From e9d15cbea7a98184521c851500176da7aa424012 Mon Sep 17 00:00:00 2001 From: russell Date: Tue, 30 Jun 2009 16:40:38 +0000 Subject: [PATCH] Move Asterisk-addons modules into the main Asterisk source tree. Someone asked yesterday, "is there a good reason why we can't just put these modules in Asterisk?". After a brief discussion, as long as the modules are clearly set aside in their own directory and not enabled by default, it is perfectly fine. For more information about why a module goes in addons, see README-addons.txt. chan_ooh323 does not currently compile as it is behind some trunk API updates. However, it will not build by default, so it should be okay for now. git-svn-id: http://svn.digium.com/svn/asterisk/trunk@204413 f38db490-d61c-443f-a65b-d21fe96a405b --- Makefile | 2 +- README-addons.txt | 27 + UPGRADE.txt | 5 + addons/Makefile | 43 + addons/app_addon_sql_mysql.c | 611 + addons/app_saycountpl.c | 136 + addons/cdr_addon_mysql.c | 641 + addons/chan_mobile.c | 4266 ++ addons/chan_ooh323.c | 3162 ++ addons/chan_ooh323.h | 113 + addons/format_mp3.c | 336 + addons/mp3/MPGLIB_README | 39 + addons/mp3/MPGLIB_TODO | 2 + addons/mp3/Makefile | 24 + addons/mp3/README | 24 + addons/mp3/common.c | 267 + addons/mp3/dct64_i386.c | 335 + addons/mp3/decode_i386.c | 153 + addons/mp3/decode_ntom.c | 219 + addons/mp3/huffman.h | 332 + addons/mp3/interface.c | 323 + addons/mp3/layer3.c | 2029 + addons/mp3/mpg123.h | 132 + addons/mp3/mpglib.h | 75 + addons/mp3/tabinit.c | 81 + addons/ooh323c/COPYING | 341 + addons/ooh323c/README | 95 + addons/ooh323c/src/Makefile.in | 564 + addons/ooh323c/src/context.c | 140 + addons/ooh323c/src/decode.c | 1050 + addons/ooh323c/src/dlist.c | 256 + addons/ooh323c/src/dlist.h | 204 + addons/ooh323c/src/encode.c | 1103 + addons/ooh323c/src/errmgmt.c | 261 + addons/ooh323c/src/eventHandler.c | 122 + addons/ooh323c/src/eventHandler.h | 284 + .../ooh323c/src/h323/H235-SECURITY-MESSAGES.h | 690 + .../src/h323/H235-SECURITY-MESSAGESDec.c | 1782 + .../src/h323/H235-SECURITY-MESSAGESEnc.c | 1269 + addons/ooh323c/src/h323/H323-MESSAGES.c | 112 + addons/ooh323c/src/h323/H323-MESSAGES.h | 6510 +++ addons/ooh323c/src/h323/H323-MESSAGESDec.c | 27199 ++++++++++ addons/ooh323c/src/h323/H323-MESSAGESEnc.c | 22596 +++++++++ .../src/h323/MULTIMEDIA-SYSTEM-CONTROL.c | 40 + .../src/h323/MULTIMEDIA-SYSTEM-CONTROL.h | 10937 ++++ .../src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c | 42170 ++++++++++++++++ .../src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c | 26599 ++++++++++ addons/ooh323c/src/memheap.c | 1331 + addons/ooh323c/src/memheap.h | 61 + addons/ooh323c/src/ooCalls.c | 820 + addons/ooh323c/src/ooCalls.h | 822 + addons/ooh323c/src/ooCapability.c | 2349 + addons/ooh323c/src/ooCapability.h | 726 + addons/ooh323c/src/ooCmdChannel.c | 193 + addons/ooh323c/src/ooCmdChannel.h | 90 + addons/ooh323c/src/ooCommon.h | 124 + addons/ooh323c/src/ooDateTime.c | 175 + addons/ooh323c/src/ooDateTime.h | 54 + addons/ooh323c/src/ooGkClient.c | 2443 + addons/ooh323c/src/ooGkClient.h | 560 + addons/ooh323c/src/ooLogChan.c | 372 + addons/ooh323c/src/ooLogChan.h | 190 + addons/ooh323c/src/ooSocket.c | 723 + addons/ooh323c/src/ooSocket.h | 403 + addons/ooh323c/src/ooStackCmds.c | 339 + addons/ooh323c/src/ooStackCmds.h | 171 + addons/ooh323c/src/ooTimer.c | 193 + addons/ooh323c/src/ooTimer.h | 128 + addons/ooh323c/src/ooUtils.c | 40 + addons/ooh323c/src/ooUtils.h | 53 + addons/ooh323c/src/ooasn1.h | 1814 + addons/ooh323c/src/oochannels.c | 1785 + addons/ooh323c/src/oochannels.h | 216 + addons/ooh323c/src/ooh245.c | 3686 ++ addons/ooh323c/src/ooh245.h | 636 + addons/ooh323c/src/ooh323.c | 1843 + addons/ooh323c/src/ooh323.h | 182 + addons/ooh323c/src/ooh323ep.c | 789 + addons/ooh323c/src/ooh323ep.h | 634 + addons/ooh323c/src/oohdr.h | 15 + addons/ooh323c/src/ooper.h | 22 + addons/ooh323c/src/ooports.c | 106 + addons/ooh323c/src/ooports.h | 91 + addons/ooh323c/src/ooq931.c | 3448 ++ addons/ooh323c/src/ooq931.h | 766 + addons/ooh323c/src/ootrace.c | 131 + addons/ooh323c/src/ootrace.h | 152 + addons/ooh323c/src/ootypes.h | 256 + addons/ooh323c/src/perutil.c | 287 + addons/ooh323c/src/printHandler.c | 273 + addons/ooh323c/src/printHandler.h | 47 + addons/ooh323c/src/rtctype.c | 168 + addons/ooh323c/src/rtctype.h | 86 + addons/ooh323cDriver.c | 361 + addons/ooh323cDriver.h | 39 + addons/res_config_mysql.c | 1752 + autoconf/ast_ext_tool_check.m4 | 2 +- build_tools/menuselect-deps.in | 2 + configs/cdr_mysql.conf.sample | 58 + configs/mobile.conf.sample | 68 + configs/mysql.conf.sample | 24 + configs/ooh323.conf.sample | 173 + configs/res_mysql.conf.sample | 40 + configure | 567 +- configure.ac | 18 +- doc/tex/Makefile | 2 +- doc/tex/asterisk.tex | 4 +- doc/tex/cdrdriver.tex | 32 + doc/tex/chan_mobile.tex | 262 + include/asterisk/autoconfig.h.in | 9 + include/asterisk/mod_format.h | 1 + main/file.c | 25 + makeopts.in | 6 + 113 files changed, 190907 insertions(+), 32 deletions(-) create mode 100644 README-addons.txt create mode 100644 addons/Makefile create mode 100644 addons/app_addon_sql_mysql.c create mode 100644 addons/app_saycountpl.c create mode 100644 addons/cdr_addon_mysql.c create mode 100644 addons/chan_mobile.c create mode 100644 addons/chan_ooh323.c create mode 100644 addons/chan_ooh323.h create mode 100644 addons/format_mp3.c create mode 100644 addons/mp3/MPGLIB_README create mode 100644 addons/mp3/MPGLIB_TODO create mode 100644 addons/mp3/Makefile create mode 100644 addons/mp3/README create mode 100644 addons/mp3/common.c create mode 100644 addons/mp3/dct64_i386.c create mode 100644 addons/mp3/decode_i386.c create mode 100644 addons/mp3/decode_ntom.c create mode 100644 addons/mp3/huffman.h create mode 100644 addons/mp3/interface.c create mode 100644 addons/mp3/layer3.c create mode 100644 addons/mp3/mpg123.h create mode 100644 addons/mp3/mpglib.h create mode 100644 addons/mp3/tabinit.c create mode 100644 addons/ooh323c/COPYING create mode 100644 addons/ooh323c/README create mode 100644 addons/ooh323c/src/Makefile.in create mode 100644 addons/ooh323c/src/context.c create mode 100644 addons/ooh323c/src/decode.c create mode 100644 addons/ooh323c/src/dlist.c create mode 100644 addons/ooh323c/src/dlist.h create mode 100644 addons/ooh323c/src/encode.c create mode 100644 addons/ooh323c/src/errmgmt.c create mode 100644 addons/ooh323c/src/eventHandler.c create mode 100644 addons/ooh323c/src/eventHandler.h create mode 100644 addons/ooh323c/src/h323/H235-SECURITY-MESSAGES.h create mode 100644 addons/ooh323c/src/h323/H235-SECURITY-MESSAGESDec.c create mode 100644 addons/ooh323c/src/h323/H235-SECURITY-MESSAGESEnc.c create mode 100644 addons/ooh323c/src/h323/H323-MESSAGES.c create mode 100644 addons/ooh323c/src/h323/H323-MESSAGES.h create mode 100644 addons/ooh323c/src/h323/H323-MESSAGESDec.c create mode 100644 addons/ooh323c/src/h323/H323-MESSAGESEnc.c create mode 100644 addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.c create mode 100644 addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.h create mode 100644 addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c create mode 100644 addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c create mode 100644 addons/ooh323c/src/memheap.c create mode 100644 addons/ooh323c/src/memheap.h create mode 100644 addons/ooh323c/src/ooCalls.c create mode 100644 addons/ooh323c/src/ooCalls.h create mode 100644 addons/ooh323c/src/ooCapability.c create mode 100644 addons/ooh323c/src/ooCapability.h create mode 100644 addons/ooh323c/src/ooCmdChannel.c create mode 100644 addons/ooh323c/src/ooCmdChannel.h create mode 100644 addons/ooh323c/src/ooCommon.h create mode 100644 addons/ooh323c/src/ooDateTime.c create mode 100644 addons/ooh323c/src/ooDateTime.h create mode 100644 addons/ooh323c/src/ooGkClient.c create mode 100644 addons/ooh323c/src/ooGkClient.h create mode 100644 addons/ooh323c/src/ooLogChan.c create mode 100644 addons/ooh323c/src/ooLogChan.h create mode 100644 addons/ooh323c/src/ooSocket.c create mode 100644 addons/ooh323c/src/ooSocket.h create mode 100644 addons/ooh323c/src/ooStackCmds.c create mode 100644 addons/ooh323c/src/ooStackCmds.h create mode 100644 addons/ooh323c/src/ooTimer.c create mode 100644 addons/ooh323c/src/ooTimer.h create mode 100644 addons/ooh323c/src/ooUtils.c create mode 100644 addons/ooh323c/src/ooUtils.h create mode 100644 addons/ooh323c/src/ooasn1.h create mode 100644 addons/ooh323c/src/oochannels.c create mode 100644 addons/ooh323c/src/oochannels.h create mode 100644 addons/ooh323c/src/ooh245.c create mode 100644 addons/ooh323c/src/ooh245.h create mode 100644 addons/ooh323c/src/ooh323.c create mode 100644 addons/ooh323c/src/ooh323.h create mode 100644 addons/ooh323c/src/ooh323ep.c create mode 100644 addons/ooh323c/src/ooh323ep.h create mode 100644 addons/ooh323c/src/oohdr.h create mode 100644 addons/ooh323c/src/ooper.h create mode 100644 addons/ooh323c/src/ooports.c create mode 100644 addons/ooh323c/src/ooports.h create mode 100644 addons/ooh323c/src/ooq931.c create mode 100644 addons/ooh323c/src/ooq931.h create mode 100644 addons/ooh323c/src/ootrace.c create mode 100644 addons/ooh323c/src/ootrace.h create mode 100644 addons/ooh323c/src/ootypes.h create mode 100644 addons/ooh323c/src/perutil.c create mode 100644 addons/ooh323c/src/printHandler.c create mode 100644 addons/ooh323c/src/printHandler.h create mode 100644 addons/ooh323c/src/rtctype.c create mode 100644 addons/ooh323c/src/rtctype.h create mode 100644 addons/ooh323cDriver.c create mode 100644 addons/ooh323cDriver.h create mode 100644 addons/res_config_mysql.c create mode 100644 configs/cdr_mysql.conf.sample create mode 100644 configs/mobile.conf.sample create mode 100644 configs/mysql.conf.sample create mode 100644 configs/ooh323.conf.sample create mode 100644 configs/res_mysql.conf.sample create mode 100644 doc/tex/chan_mobile.tex diff --git a/Makefile b/Makefile index a74b95b9d..0d57d651d 100644 --- a/Makefile +++ b/Makefile @@ -293,7 +293,7 @@ endif # value directly to ASTCFLAGS ASTCFLAGS+=$(MALLOC_DEBUG)$(OPTIONS) -MOD_SUBDIRS:=channels pbx apps codecs formats cdr cel bridges funcs tests main res $(LOCAL_MOD_SUBDIRS) +MOD_SUBDIRS:=addons channels pbx apps codecs formats cdr cel bridges funcs tests main res $(LOCAL_MOD_SUBDIRS) OTHER_SUBDIRS:=utils agi SUBDIRS:=$(OTHER_SUBDIRS) $(MOD_SUBDIRS) SUBDIRS_INSTALL:=$(SUBDIRS:%=%-install) diff --git a/README-addons.txt b/README-addons.txt new file mode 100644 index 000000000..4d5e1986f --- /dev/null +++ b/README-addons.txt @@ -0,0 +1,27 @@ +=============================================================================== +=== Asterisk Add-on Modules === +=============================================================================== + + This document pertains to the modules that reside in the addons/ +subdirectory of the source tree. By default, these modules are not compiled +and installed. If you choose to enable them, you must be aware of what +potential licensing and/or patent implications that has on your usage and +distribution of Asterisk. + + Even though Asterisk is released as open source under the terms of the +GPLv2 (see LICENSE for details), no core functionality in Asterisk has any +dependencies on libraries that are licensed under the GPL. One reason a module +may be in the add-ons category is that it may have a GPL dependency. Since +these dependencies are not compatible with dual licensing of Asterisk, the +dependant modules are set aside to make it clear that they may not be used +with commercial versions of Asterisk, unless other licensing arrangements are +made with the copyright holders of those dependencies. + + Another reason that modules may be set aside is that there may be +additional restrictions on the usage of the code imposed by the license or +related patents. The MySQL and MP3 modules are examples of this. + + If you have any questions, contact your lawyer. + +=============================================================================== +=============================================================================== diff --git a/UPGRADE.txt b/UPGRADE.txt index d670e414d..651ea18e0 100644 --- a/UPGRADE.txt +++ b/UPGRADE.txt @@ -20,6 +20,11 @@ From 1.6.2 to 1.6.3: +* Asterisk-addons no longer exists as an independent package. Those modules + now live in the addons directory of the main Asterisk source tree. They + are not enabled by default. For more information about why modules live in + addons, see README-addons.txt. + * The rarely used 'event_log' and LOG_EVENT channel have been removed; the few users of this channel in the tree have been converted to LOG_NOTICE or removed (in cases where the same message was already generated to another channel). diff --git a/addons/Makefile b/addons/Makefile new file mode 100644 index 000000000..c93759702 --- /dev/null +++ b/addons/Makefile @@ -0,0 +1,43 @@ +# +# Asterisk -- A telephony toolkit for Linux. +# +# Makefile for Add-on Modules +# +# Copyright (C) 2009, Digium, Inc. +# +# This program is free software, distributed under the terms of +# the GNU General Public License +# + +-include $(ASTTOPDIR)/menuselect.makeopts $(ASTTOPDIR)/menuselect.makedeps + +MODULE_PREFIX=app bridge cdr cel chan codec format func pbx res test +MENUSELECT_CATEGORY=Addons +MENUSELECT_DESCRIPTION=Add-ons (See README-addons.txt) + +H323OBJS:=ooCmdChannel.o ooLogChan.o ooUtils.o ooGkClient.o context.o \ + ooDateTime.o decode.o dlist.o encode.o errmgmt.o \ + memheap.o ootrace.o oochannels.o ooh245.o ooports.o \ + ooq931.o ooCapability.o ooSocket.o perutil.o eventHandler.o \ + ooCalls.o ooStackCmds.o ooh323.o ooh323ep.o printHandler.o \ + rtctype.o ooTimer.o h323/H235-SECURITY-MESSAGESDec.o \ + h323/H235-SECURITY-MESSAGESEnc.o h323/H323-MESSAGES.o h323/H323-MESSAGESDec.o \ + h323/H323-MESSAGESEnc.o h323/MULTIMEDIA-SYSTEM-CONTROL.o \ + h323/MULTIMEDIA-SYSTEM-CONTROLDec.o h323/MULTIMEDIA-SYSTEM-CONTROLEnc.o + +H323CFLAGS:=-Iooh323c/src -Iooh323c/src/h323 + +all: _all + +include $(ASTTOPDIR)/Makefile.moddir_rules + +clean:: + $(MAKE) -C mp3 clean + rm -f $(addprefix ooh323c/src/,$(H323OBJS)) + +$(if $(filter format_mp3,$(EMBEDDED_MODS)),modules.link,format_mp3.so): mp3/common.o mp3/dct64_i386.o mp3/decode_ntom.o mp3/layer3.o mp3/tabinit.o mp3/interface.o + +chan_ooh323.o: ASTCFLAGS+=$(H323CFLAGS) + +$(if $(filter chan_ooh323,$(EMBEDDED_MODS)),modules.link,chan_ooh323.so): ASTCFLAGS+=$(H323CFLAGS) +$(if $(filter chan_ooh323,$(EMBEDDED_MODS)),modules.link,chan_ooh323.so): $(addprefix ooh323c/src/,$(H323OBJS)) chan_ooh323.o ooh323cDriver.o diff --git a/addons/app_addon_sql_mysql.c b/addons/app_addon_sql_mysql.c new file mode 100644 index 000000000..db33c11cb --- /dev/null +++ b/addons/app_addon_sql_mysql.c @@ -0,0 +1,611 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2004, Constantine Filin and Christos Ricudis + * + * Christos Ricudis + * Constantine Filin + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! + * \file + * \brief MYSQL dialplan application + * \ingroup applications + */ + +/*** MODULEINFO + mysqlclient + no + ***/ + +#include "asterisk.h" + +#include + +#include "asterisk/file.h" +#include "asterisk/logger.h" +#include "asterisk/channel.h" +#include "asterisk/pbx.h" +#include "asterisk/module.h" +#include "asterisk/linkedlists.h" +#include "asterisk/chanvars.h" +#include "asterisk/lock.h" +#include "asterisk/options.h" +#include "asterisk/app.h" +#include "asterisk/config.h" + +#define EXTRA_LOG 0 + +enum { NULLSTRING, NULLVALUE, EMPTYSTRING } nullvalue = NULLSTRING; + +static const char app[] = "MYSQL"; + +static const char synopsis[] = "Do several mySQLy things"; + +static const char descrip[] = +"MYSQL(): Do several mySQLy things\n" +"Syntax:\n" +" MYSQL(Set timeout )\n" +" Set the connection timeout, in seconds.\n" +" MYSQL(Connect connid dhhost dbuser dbpass dbname)\n" +" Connects to a database. Arguments contain standard MySQL parameters\n" +" passed to function mysql_real_connect. Connection identifer returned\n" +" in ${connid}\n" +" MYSQL(Query resultid ${connid} query-string)\n" +" Executes standard MySQL query contained in query-string using established\n" +" connection identified by ${connid}. Result of query is stored in ${resultid}.\n" +" MYSQL(Nextresult resultid ${connid}\n" +" If last query returned more than one result set, it stores the next\n" +" result set in ${resultid}. It's useful with stored procedures\n" +" MYSQL(Fetch fetchid ${resultid} var1 var2 ... varN)\n" +" Fetches a single row from a result set contained in ${result_identifier}.\n" +" Assigns returned fields to ${var1} ... ${varn}. ${fetchid} is set TRUE\n" +" if additional rows exist in result set.\n" +" MYSQL(Clear ${resultid})\n" +" Frees memory and datastructures associated with result set.\n" +" MYSQL(Disconnect ${connid})\n" +" Disconnects from named connection to MySQL.\n" +" On exit, always returns 0. Sets MYSQL_STATUS to 0 on success and -1 on error.\n"; + +/* +EXAMPLES OF USE : + +exten => s,2,MYSQL(Connect connid localhost asterisk mypass credit) +exten => s,3,MYSQL(Query resultid ${connid} SELECT username,credit FROM credit WHERE callerid=${CALLERIDNUM}) +exten => s,4,MYSQL(Fetch fetchid ${resultid} datavar1 datavar2) +exten => s,5,GotoIf(${fetchid}?6:8) +exten => s,6,Festival("User ${datavar1} currently has credit balance of ${datavar2} dollars.") +exten => s,7,Goto(s,4) +exten => s,8,MYSQL(Clear ${resultid}) +exten => s,9,MYSQL(Disconnect ${connid}) +*/ + +AST_MUTEX_DEFINE_STATIC(_mysql_mutex); + +#define MYSQL_CONFIG "mysql.conf" +#define AST_MYSQL_ID_DUMMY 0 +#define AST_MYSQL_ID_CONNID 1 +#define AST_MYSQL_ID_RESID 2 +#define AST_MYSQL_ID_FETCHID 3 + +static int autoclear = 0; + +static void mysql_ds_destroy(void *data); +static void mysql_ds_fixup(void *data, struct ast_channel *oldchan, struct ast_channel *newchan); + +static struct ast_datastore_info mysql_ds_info = { + .type = "APP_ADDON_SQL_MYSQL", + .destroy = mysql_ds_destroy, + .chan_fixup = mysql_ds_fixup, +}; + +struct ast_MYSQL_id { + struct ast_channel *owner; + int identifier_type; /* 0=dummy, 1=connid, 2=resultid */ + int identifier; + void *data; + AST_LIST_ENTRY(ast_MYSQL_id) entries; +} *ast_MYSQL_id; + +AST_LIST_HEAD(MYSQLidshead,ast_MYSQL_id) _mysql_ids_head; + +static void mysql_ds_destroy(void *data) +{ + /* Destroy any IDs owned by the channel */ + struct ast_MYSQL_id *i; + if (AST_LIST_LOCK(&_mysql_ids_head)) { + ast_log(LOG_WARNING, "Unable to lock identifiers list\n"); + } else { + AST_LIST_TRAVERSE_SAFE_BEGIN(&_mysql_ids_head, i, entries) { + if (i->owner == data) { + AST_LIST_REMOVE_CURRENT(entries); + if (i->identifier_type == AST_MYSQL_ID_CONNID) { + /* Drop connection */ + mysql_close(i->data); + } else if (i->identifier_type == AST_MYSQL_ID_RESID) { + /* Drop result */ + mysql_free_result(i->data); + } + ast_free(i); + } + } + AST_LIST_TRAVERSE_SAFE_END + AST_LIST_UNLOCK(&_mysql_ids_head); + } +} + +static void mysql_ds_fixup(void *data, struct ast_channel *oldchan, struct ast_channel *newchan) +{ + /* Destroy any IDs owned by the channel */ + struct ast_MYSQL_id *i; + if (AST_LIST_LOCK(&_mysql_ids_head)) { + ast_log(LOG_WARNING, "Unable to lock identifiers list\n"); + } else { + AST_LIST_TRAVERSE_SAFE_BEGIN(&_mysql_ids_head, i, entries) { + if (i->owner == data) { + AST_LIST_REMOVE_CURRENT(entries); + if (i->identifier_type == AST_MYSQL_ID_CONNID) { + /* Drop connection */ + mysql_close(i->data); + } else if (i->identifier_type == AST_MYSQL_ID_RESID) { + /* Drop result */ + mysql_free_result(i->data); + } + ast_free(i); + } + } + AST_LIST_TRAVERSE_SAFE_END + AST_LIST_UNLOCK(&_mysql_ids_head); + } +} + +/* helpful procs */ +static void *find_identifier(int identifier, int identifier_type) +{ + struct MYSQLidshead *headp = &_mysql_ids_head; + struct ast_MYSQL_id *i; + void *res=NULL; + int found=0; + + if (AST_LIST_LOCK(headp)) { + ast_log(LOG_WARNING, "Unable to lock identifiers list\n"); + } else { + AST_LIST_TRAVERSE(headp, i, entries) { + if ((i->identifier == identifier) && (i->identifier_type == identifier_type)) { + found = 1; + res = i->data; + break; + } + } + if (!found) { + ast_log(LOG_WARNING, "Identifier %d, identifier_type %d not found in identifier list\n", identifier, identifier_type); + } + AST_LIST_UNLOCK(headp); + } + + return res; +} + +static int add_identifier(struct ast_channel *chan, int identifier_type, void *data) +{ + struct ast_MYSQL_id *i = NULL, *j = NULL; + struct MYSQLidshead *headp = &_mysql_ids_head; + int maxidentifier = 0; + + if (AST_LIST_LOCK(headp)) { + ast_log(LOG_WARNING, "Unable to lock identifiers list\n"); + return -1; + } else { + i = malloc(sizeof(*i)); + AST_LIST_TRAVERSE(headp, j, entries) { + if (j->identifier > maxidentifier) { + maxidentifier = j->identifier; + } + } + i->identifier = maxidentifier + 1; + i->identifier_type = identifier_type; + i->data = data; + i->owner = chan; + AST_LIST_INSERT_HEAD(headp, i, entries); + AST_LIST_UNLOCK(headp); + } + return i->identifier; +} + +static int del_identifier(int identifier, int identifier_type) +{ + struct ast_MYSQL_id *i; + struct MYSQLidshead *headp = &_mysql_ids_head; + int found = 0; + + if (AST_LIST_LOCK(headp)) { + ast_log(LOG_WARNING, "Unable to lock identifiers list\n"); + } else { + AST_LIST_TRAVERSE(headp, i, entries) { + if ((i->identifier == identifier) && + (i->identifier_type == identifier_type)) { + AST_LIST_REMOVE(headp, i, entries); + free(i); + found = 1; + break; + } + } + AST_LIST_UNLOCK(headp); + } + + if (found == 0) { + ast_log(LOG_WARNING, "Could not find identifier %d, identifier_type %d in list to delete\n", identifier, identifier_type); + return -1; + } else { + return 0; + } +} + +static int set_asterisk_int(struct ast_channel *chan, char *varname, int id) +{ + if (id >= 0) { + char s[12] = ""; + snprintf(s, sizeof(s), "%d", id); + ast_debug(5, "MYSQL: setting var '%s' to value '%s'\n", varname, s); + pbx_builtin_setvar_helper(chan, varname, s); + } + return id; +} + +static int add_identifier_and_set_asterisk_int(struct ast_channel *chan, char *varname, int identifier_type, void *data) +{ + return set_asterisk_int(chan, varname, add_identifier(chan, identifier_type, data)); +} + +static int safe_scan_int(char **data, char *delim, int def) +{ + char *end; + int res = def; + char *s = strsep(data, delim); + if (s) { + res = strtol(s, &end, 10); + if (*end) + res = def; /* not an integer */ + } + return res; +} + +static int aMYSQL_set(struct ast_channel *chan, char *data) +{ + char *var, *tmp; + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(set); + AST_APP_ARG(variable); + AST_APP_ARG(value); + ); + + AST_NONSTANDARD_APP_ARGS(args, data, ' '); + + if (args.argc == 3) { + var = alloca(6 + strlen(args.variable) + 1); + sprintf(var, "MYSQL_%s", args.variable); + + /* Make the parameter case-insensitive */ + for (tmp = var + 6; *tmp; tmp++) + *tmp = toupper(*tmp); + + pbx_builtin_setvar_helper(chan, var, args.value); + } + return 0; +} + +/* MYSQL operations */ +static int aMYSQL_connect(struct ast_channel *chan, char *data) +{ + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(connect); + AST_APP_ARG(connid); + AST_APP_ARG(dbhost); + AST_APP_ARG(dbuser); + AST_APP_ARG(dbpass); + AST_APP_ARG(dbname); + ); + MYSQL *mysql; + int timeout; + const char *ctimeout; + + AST_NONSTANDARD_APP_ARGS(args, data, ' '); + + if (args.argc != 6) { + ast_log(LOG_WARNING, "MYSQL_connect is missing some arguments\n"); + return -1; + } + + if (!(mysql = mysql_init(NULL))) { + ast_log(LOG_WARNING, "mysql_init returned NULL\n"); + return -1; + } + + ctimeout = pbx_builtin_getvar_helper(chan, "MYSQL_TIMEOUT"); + if (ctimeout && sscanf(ctimeout, "%d", &timeout) == 1) { + mysql_options(mysql, MYSQL_OPT_CONNECT_TIMEOUT, (void *)&timeout); + } + + if (! mysql_real_connect(mysql, args.dbhost, args.dbuser, args.dbpass, args.dbname, 0, NULL, +#ifdef CLIENT_MULTI_STATEMENTS + CLIENT_MULTI_STATEMENTS | CLIENT_MULTI_RESULTS +#elif defined(CLIENT_MULTI_QUERIES) + CLIENT_MULTI_QUERIES +#else + 0 +#endif + )) { + ast_log(LOG_WARNING, "mysql_real_connect(mysql,%s,%s,dbpass,%s,...) failed(%d): %s\n", + args.dbhost, args.dbuser, args.dbname, mysql_errno(mysql), mysql_error(mysql)); + return -1; + } + + add_identifier_and_set_asterisk_int(chan, args.connid, AST_MYSQL_ID_CONNID, mysql); + return 0; +} + +static int aMYSQL_query(struct ast_channel *chan, char *data) +{ + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(query); + AST_APP_ARG(resultid); + AST_APP_ARG(connid); + AST_APP_ARG(sql); + ); + MYSQL *mysql; + MYSQL_RES *mysqlres; + int connid; + int mysql_query_res; + + AST_NONSTANDARD_APP_ARGS(args, data, ' '); + + if (args.argc != 4 || (connid = atoi(args.connid)) == 0) { + ast_log(LOG_WARNING, "missing some arguments\n"); + return -1; + } + + if (!(mysql = find_identifier(connid, AST_MYSQL_ID_CONNID))) { + ast_log(LOG_WARNING, "Invalid connection identifier %s passed in aMYSQL_query\n", args.connid); + return -1; + } + + if ((mysql_query_res = mysql_query(mysql, args.sql)) != 0) { + ast_log(LOG_WARNING, "aMYSQL_query: mysql_query failed. Error: %s\n", mysql_error(mysql)); + return -1; + } + + if ((mysqlres = mysql_store_result(mysql))) { + add_identifier_and_set_asterisk_int(chan, args.resultid, AST_MYSQL_ID_RESID, mysqlres); + return 0; + } else if (!mysql_field_count(mysql)) { + return 0; + } else + ast_log(LOG_WARNING, "mysql_store_result() failed on query %s\n", args.sql); + + return -1; +} + +static int aMYSQL_nextresult(struct ast_channel *chan, char *data) +{ + MYSQL *mysql; + MYSQL_RES *mysqlres; + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(nextresult); + AST_APP_ARG(resultid); + AST_APP_ARG(connid); + ); + int connid = -1; + + AST_NONSTANDARD_APP_ARGS(args, data, ' '); + sscanf(args.connid, "%d", &connid); + + if (args.argc != 3 || connid <= 0) { + ast_log(LOG_WARNING, "missing some arguments\n"); + return -1; + } + + if (!(mysql = find_identifier(connid, AST_MYSQL_ID_CONNID))) { + ast_log(LOG_WARNING, "Invalid connection identifier %d passed in aMYSQL_query\n", connid); + return -1; + } + + if (mysql_more_results(mysql)) { + mysql_next_result(mysql); + if ((mysqlres = mysql_store_result(mysql))) { + add_identifier_and_set_asterisk_int(chan, args.resultid, AST_MYSQL_ID_RESID, mysqlres); + return 0; + } else if (!mysql_field_count(mysql)) { + return 0; + } else + ast_log(LOG_WARNING, "mysql_store_result() failed on storing next_result\n"); + } else + ast_log(LOG_WARNING, "mysql_more_results() result set has no more results\n"); + + return 0; +} + + +static int aMYSQL_fetch(struct ast_channel *chan, char *data) +{ + MYSQL_RES *mysqlres; + MYSQL_ROW mysqlrow; + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(fetch); + AST_APP_ARG(resultvar); + AST_APP_ARG(fetchid); + AST_APP_ARG(vars); + ); + char *s5, *parse; + int resultid = -1, numFields, j; + + parse = ast_strdupa(data); + AST_NONSTANDARD_APP_ARGS(args, parse, ' '); + sscanf(args.fetchid, "%d", &resultid); + + if (args.resultvar && (resultid >= 0) ) { + if ((mysqlres = find_identifier(resultid, AST_MYSQL_ID_RESID)) != NULL) { + /* Grab the next row */ + if ((mysqlrow = mysql_fetch_row(mysqlres)) != NULL) { + numFields = mysql_num_fields(mysqlres); + for (j = 0; j < numFields; j++) { + s5 = strsep(&args.vars, " "); + if (s5 == NULL) { + ast_log(LOG_WARNING, "ast_MYSQL_fetch: More fields (%d) than variables (%d)\n", numFields, j); + break; + } + + pbx_builtin_setvar_helper(chan, s5, mysqlrow[j] ? mysqlrow[j] : + nullvalue == NULLSTRING ? "NULL" : + nullvalue == EMPTYSTRING ? "" : + NULL); + } + ast_debug(5, "ast_MYSQL_fetch: numFields=%d\n", numFields); + set_asterisk_int(chan, args.resultvar, 1); /* try more rows */ + } else { + ast_debug(5, "ast_MYSQL_fetch : EOF\n"); + set_asterisk_int(chan, args.resultvar, 0); /* no more rows */ + } + return 0; + } else { + set_asterisk_int(chan, args.resultvar, 0); + ast_log(LOG_WARNING, "aMYSQL_fetch: Invalid result identifier %d passed\n", resultid); + } + } else { + ast_log(LOG_WARNING, "aMYSQL_fetch: missing some arguments\n"); + } + + return -1; +} + +static int aMYSQL_clear(struct ast_channel *chan, char *data) +{ + MYSQL_RES *mysqlres; + + int id; + strsep(&data, " "); /* eat the first token, we already know it :P */ + id = safe_scan_int(&data, " \n", -1); + if ((mysqlres = find_identifier(id, AST_MYSQL_ID_RESID)) == NULL) { + ast_log(LOG_WARNING, "Invalid result identifier %d passed in aMYSQL_clear\n", id); + } else { + mysql_free_result(mysqlres); + del_identifier(id, AST_MYSQL_ID_RESID); + } + + return 0; +} + +static int aMYSQL_disconnect(struct ast_channel *chan, char *data) +{ + MYSQL *mysql; + int id; + strsep(&data, " "); /* eat the first token, we already know it :P */ + + id = safe_scan_int(&data, " \n", -1); + if ((mysql = find_identifier(id, AST_MYSQL_ID_CONNID)) == NULL) { + ast_log(LOG_WARNING, "Invalid connection identifier %d passed in aMYSQL_disconnect\n", id); + } else { + mysql_close(mysql); + del_identifier(id, AST_MYSQL_ID_CONNID); + } + + return 0; +} + +static int MYSQL_exec(struct ast_channel *chan, const char *data) +{ + int result; + char sresult[10]; + + ast_debug(5, "MYSQL: data=%s\n", data); + + if (!data) { + ast_log(LOG_WARNING, "MYSQL requires an argument (see manual)\n"); + return -1; + } + + result = 0; + + if (autoclear) { + struct ast_datastore *mysql_store = ast_channel_datastore_find(chan, &mysql_ds_info, NULL); + if (!mysql_store) { + if (!(mysql_store = ast_datastore_alloc(&mysql_ds_info, NULL))) { + ast_log(LOG_WARNING, "Unable to allocate new datastore.\n"); + } else { + mysql_store->data = chan; + ast_channel_datastore_add(chan, mysql_store); + } + } + } + ast_mutex_lock(&_mysql_mutex); + + if (strncasecmp("connect", data, strlen("connect")) == 0) { + result = aMYSQL_connect(chan, ast_strdupa(data)); + } else if (strncasecmp("query", data, strlen("query")) == 0) { + result = aMYSQL_query(chan, ast_strdupa(data)); + } else if (strncasecmp("nextresult", data, strlen("nextresult")) == 0) { + result = aMYSQL_nextresult(chan, ast_strdupa(data)); + } else if (strncasecmp("fetch", data, strlen("fetch")) == 0) { + result = aMYSQL_fetch(chan, ast_strdupa(data)); + } else if (strncasecmp("clear", data, strlen("clear")) == 0) { + result = aMYSQL_clear(chan, ast_strdupa(data)); + } else if (strncasecmp("disconnect", data, strlen("disconnect")) == 0) { + result = aMYSQL_disconnect(chan, ast_strdupa(data)); + } else if (strncasecmp("set", data, 3) == 0) { + result = aMYSQL_set(chan, ast_strdupa(data)); + } else { + ast_log(LOG_WARNING, "Unknown argument to MYSQL application : %s\n", data); + result = -1; + } + + ast_mutex_unlock(&_mysql_mutex); + + snprintf(sresult, sizeof(sresult), "%d", result); + pbx_builtin_setvar_helper(chan, "MYSQL_STATUS", sresult); + return 0; +} + +static int unload_module(void) +{ + return ast_unregister_application(app); +} + +static int load_module(void) +{ + struct MYSQLidshead *headp = &_mysql_ids_head; + struct ast_flags config_flags = { 0 }; + struct ast_config *cfg = ast_config_load(MYSQL_CONFIG, config_flags); + const char *temp; + + if (cfg) { + if ((temp = ast_variable_retrieve(cfg, "general", "nullvalue"))) { + if (!strcasecmp(temp, "nullstring")) { + nullvalue = NULLSTRING; + } else if (!strcasecmp(temp, "emptystring")) { + nullvalue = EMPTYSTRING; + } else if (!strcasecmp(temp, "null")) { + nullvalue = NULLVALUE; + } else { + ast_log(LOG_WARNING, "Illegal value for 'nullvalue': '%s' (must be 'nullstring', 'null', or 'emptystring')\n", temp); + } + } + if ((temp = ast_variable_retrieve(cfg, "general", "autoclear")) && ast_true(temp)) { + autoclear = 1; + } + ast_config_destroy(cfg); + } + + AST_LIST_HEAD_INIT(headp); + return ast_register_application(app, MYSQL_exec, synopsis, descrip); +} + +AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Simple Mysql Interface"); diff --git a/addons/app_saycountpl.c b/addons/app_saycountpl.c new file mode 100644 index 000000000..fd921de1a --- /dev/null +++ b/addons/app_saycountpl.c @@ -0,0 +1,136 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 2004, Andy Powell & TAAN Softworks Corp. + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! + * \file + * \brief Say Polish counting words + * \author Andy Powell + */ + +/*** MODULEINFO + no + ***/ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include "asterisk/file.h" +#include "asterisk/logger.h" +#include "asterisk/channel.h" +#include "asterisk/pbx.h" +#include "asterisk/module.h" +#include "asterisk/lock.h" +#include "asterisk/app.h" + +/*** DOCUMENTATION + + + Say Polish counting words. + + + + + + + + + Polish grammar has some funny rules for counting words. for example 1 zloty, + 2 zlote, 5 zlotych. This application will take the words for 1, 2-4 and 5 and + decide based on grammar rules which one to use with the number you pass to it. + Example: SayCountPL(zloty,zlote,zlotych,122) will give: zlote + + + + ***/ +static const char app[] = "SayCountPL"; + +static int saywords(struct ast_channel *chan, char *word1, char *word2, char *word5, int num) +{ + /* Put this in a separate proc because it's bound to change */ + int d = 0; + + if (num > 0) { + if (num % 1000 == 1) { + ast_streamfile(chan, word1, chan->language); + d = ast_waitstream(chan,""); + } else if (((num % 10) >= 2) && ((num % 10) <= 4 ) && ((num % 100) < 10 || (num % 100) > 20)) { + ast_streamfile(chan, word2, chan->language); + d = ast_waitstream(chan, ""); + } else { + ast_streamfile(chan, word5, chan->language); + d = ast_waitstream(chan, ""); + } + } + + return d; +} + + +static int sayword_exec(struct ast_channel *chan, const char *data) +{ + int res = 0; + char *s; + int inum; + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(word1); + AST_APP_ARG(word2); + AST_APP_ARG(word5); + AST_APP_ARG(num); + ); + + if (!data) { + ast_log(LOG_WARNING, "SayCountPL requires 4 arguments: word-1,word-2,word-5,number\n"); + return -1; + } + + s = ast_strdupa(data); + + AST_STANDARD_APP_ARGS(args, s); + + /* Check to see if params passed */ + if (!args.word1 || !args.word2 || !args.word5 || !args.num) { + ast_log(LOG_WARNING, "SayCountPL requires 4 arguments: word-1,word-2,word-3,number\n"); + return -1; + } + + if (sscanf(args.num, "%d", &inum) != 1) { + ast_log(LOG_WARNING, "'%s' is not a valid number\n", args.num); + return -1; + } + + /* do the saying part (after a bit of maths) */ + + res = saywords(chan, args.word1, args.word2, args.word5, inum); + + return res; +} + +static int unload_module(void) +{ + return ast_unregister_application(app); +} + +static int load_module(void) +{ + int res; + + res = ast_register_application_xml(app, sayword_exec); + + return res ? AST_MODULE_LOAD_DECLINE : AST_MODULE_LOAD_SUCCESS; +} + +AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Say polish counting words"); diff --git a/addons/cdr_addon_mysql.c b/addons/cdr_addon_mysql.c new file mode 100644 index 000000000..2a3ef4365 --- /dev/null +++ b/addons/cdr_addon_mysql.c @@ -0,0 +1,641 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * James Sharp + * + * Modified August 2003 + * Tilghman Lesher + * + * Modified August 6, 2005 + * Joseph Benden + * Added mysql connection timeout parameter + * Added an automatic reconnect as to not lose a cdr record + * Cleaned up the original code to match the coding guidelines + * + * Modified Juli 2006 + * Martin Portmann + * Added mysql ssl support + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! + * \file + * \brief MySQL CDR backend + * \ingroup cdr_drivers + */ + +/*** MODULEINFO + mysqlclient + no + ***/ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include +#include + +#include "asterisk/config.h" +#include "asterisk/options.h" +#include "asterisk/channel.h" +#include "asterisk/cdr.h" +#include "asterisk/module.h" +#include "asterisk/logger.h" +#include "asterisk/cli.h" +#include "asterisk/strings.h" +#include "asterisk/linkedlists.h" +#include "asterisk/threadstorage.h" + +#define DATE_FORMAT "%Y-%m-%d %T" + +AST_THREADSTORAGE(sql1_buf); +AST_THREADSTORAGE(sql2_buf); +AST_THREADSTORAGE(escape_buf); + +static const char desc[] = "MySQL CDR Backend"; +static const char name[] = "mysql"; +static const char config[] = "cdr_mysql.conf"; + +static struct ast_str *hostname = NULL, *dbname = NULL, *dbuser = NULL, *password = NULL, *dbsock = NULL, *dbtable = NULL, *dbcharset = NULL; + +static struct ast_str *ssl_ca = NULL, *ssl_cert = NULL, *ssl_key = NULL; + +static int dbport = 0; +static int connected = 0; +static time_t connect_time = 0; +static int records = 0; +static int totalrecords = 0; +static int timeout = 0; +static int calldate_compat = 0; + +AST_MUTEX_DEFINE_STATIC(mysql_lock); + +struct unload_string { + AST_LIST_ENTRY(unload_string) entry; + struct ast_str *str; +}; + +static AST_LIST_HEAD_STATIC(unload_strings, unload_string); + +struct column { + char *name; + char *cdrname; + char *staticvalue; + char *type; + AST_LIST_ENTRY(column) list; +}; + +/* Protected with mysql_lock */ +static AST_RWLIST_HEAD_STATIC(columns, column); + +static MYSQL mysql = { { NULL }, }; + +static char *handle_cli_cdr_mysql_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + switch (cmd) { + case CLI_INIT: + e->command = "cdr mysql status"; + e->usage = + "Usage: cdr mysql status\n" + " Shows current connection status for cdr_mysql\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 3) + return CLI_SHOWUSAGE; + + if (connected) { + char status[256], status2[100] = ""; + int ctime = time(NULL) - connect_time; + if (dbport) + snprintf(status, 255, "Connected to %s@%s, port %d", ast_str_buffer(dbname), ast_str_buffer(hostname), dbport); + else if (dbsock) + snprintf(status, 255, "Connected to %s on socket file %s", ast_str_buffer(dbname), S_OR(ast_str_buffer(dbsock), "default")); + else + snprintf(status, 255, "Connected to %s@%s", ast_str_buffer(dbname), ast_str_buffer(hostname)); + + if (!ast_strlen_zero(ast_str_buffer(dbuser))) + snprintf(status2, 99, " with username %s", ast_str_buffer(dbuser)); + if (ast_str_strlen(dbtable)) + snprintf(status2, 99, " using table %s", ast_str_buffer(dbtable)); + if (ctime > 31536000) { + ast_cli(a->fd, "%s%s for %d years, %d days, %d hours, %d minutes, %d seconds.\n", status, status2, ctime / 31536000, (ctime % 31536000) / 86400, (ctime % 86400) / 3600, (ctime % 3600) / 60, ctime % 60); + } else if (ctime > 86400) { + ast_cli(a->fd, "%s%s for %d days, %d hours, %d minutes, %d seconds.\n", status, status2, ctime / 86400, (ctime % 86400) / 3600, (ctime % 3600) / 60, ctime % 60); + } else if (ctime > 3600) { + ast_cli(a->fd, "%s%s for %d hours, %d minutes, %d seconds.\n", status, status2, ctime / 3600, (ctime % 3600) / 60, ctime % 60); + } else if (ctime > 60) { + ast_cli(a->fd, "%s%s for %d minutes, %d seconds.\n", status, status2, ctime / 60, ctime % 60); + } else { + ast_cli(a->fd, "%s%s for %d seconds.\n", status, status2, ctime); + } + if (records == totalrecords) + ast_cli(a->fd, " Wrote %d records since last restart.\n", totalrecords); + else + ast_cli(a->fd, " Wrote %d records since last restart and %d records since last reconnect.\n", totalrecords, records); + } else { + ast_cli(a->fd, "Not currently connected to a MySQL server.\n"); + } + + return CLI_SUCCESS; +} + +static struct ast_cli_entry cdr_mysql_status_cli[] = { + AST_CLI_DEFINE(handle_cli_cdr_mysql_status, "Show connection status of cdr_mysql"), +}; + +static int mysql_log(struct ast_cdr *cdr) +{ + struct ast_str *sql1 = ast_str_thread_get(&sql1_buf, 1024), *sql2 = ast_str_thread_get(&sql2_buf, 1024); + int retries = 5; +#if MYSQL_VERSION_ID >= 50013 + my_bool my_bool_true = 1; +#endif + + if (!sql1 || !sql2) { + ast_log(LOG_ERROR, "Memory error\n"); + return -1; + } + + ast_mutex_lock(&mysql_lock); + +db_reconnect: + if ((!connected) && (hostname || dbsock) && dbuser && password && dbname && dbtable ) { + /* Attempt to connect */ + mysql_init(&mysql); + /* Add option to quickly timeout the connection */ + if (timeout && mysql_options(&mysql, MYSQL_OPT_CONNECT_TIMEOUT, (char *)&timeout) != 0) { + ast_log(LOG_ERROR, "mysql_options returned (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql)); + } +#if MYSQL_VERSION_ID >= 50013 + /* Add option for automatic reconnection */ + if (mysql_options(&mysql, MYSQL_OPT_RECONNECT, &my_bool_true) != 0) { + ast_log(LOG_ERROR, "mysql_options returned (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql)); + } +#endif + if (ssl_ca || ssl_cert || ssl_key) { + mysql_ssl_set(&mysql, ssl_key ? ast_str_buffer(ssl_key) : NULL, ssl_cert ? ast_str_buffer(ssl_cert) : NULL, ssl_ca ? ast_str_buffer(ssl_ca) : NULL, NULL, NULL); + } + if (mysql_real_connect(&mysql, ast_str_buffer(hostname), ast_str_buffer(dbuser), ast_str_buffer(password), ast_str_buffer(dbname), dbport, dbsock && ast_str_strlen(dbsock) ? ast_str_buffer(dbsock) : NULL, ssl_ca ? CLIENT_SSL : 0)) { + connected = 1; + connect_time = time(NULL); + records = 0; + if (dbcharset) { + ast_str_set(&sql1, 0, "SET NAMES '%s'", ast_str_buffer(dbcharset)); + mysql_real_query(&mysql, ast_str_buffer(sql1), ast_str_strlen(sql1)); + ast_debug(1, "SQL command as follows: %s\n", ast_str_buffer(sql1)); + } + } else { + ast_log(LOG_ERROR, "Cannot connect to database server %s: (%d) %s\n", ast_str_buffer(hostname), mysql_errno(&mysql), mysql_error(&mysql)); + connected = 0; + } + } else { + /* Long connection - ping the server */ + int error; + if ((error = mysql_ping(&mysql))) { + connected = 0; + records = 0; + switch (mysql_errno(&mysql)) { + case CR_SERVER_GONE_ERROR: + case CR_SERVER_LOST: + ast_log(LOG_ERROR, "Server has gone away. Attempting to reconnect.\n"); + break; + default: + ast_log(LOG_ERROR, "Unknown connection error: (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql)); + } + retries--; + if (retries) { + goto db_reconnect; + } else { + ast_log(LOG_ERROR, "Retried to connect five times, giving up.\n"); + } + } + } + + if (connected) { + int column_count = 0; + char *cdrname; + char workspace[2048], *value = NULL; + struct column *entry; + struct ast_str *escape = ast_str_thread_get(&escape_buf, 16); + + ast_str_set(&sql1, 0, "INSERT INTO %s (", AS_OR(dbtable, "cdr")); + ast_str_set(&sql2, 0, ") VALUES ("); + + AST_RWLIST_RDLOCK(&columns); + AST_RWLIST_TRAVERSE(&columns, entry, list) { + if (!strcmp(entry->name, "calldate")) { + /*!\note + * For some dumb reason, "calldate" used to be formulated using + * the datetime the record was posted, rather than the start + * time of the call. If someone really wants the old compatible + * behavior, it's provided here. + */ + if (calldate_compat) { + struct timeval tv = ast_tvnow(); + struct ast_tm tm; + char timestr[128]; + ast_localtime(&tv, &tm, NULL); + ast_strftime(timestr, sizeof(timestr), "%Y-%m-%d %T", &tm); + ast_cdr_setvar(cdr, "calldate", timestr, 0); + cdrname = "calldate"; + } else { + cdrname = "start"; + } + } else { + cdrname = entry->cdrname; + } + + /* Construct SQL */ + + /* Need the type and value to determine if we want the raw value or not */ + if (entry->staticvalue) { + value = ast_strdupa(entry->staticvalue); + } else if ((!strcmp(cdrname, "start") || + !strcmp(cdrname, "answer") || + !strcmp(cdrname, "end") || + !strcmp(cdrname, "disposition") || + !strcmp(cdrname, "amaflags")) && + (strstr(entry->type, "int") || + strstr(entry->type, "dec") || + strstr(entry->type, "float") || + strstr(entry->type, "double") || + strstr(entry->type, "real") || + strstr(entry->type, "numeric") || + strstr(entry->type, "fixed"))) { + ast_cdr_getvar(cdr, cdrname, &value, workspace, sizeof(workspace), 0, 1); + } else { + ast_cdr_getvar(cdr, cdrname, &value, workspace, sizeof(workspace), 0, 0); + } + + if (value) { + size_t valsz; + + if (column_count++) { + ast_str_append(&sql1, 0, ","); + ast_str_append(&sql2, 0, ","); + } + + ast_str_make_space(&escape, (valsz = strlen(value)) * 2 + 1); + mysql_real_escape_string(&mysql, ast_str_buffer(escape), value, valsz); + + ast_str_append(&sql1, 0, "%s", entry->name); + ast_str_append(&sql2, 0, "'%s'", ast_str_buffer(escape)); + } + } + AST_RWLIST_UNLOCK(&columns); + + ast_debug(1, "Inserting a CDR record.\n"); + ast_str_append(&sql1, 0, "%s)", ast_str_buffer(sql2)); + + ast_debug(1, "SQL command as follows: %s\n", ast_str_buffer(sql1)); + + if (mysql_real_query(&mysql, ast_str_buffer(sql1), ast_str_strlen(sql1))) { + ast_log(LOG_ERROR, "Failed to insert into database: (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql)); + mysql_close(&mysql); + connected = 0; + } else { + records++; + totalrecords++; + } + } + ast_mutex_unlock(&mysql_lock); + return 0; +} + +static int my_unload_module(int reload) +{ + struct unload_string *us; + struct column *entry; + + ast_cli_unregister_multiple(cdr_mysql_status_cli, sizeof(cdr_mysql_status_cli) / sizeof(struct ast_cli_entry)); + + if (connected) { + mysql_close(&mysql); + connected = 0; + records = 0; + } + + AST_LIST_LOCK(&unload_strings); + while ((us = AST_LIST_REMOVE_HEAD(&unload_strings, entry))) { + ast_free(us->str); + ast_free(us); + } + AST_LIST_UNLOCK(&unload_strings); + + if (!reload) { + AST_RWLIST_WRLOCK(&columns); + } + while ((entry = AST_RWLIST_REMOVE_HEAD(&columns, list))) { + ast_free(entry); + } + if (!reload) { + AST_RWLIST_UNLOCK(&columns); + } + + dbport = 0; + ast_cdr_unregister(name); + + return 0; +} + +static int my_load_config_string(struct ast_config *cfg, const char *category, const char *variable, struct ast_str **field, const char *def) +{ + struct unload_string *us; + const char *tmp; + + if (!(us = ast_calloc(1, sizeof(*us)))) + return -1; + + if (!(*field = ast_str_create(16))) { + ast_free(us); + return -1; + } + + us->str = *field; + + AST_LIST_LOCK(&unload_strings); + AST_LIST_INSERT_HEAD(&unload_strings, us, entry); + AST_LIST_UNLOCK(&unload_strings); + + tmp = ast_variable_retrieve(cfg, category, variable); + + ast_str_set(field, 0, "%s", tmp ? tmp : def); + + return 0; +} + +static int my_load_config_number(struct ast_config *cfg, const char *category, const char *variable, int *field, int def) +{ + const char *tmp; + + tmp = ast_variable_retrieve(cfg, category, variable); + + if (!tmp || sscanf(tmp, "%d", field) < 1) + *field = def; + + return 0; +} + +static int my_load_module(int reload) +{ + int res; + struct ast_config *cfg; + struct ast_variable *var; + struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 }; + struct column *entry; + char *temp; + struct ast_str *compat; + MYSQL_ROW row; + MYSQL_RES *result; + char sqldesc[128]; +#if MYSQL_VERSION_ID >= 50013 + my_bool my_bool_true = 1; +#endif + + cfg = ast_config_load(config, config_flags); + if (!cfg) { + ast_log(LOG_WARNING, "Unable to load config for mysql CDR's: %s\n", config); + return AST_MODULE_LOAD_SUCCESS; + } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) + return AST_MODULE_LOAD_SUCCESS; + + if (reload) { + AST_RWLIST_WRLOCK(&columns); + my_unload_module(1); + } + + var = ast_variable_browse(cfg, "global"); + if (!var) { + /* nothing configured */ + if (reload) { + AST_RWLIST_UNLOCK(&columns); + } + return AST_MODULE_LOAD_SUCCESS; + } + + res = 0; + + res |= my_load_config_string(cfg, "global", "hostname", &hostname, "localhost"); + res |= my_load_config_string(cfg, "global", "dbname", &dbname, "astriskcdrdb"); + res |= my_load_config_string(cfg, "global", "user", &dbuser, "root"); + res |= my_load_config_string(cfg, "global", "sock", &dbsock, ""); + res |= my_load_config_string(cfg, "global", "table", &dbtable, "cdr"); + res |= my_load_config_string(cfg, "global", "password", &password, ""); + + res |= my_load_config_string(cfg, "global", "charset", &dbcharset, ""); + + res |= my_load_config_string(cfg, "global", "ssl_ca", &ssl_ca, ""); + res |= my_load_config_string(cfg, "global", "ssl_cert", &ssl_cert, ""); + res |= my_load_config_string(cfg, "global", "ssl_key", &ssl_key, ""); + + res |= my_load_config_number(cfg, "global", "port", &dbport, 0); + res |= my_load_config_number(cfg, "global", "timeout", &timeout, 0); + res |= my_load_config_string(cfg, "global", "compat", &compat, "no"); + if (ast_true(ast_str_buffer(compat))) { + calldate_compat = 1; + } else { + calldate_compat = 0; + } + + if (res < 0) { + if (reload) { + AST_RWLIST_UNLOCK(&columns); + } + return AST_MODULE_LOAD_FAILURE; + } + + /* Check for any aliases */ + if (!reload) { + /* Lock, if not already */ + AST_RWLIST_WRLOCK(&columns); + } + while ((entry = AST_LIST_REMOVE_HEAD(&columns, list))) { + ast_free(entry); + } + + ast_debug(1, "Got hostname of %s\n", ast_str_buffer(hostname)); + ast_debug(1, "Got port of %d\n", dbport); + ast_debug(1, "Got a timeout of %d\n", timeout); + if (dbsock) + ast_debug(1, "Got sock file of %s\n", ast_str_buffer(dbsock)); + ast_debug(1, "Got user of %s\n", ast_str_buffer(dbuser)); + ast_debug(1, "Got dbname of %s\n", ast_str_buffer(dbname)); + ast_debug(1, "Got password of %s\n", ast_str_buffer(password)); + ast_debug(1, "%sunning in calldate compatibility mode\n", calldate_compat ? "R" : "Not r"); + + if (dbcharset) { + ast_debug(1, "Got DB charset of %s\n", ast_str_buffer(dbcharset)); + } + + mysql_init(&mysql); + + if (timeout && mysql_options(&mysql, MYSQL_OPT_CONNECT_TIMEOUT, (char *)&timeout) != 0) { + ast_log(LOG_ERROR, "cdr_mysql: mysql_options returned (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql)); + } + +#if MYSQL_VERSION_ID >= 50013 + /* Add option for automatic reconnection */ + if (mysql_options(&mysql, MYSQL_OPT_RECONNECT, &my_bool_true) != 0) { + ast_log(LOG_ERROR, "cdr_mysql: mysql_options returned (%d) %s\n", mysql_errno(&mysql), mysql_error(&mysql)); + } +#endif + + if ((ssl_ca && ast_str_strlen(ssl_ca)) || (ssl_cert && ast_str_strlen(ssl_cert)) || (ssl_key && ast_str_strlen(ssl_key))) { + mysql_ssl_set(&mysql, + ssl_key ? ast_str_buffer(ssl_key) : NULL, + ssl_cert ? ast_str_buffer(ssl_cert) : NULL, + ssl_ca ? ast_str_buffer(ssl_ca) : NULL, + NULL, NULL); + } + temp = dbsock && ast_str_strlen(dbsock) ? ast_str_buffer(dbsock) : NULL; + if (!mysql_real_connect(&mysql, ast_str_buffer(hostname), ast_str_buffer(dbuser), ast_str_buffer(password), ast_str_buffer(dbname), dbport, temp, ssl_ca && ast_str_strlen(ssl_ca) ? CLIENT_SSL : 0)) { + ast_log(LOG_ERROR, "Failed to connect to mysql database %s on %s.\n", ast_str_buffer(dbname), ast_str_buffer(hostname)); + connected = 0; + records = 0; + } else { + ast_debug(1, "Successfully connected to MySQL database.\n"); + connected = 1; + records = 0; + connect_time = time(NULL); + if (dbcharset) { + snprintf(sqldesc, sizeof(sqldesc), "SET NAMES '%s'", ast_str_buffer(dbcharset)); + mysql_real_query(&mysql, sqldesc, strlen(sqldesc)); + ast_debug(1, "SQL command as follows: %s\n", sqldesc); + } + + /* Get table description */ + snprintf(sqldesc, sizeof(sqldesc), "DESC %s", dbtable ? ast_str_buffer(dbtable) : "cdr"); + if (mysql_query(&mysql, sqldesc)) { + ast_log(LOG_ERROR, "Unable to query table description!! Logging disabled.\n"); + mysql_close(&mysql); + connected = 0; + AST_RWLIST_UNLOCK(&columns); + ast_config_destroy(cfg); + return AST_MODULE_LOAD_SUCCESS; + } + + if (!(result = mysql_store_result(&mysql))) { + ast_log(LOG_ERROR, "Unable to query table description!! Logging disabled.\n"); + mysql_close(&mysql); + connected = 0; + AST_RWLIST_UNLOCK(&columns); + ast_config_destroy(cfg); + return AST_MODULE_LOAD_SUCCESS; + } + + while ((row = mysql_fetch_row(result))) { + struct column *entry; + char *cdrvar = "", *staticvalue = ""; + + ast_debug(1, "Got a field '%s' of type '%s'\n", row[0], row[1]); + /* Check for an alias or a static value */ + for (var = ast_variable_browse(cfg, "columns"); var; var = var->next) { + if (strncmp(var->name, "alias", 5) == 0 && strcasecmp(var->value, row[0]) == 0 ) { + char *alias = ast_strdupa(var->name + 5); + cdrvar = ast_strip(alias); + ast_verb(3, "Found alias %s for column %s\n", cdrvar, row[0]); + break; + } else if (strncmp(var->name, "static", 6) == 0 && strcasecmp(var->value, row[0]) == 0) { + char *item = ast_strdupa(var->name + 6); + item = ast_strip(item); + if (item[0] == '"' && item[strlen(item) - 1] == '"') { + /* Remove surrounding quotes */ + item[strlen(item) - 1] = '\0'; + item++; + } + staticvalue = item; + } + } + + entry = ast_calloc(sizeof(char), sizeof(*entry) + strlen(row[0]) + 1 + strlen(cdrvar) + 1 + strlen(staticvalue) + 1 + strlen(row[1]) + 1); + if (!entry) { + ast_log(LOG_ERROR, "Out of memory creating entry for column '%s'\n", row[0]); + res = -1; + break; + } + + entry->name = (char *)entry + sizeof(*entry); + strcpy(entry->name, row[0]); + + if (!ast_strlen_zero(cdrvar)) { + entry->cdrname = entry->name + strlen(row[0]) + 1; + strcpy(entry->cdrname, cdrvar); + } else { /* Point to same place as the column name */ + entry->cdrname = (char *)entry + sizeof(*entry); + } + + if (!ast_strlen_zero(staticvalue)) { + entry->staticvalue = entry->cdrname + strlen(entry->cdrname) + 1; + strcpy(entry->staticvalue, staticvalue); + ast_debug(1, "staticvalue length: %d\n", (int) strlen(staticvalue) ); + entry->type = entry->staticvalue + strlen(entry->staticvalue) + 1; + } else { + entry->type = entry->cdrname + strlen(entry->cdrname) + 1; + } + strcpy(entry->type, row[1]); + + ast_debug(1, "Entry name '%s'\n", entry->name); + ast_debug(1, " cdrname '%s'\n", entry->cdrname); + ast_debug(1, " static '%s'\n", entry->staticvalue); + ast_debug(1, " type '%s'\n", entry->type); + + AST_LIST_INSERT_TAIL(&columns, entry, list); + } + mysql_free_result(result); + } + AST_RWLIST_UNLOCK(&columns); + ast_config_destroy(cfg); + if (res < 0) { + return AST_MODULE_LOAD_FAILURE; + } + + res = ast_cdr_register(name, desc, mysql_log); + if (res) { + ast_log(LOG_ERROR, "Unable to register MySQL CDR handling\n"); + } else { + res = ast_cli_register_multiple(cdr_mysql_status_cli, sizeof(cdr_mysql_status_cli) / sizeof(struct ast_cli_entry)); + } + + return res; +} + +static int load_module(void) +{ + return my_load_module(0); +} + +static int unload_module(void) +{ + return my_unload_module(0); +} + +static int reload(void) +{ + int ret; + + ast_mutex_lock(&mysql_lock); + ret = my_load_module(1); + ast_mutex_unlock(&mysql_lock); + + return ret; +} + +AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "MySQL CDR Backend", + .load = load_module, + .unload = unload_module, + .reload = reload, +); + diff --git a/addons/chan_mobile.c b/addons/chan_mobile.c new file mode 100644 index 000000000..415ca617e --- /dev/null +++ b/addons/chan_mobile.c @@ -0,0 +1,4266 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 1999 - 2006, Digium, Inc. + * + * Mark Spencer + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! + * \file + * \brief Bluetooth Mobile Device channel driver + * + * \author Dave Bowerman + * + * \ingroup channel_drivers + */ + +/*** MODULEINFO + bluetooth + no + ***/ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include + +#include "asterisk/compat.h" +#include "asterisk/lock.h" +#include "asterisk/channel.h" +#include "asterisk/config.h" +#include "asterisk/logger.h" +#include "asterisk/module.h" +#include "asterisk/pbx.h" +#include "asterisk/options.h" +#include "asterisk/utils.h" +#include "asterisk/linkedlists.h" +#include "asterisk/cli.h" +#include "asterisk/devicestate.h" +#include "asterisk/causes.h" +#include "asterisk/dsp.h" +#include "asterisk/app.h" +#include "asterisk/manager.h" +#include "asterisk/io.h" + +#define MBL_CONFIG "mobile.conf" + +#define DEVICE_FRAME_SIZE 48 +#define DEVICE_FRAME_FORMAT AST_FORMAT_SLINEAR +#define CHANNEL_FRAME_SIZE 320 + +static int prefformat = DEVICE_FRAME_FORMAT; + +static int discovery_interval = 60; /* The device discovery interval, default 60 seconds. */ +static pthread_t discovery_thread = AST_PTHREADT_NULL; /* The discovery thread */ +static sdp_session_t *sdp_session; + +AST_MUTEX_DEFINE_STATIC(unload_mutex); +static int unloading_flag = 0; +static inline int check_unloading(void); +static inline void set_unloading(void); + +enum mbl_type { + MBL_TYPE_PHONE, + MBL_TYPE_HEADSET +}; + +struct adapter_pvt { + int dev_id; /* device id */ + int hci_socket; /* device descriptor */ + char id[31]; /* the 'name' from mobile.conf */ + bdaddr_t addr; /* adddress of adapter */ + unsigned int inuse:1; /* are we in use ? */ + unsigned int alignment_detection:1; /* do alignment detection on this adpater? */ + struct io_context *io; /*!< io context for audio connections */ + struct io_context *accept_io; /*!< io context for sco listener */ + int *sco_id; /*!< the io context id of the sco listener socket */ + int sco_socket; /*!< sco listener socket */ + pthread_t sco_listener_thread; /*!< sco listener thread */ + AST_LIST_ENTRY(adapter_pvt) entry; +}; + +static AST_RWLIST_HEAD_STATIC(adapters, adapter_pvt); + +struct msg_queue_entry; +struct hfp_pvt; +struct mbl_pvt { + struct ast_channel *owner; /* Channel we belong to, possibly NULL */ + struct ast_frame fr; /* "null" frame */ + ast_mutex_t lock; /*!< pvt lock */ + /*! queue for messages we are expecting */ + AST_LIST_HEAD_NOLOCK(msg_queue, msg_queue_entry) msg_queue; + enum mbl_type type; /* Phone or Headset */ + char id[31]; /* The id from mobile.conf */ + int group; /* group number for group dialling */ + bdaddr_t addr; /* address of device */ + struct adapter_pvt *adapter; /* the adapter we use */ + char context[AST_MAX_CONTEXT]; /* the context for incoming calls */ + struct hfp_pvt *hfp; /*!< hfp pvt */ + int rfcomm_port; /* rfcomm port number */ + int rfcomm_socket; /* rfcomm socket descriptor */ + char rfcomm_buf[256]; + char io_buf[CHANNEL_FRAME_SIZE + AST_FRIENDLY_OFFSET]; + struct ast_smoother *smoother; /* our smoother, for making 48 byte frames */ + int sco_socket; /* sco socket descriptor */ + pthread_t monitor_thread; /* monitor thread handle */ + int timeout; /*!< used to set the timeout for rfcomm data (may be used in the future) */ + unsigned int no_callsetup:1; + unsigned int has_sms:1; + unsigned int do_alignment_detection:1; + unsigned int alignment_detection_triggered:1; + unsigned int blackberry:1; + short alignment_samples[4]; + int alignment_count; + int ring_sched_id; + struct ast_dsp *dsp; + struct sched_context *sched; + + /* flags */ + unsigned int outgoing:1; /*!< outgoing call */ + unsigned int incoming:1; /*!< incoming call */ + unsigned int outgoing_sms:1; /*!< outgoing sms */ + unsigned int incoming_sms:1; /*!< outgoing sms */ + unsigned int needcallerid:1; /*!< we need callerid */ + unsigned int needchup:1; /*!< we need to send a chup */ + unsigned int needring:1; /*!< we need to send a RING */ + unsigned int answered:1; /*!< we sent/recieved an answer */ + unsigned int connected:1; /*!< do we have an rfcomm connection to a device */ + + AST_LIST_ENTRY(mbl_pvt) entry; +}; + +static AST_RWLIST_HEAD_STATIC(devices, mbl_pvt); + +static int handle_response_ok(struct mbl_pvt *pvt, char *buf); +static int handle_response_error(struct mbl_pvt *pvt, char *buf); +static int handle_response_ciev(struct mbl_pvt *pvt, char *buf); +static int handle_response_clip(struct mbl_pvt *pvt, char *buf); +static int handle_response_ring(struct mbl_pvt *pvt, char *buf); +static int handle_response_cmti(struct mbl_pvt *pvt, char *buf); +static int handle_response_cmgr(struct mbl_pvt *pvt, char *buf); +static int handle_sms_prompt(struct mbl_pvt *pvt, char *buf); + +/* CLI stuff */ +static char *handle_cli_mobile_show_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a); +static char *handle_cli_mobile_search(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a); +static char *handle_cli_mobile_rfcomm(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a); + +static struct ast_cli_entry mbl_cli[] = { + AST_CLI_DEFINE(handle_cli_mobile_show_devices, "Show Bluetooth Cell / Mobile devices"), + AST_CLI_DEFINE(handle_cli_mobile_search, "Search for Bluetooth Cell / Mobile devices"), + AST_CLI_DEFINE(handle_cli_mobile_rfcomm, "Send commands to the rfcomm port for debugging"), +}; + +/* App stuff */ +static char *app_mblstatus = "MobileStatus"; +static char *mblstatus_synopsis = "MobileStatus(Device,Variable)"; +static char *mblstatus_desc = +"MobileStatus(Device,Variable)\n" +" Device - Id of mobile device from mobile.conf\n" +" Variable - Variable to store status in will be 1-3.\n" +" In order, Disconnected, Connected & Free, Connected & Busy.\n"; + +static char *app_mblsendsms = "MobileSendSMS"; +static char *mblsendsms_synopsis = "MobileSendSMS(Device,Dest,Message)"; +static char *mblsendsms_desc = +"MobileSendSms(Device,Dest,Message)\n" +" Device - Id of device from mobile.conf\n" +" Dest - destination\n" +" Message - text of the message\n"; + +static struct ast_channel *mbl_new(int state, struct mbl_pvt *pvt, char *cid_num, + const struct ast_channel *requestor); +static struct ast_channel *mbl_request(const char *type, int format, + const struct ast_channel *requestor, void *data, int *cause); +static int mbl_call(struct ast_channel *ast, char *dest, int timeout); +static int mbl_hangup(struct ast_channel *ast); +static int mbl_answer(struct ast_channel *ast); +static int mbl_digit_end(struct ast_channel *ast, char digit, unsigned int duration); +static struct ast_frame *mbl_read(struct ast_channel *ast); +static int mbl_write(struct ast_channel *ast, struct ast_frame *frame); +static int mbl_fixup(struct ast_channel *oldchan, struct ast_channel *newchan); +static int mbl_devicestate(void *data); + +static void do_alignment_detection(struct mbl_pvt *pvt, char *buf, int buflen); + +static int mbl_queue_control(struct mbl_pvt *pvt, enum ast_control_frame_type control); +static int mbl_queue_hangup(struct mbl_pvt *pvt); +static int mbl_ast_hangup(struct mbl_pvt *pvt); + +static int rfcomm_connect(bdaddr_t src, bdaddr_t dst, int remote_channel); +static int rfcomm_write(int rsock, char *buf); +static int rfcomm_write_full(int rsock, char *buf, size_t count); +static int rfcomm_wait(int rsock, int *ms); +static ssize_t rfcomm_read(int rsock, char *buf, size_t count); + +static int sco_connect(bdaddr_t src, bdaddr_t dst); +static int sco_write(int s, char *buf, int len); +static int sco_accept(int *id, int fd, short events, void *data); +static int sco_bind(struct adapter_pvt *adapter); + +static void *do_sco_listen(void *data); +static int sdp_search(char *addr, int profile); + +static int headset_send_ring(const void *data); + +/* + * bluetooth handsfree profile helpers + */ + +#define HFP_HF_ECNR (1 << 0) +#define HFP_HF_CW (1 << 1) +#define HFP_HF_CID (1 << 2) +#define HFP_HF_VOICE (1 << 3) +#define HFP_HF_VOLUME (1 << 4) +#define HFP_HF_STATUS (1 << 5) +#define HFP_HF_CONTROL (1 << 6) + +#define HFP_AG_CW (1 << 0) +#define HFP_AG_ECNR (1 << 1) +#define HFP_AG_VOICE (1 << 2) +#define HFP_AG_RING (1 << 3) +#define HFP_AG_TAG (1 << 4) +#define HFP_AG_REJECT (1 << 5) +#define HFP_AG_STATUS (1 << 6) +#define HFP_AG_CONTROL (1 << 7) +#define HFP_AG_ERRORS (1 << 8) + +#define HFP_CIND_UNKNOWN -1 +#define HFP_CIND_NONE 0 +#define HFP_CIND_SERVICE 1 +#define HFP_CIND_CALL 2 +#define HFP_CIND_CALLSETUP 3 +#define HFP_CIND_CALLHELD 4 +#define HFP_CIND_SIGNAL 5 +#define HFP_CIND_ROAM 6 +#define HFP_CIND_BATTCHG 7 + +/* call indicator values */ +#define HFP_CIND_CALL_NONE 0 +#define HFP_CIND_CALL_ACTIVE 1 + +/* callsetup indicator values */ +#define HFP_CIND_CALLSETUP_NONE 0 +#define HFP_CIND_CALLSETUP_INCOMING 1 +#define HFP_CIND_CALLSETUP_OUTGOING 2 +#define HFP_CIND_CALLSETUP_ALERTING 3 + +/*! + * \brief This struct holds HFP features that we support. + */ +struct hfp_hf { + int ecnr:1; /*!< echo-cancel/noise reduction */ + int cw:1; /*!< call waiting and three way calling */ + int cid:1; /*!< cli presentation (callier id) */ + int voice:1; /*!< voice recognition activation */ + int volume:1; /*!< remote volume control */ + int status:1; /*!< enhanced call status */ + int control:1; /*!< enhanced call control*/ +}; + +/*! + * \brief This struct holds HFP features the AG supports. + */ +struct hfp_ag { + int cw:1; /*!< three way calling */ + int ecnr:1; /*!< echo-cancel/noise reduction */ + int voice:1; /*!< voice recognition */ + int ring:1; /*!< in band ring tone capability */ + int tag:1; /*!< attach a number to a voice tag */ + int reject:1; /*!< ability to reject a call */ + int status:1; /*!< enhanced call status */ + int control:1; /*!< enhanced call control*/ + int errors:1; /*!< extended error result codes*/ +}; + +/*! + * \brief This struct holds mappings for indications. + */ +struct hfp_cind { + int service; /*!< whether we have service or not */ + int call; /*!< call state */ + int callsetup; /*!< bluetooth call setup indications */ + int callheld; /*!< bluetooth call hold indications */ + int signal; /*!< signal strength */ + int roam; /*!< roaming indicator */ + int battchg; /*!< battery charge indicator */ +}; + + +/*! + * \brief This struct holds state information about the current hfp connection. + */ +struct hfp_pvt { + struct mbl_pvt *owner; /*!< the mbl_pvt struct that owns this struct */ + int initialized:1; /*!< whether a service level connection exists or not */ + int nocallsetup:1; /*!< whether we detected a callsetup indicator */ + struct hfp_ag brsf; /*!< the supported feature set of the AG */ + int cind_index[16]; /*!< the cind/ciev index to name mapping for this AG */ + int cind_state[16]; /*!< the cind/ciev state for this AG */ + struct hfp_cind cind_map; /*!< the cind name to index mapping for this AG */ + int rsock; /*!< our rfcomm socket */ + int rport; /*!< our rfcomm port */ +}; + + +/* Our supported features. + * we only support caller id + */ +static struct hfp_hf hfp_our_brsf = { + .ecnr = 0, + .cw = 0, + .cid = 1, + .voice = 0, + .volume = 0, + .status = 0, + .control = 0, +}; + + +static int hfp_parse_ciev(struct hfp_pvt *hfp, char *buf, int *value); +static char *hfp_parse_clip(struct hfp_pvt *hfp, char *buf); +static int hfp_parse_cmti(struct hfp_pvt *hfp, char *buf); +static int hfp_parse_cmgr(struct hfp_pvt *hfp, char *buf, char **from_number, char **text); +static int hfp_parse_brsf(struct hfp_pvt *hfp, const char *buf); +static int hfp_parse_cind(struct hfp_pvt *hfp, char *buf); +static int hfp_parse_cind_test(struct hfp_pvt *hfp, char *buf); + +static int hfp_brsf2int(struct hfp_hf *hf); +static struct hfp_ag *hfp_int2brsf(int brsf, struct hfp_ag *ag); + +static int hfp_send_brsf(struct hfp_pvt *hfp, struct hfp_hf *brsf); +static int hfp_send_cind(struct hfp_pvt *hfp); +static int hfp_send_cind_test(struct hfp_pvt *hfp); +static int hfp_send_cmer(struct hfp_pvt *hfp, int status); +static int hfp_send_clip(struct hfp_pvt *hfp, int status); +static int hfp_send_vgs(struct hfp_pvt *hfp, int value); + +#if 0 +static int hfp_send_vgm(struct hfp_pvt *hfp, int value); +#endif +static int hfp_send_dtmf(struct hfp_pvt *hfp, char digit); +static int hfp_send_cmgf(struct hfp_pvt *hfp, int mode); +static int hfp_send_cnmi(struct hfp_pvt *hfp); +static int hfp_send_cmgr(struct hfp_pvt *hfp, int index); +static int hfp_send_cmgs(struct hfp_pvt *hfp, const char *number); +static int hfp_send_sms_text(struct hfp_pvt *hfp, const char *message); +static int hfp_send_chup(struct hfp_pvt *hfp); +static int hfp_send_atd(struct hfp_pvt *hfp, const char *number); +static int hfp_send_ata(struct hfp_pvt *hfp); + +/* + * bluetooth headset profile helpers + */ +static int hsp_send_ok(int rsock); +static int hsp_send_error(int rsock); +static int hsp_send_vgs(int rsock, int gain); +static int hsp_send_vgm(int rsock, int gain); +static int hsp_send_ring(int rsock); + + +/* + * Hayes AT command helpers + */ +typedef enum { + /* errors */ + AT_PARSE_ERROR = -2, + AT_READ_ERROR = -1, + AT_UNKNOWN = 0, + /* at responses */ + AT_OK, + AT_ERROR, + AT_RING, + AT_BRSF, + AT_CIND, + AT_CIEV, + AT_CLIP, + AT_CMTI, + AT_CMGR, + AT_SMS_PROMPT, + AT_CMS_ERROR, + /* at commands */ + AT_A, + AT_D, + AT_CHUP, + AT_CKPD, + AT_CMGS, + AT_VGM, + AT_VGS, + AT_VTS, + AT_CMGF, + AT_CNMI, + AT_CMER, + AT_CIND_TEST, +} at_message_t; + +static int at_match_prefix(char *buf, char *prefix); +static at_message_t at_read_full(int rsock, char *buf, size_t count); +static inline const char *at_msg2str(at_message_t msg); + +struct msg_queue_entry { + at_message_t expected; + at_message_t response_to; + void *data; + + AST_LIST_ENTRY(msg_queue_entry) entry; +}; + +static int msg_queue_push(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to); +static int msg_queue_push_data(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to, void *data); +static struct msg_queue_entry *msg_queue_pop(struct mbl_pvt *pvt); +static void msg_queue_free_and_pop(struct mbl_pvt *pvt); +static void msg_queue_flush(struct mbl_pvt *pvt); +static struct msg_queue_entry *msg_queue_head(struct mbl_pvt *pvt); + +/* + * channel stuff + */ + +static const struct ast_channel_tech mbl_tech = { + .type = "Mobile", + .description = "Bluetooth Mobile Device Channel Driver", + .capabilities = AST_FORMAT_SLINEAR, + .requester = mbl_request, + .call = mbl_call, + .hangup = mbl_hangup, + .answer = mbl_answer, + .send_digit_end = mbl_digit_end, + .read = mbl_read, + .write = mbl_write, + .fixup = mbl_fixup, + .devicestate = mbl_devicestate +}; + +/* CLI Commands implementation */ + +static char *handle_cli_mobile_show_devices(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct mbl_pvt *pvt; + char bdaddr[18]; + char group[6]; + +#define FORMAT1 "%-15.15s %-17.17s %-5.5s %-15.15s %-9.9s %-5.5s %-3.3s\n" + + switch (cmd) { + case CLI_INIT: + e->command = "mobile show devices"; + e->usage = + "Usage: mobile show devices\n" + " Shows the state of Bluetooth Cell / Mobile devices.\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 3) + return CLI_SHOWUSAGE; + + ast_cli(a->fd, FORMAT1, "ID", "Address", "Group", "Adapter", "Connected", "State", "SMS"); + AST_RWLIST_RDLOCK(&devices); + AST_RWLIST_TRAVERSE(&devices, pvt, entry) { + ast_mutex_lock(&pvt->lock); + ba2str(&pvt->addr, bdaddr); + snprintf(group, sizeof(group), "%d", pvt->group); + ast_cli(a->fd, FORMAT1, + pvt->id, + bdaddr, + group, + pvt->adapter->id, + pvt->connected ? "Yes" : "No", + (!pvt->connected) ? "None" : (pvt->owner) ? "Busy" : (pvt->outgoing_sms || pvt->incoming_sms) ? "SMS" : "Free", + (pvt->has_sms) ? "Yes" : "No" + ); + ast_mutex_unlock(&pvt->lock); + } + AST_RWLIST_UNLOCK(&devices); + +#undef FORMAT1 + + return CLI_SUCCESS; +} + +static char *handle_cli_mobile_search(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct adapter_pvt *adapter; + inquiry_info *ii = NULL; + int max_rsp, num_rsp; + int len, flags; + int i, phport, hsport; + char addr[19] = {0}; + char name[31] = {0}; + +#define FORMAT1 "%-17.17s %-30.30s %-6.6s %-7.7s %-4.4s\n" +#define FORMAT2 "%-17.17s %-30.30s %-6.6s %-7.7s %d\n" + + switch (cmd) { + case CLI_INIT: + e->command = "mobile search"; + e->usage = + "Usage: mobile search\n" + " Searches for Bluetooth Cell / Mobile devices in range.\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 2) + return CLI_SHOWUSAGE; + + /* find a free adapter */ + AST_RWLIST_RDLOCK(&adapters); + AST_RWLIST_TRAVERSE(&adapters, adapter, entry) { + if (!adapter->inuse) + break; + } + AST_RWLIST_UNLOCK(&adapters); + + if (!adapter) { + ast_cli(a->fd, "All Bluetooth adapters are in use at this time.\n"); + return CLI_SUCCESS; + } + + len = 8; + max_rsp = 255; + flags = IREQ_CACHE_FLUSH; + + ii = alloca(max_rsp * sizeof(inquiry_info)); + num_rsp = hci_inquiry(adapter->dev_id, len, max_rsp, NULL, &ii, flags); + if (num_rsp > 0) { + ast_cli(a->fd, FORMAT1, "Address", "Name", "Usable", "Type", "Port"); + for (i = 0; i < num_rsp; i++) { + ba2str(&(ii + i)->bdaddr, addr); + name[0] = 0x00; + if (hci_read_remote_name(adapter->hci_socket, &(ii + i)->bdaddr, sizeof(name) - 1, name, 0) < 0) + strcpy(name, "[unknown]"); + phport = sdp_search(addr, HANDSFREE_AGW_PROFILE_ID); + if (!phport) + hsport = sdp_search(addr, HEADSET_PROFILE_ID); + else + hsport = 0; + ast_cli(a->fd, FORMAT2, addr, name, (phport > 0 || hsport > 0) ? "Yes" : "No", + (phport > 0) ? "Phone" : "Headset", (phport > 0) ? phport : hsport); + } + } else + ast_cli(a->fd, "No Bluetooth Cell / Mobile devices found.\n"); + +#undef FORMAT1 +#undef FORMAT2 + + return CLI_SUCCESS; +} + +static char *handle_cli_mobile_rfcomm(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + char buf[128]; + struct mbl_pvt *pvt = NULL; + + switch (cmd) { + case CLI_INIT: + e->command = "mobile rfcomm"; + e->usage = + "Usage: mobile rfcomm \n" + " Send to the rfcomm port on the device\n" + " with the specified .\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 4) + return CLI_SHOWUSAGE; + + AST_RWLIST_RDLOCK(&devices); + AST_RWLIST_TRAVERSE(&devices, pvt, entry) { + if (!strcmp(pvt->id, a->argv[2])) + break; + } + AST_RWLIST_UNLOCK(&devices); + + if (!pvt) { + ast_cli(a->fd, "Device %s not found.\n", a->argv[2]); + goto e_return; + } + + ast_mutex_lock(&pvt->lock); + if (!pvt->connected) { + ast_cli(a->fd, "Device %s not connected.\n", a->argv[2]); + goto e_unlock_pvt; + } + + snprintf(buf, sizeof(buf), "%s\r", a->argv[3]); + rfcomm_write(pvt->rfcomm_socket, buf); + msg_queue_push(pvt, AT_OK, AT_UNKNOWN); + +e_unlock_pvt: + ast_mutex_unlock(&pvt->lock); +e_return: + return CLI_SUCCESS; +} + +/* + + Dialplan applications implementation + +*/ + +static int mbl_status_exec(struct ast_channel *ast, const char *data) +{ + + struct mbl_pvt *pvt; + char *parse; + int stat; + char status[2]; + + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(device); + AST_APP_ARG(variable); + ); + + if (ast_strlen_zero(data)) + return -1; + + parse = ast_strdupa(data); + + AST_STANDARD_APP_ARGS(args, parse); + + if (ast_strlen_zero(args.device) || ast_strlen_zero(args.variable)) + return -1; + + stat = 1; + + AST_RWLIST_RDLOCK(&devices); + AST_RWLIST_TRAVERSE(&devices, pvt, entry) { + if (!strcmp(pvt->id, args.device)) + break; + } + AST_RWLIST_UNLOCK(&devices); + + if (pvt) { + ast_mutex_lock(&pvt->lock); + if (pvt->connected) + stat = 2; + if (pvt->owner) + stat = 3; + ast_mutex_unlock(&pvt->lock); + } + + snprintf(status, sizeof(status), "%d", stat); + pbx_builtin_setvar_helper(ast, args.variable, status); + + return 0; + +} + +static int mbl_sendsms_exec(struct ast_channel *ast, const char *data) +{ + + struct mbl_pvt *pvt; + char *parse, *message; + + AST_DECLARE_APP_ARGS(args, + AST_APP_ARG(device); + AST_APP_ARG(dest); + AST_APP_ARG(message); + ); + + if (ast_strlen_zero(data)) + return -1; + + parse = ast_strdupa(data); + + AST_STANDARD_APP_ARGS(args, parse); + + if (ast_strlen_zero(args.device)) { + ast_log(LOG_ERROR,"NULL device for message -- SMS will not be sent.\n"); + return -1; + } + + if (ast_strlen_zero(args.dest)) { + ast_log(LOG_ERROR,"NULL destination for message -- SMS will not be sent.\n"); + return -1; + } + + if (ast_strlen_zero(args.message)) { + ast_log(LOG_ERROR,"NULL Message to be sent -- SMS will not be sent.\n"); + return -1; + } + + AST_RWLIST_RDLOCK(&devices); + AST_RWLIST_TRAVERSE(&devices, pvt, entry) { + if (!strcmp(pvt->id, args.device)) + break; + } + AST_RWLIST_UNLOCK(&devices); + + if (!pvt) { + ast_log(LOG_ERROR,"Bluetooth device %s wasn't found in the list -- SMS will not be sent.\n", args.device); + goto e_return; + } + + ast_mutex_lock(&pvt->lock); + if (!pvt->connected) { + ast_log(LOG_ERROR,"Bluetooth device %s wasn't connected -- SMS will not be sent.\n", args.device); + goto e_unlock_pvt; + } + + if (!pvt->has_sms) { + ast_log(LOG_ERROR,"Bluetooth device %s doesn't handle SMS -- SMS will not be sent.\n", args.device); + goto e_unlock_pvt; + } + + message = ast_strdup(args.message); + + if (hfp_send_cmgs(pvt->hfp, args.dest) + || msg_queue_push_data(pvt, AT_SMS_PROMPT, AT_CMGS, message)) { + + ast_log(LOG_ERROR, "[%s] problem sending SMS message\n", pvt->id); + goto e_free_message; + } + + ast_mutex_unlock(&pvt->lock); + + return 0; + +e_free_message: + ast_free(message); +e_unlock_pvt: + ast_mutex_unlock(&pvt->lock); +e_return: + return -1; +} + +/* + + Channel Driver callbacks + +*/ + +static struct ast_channel *mbl_new(int state, struct mbl_pvt *pvt, char *cid_num, + const struct ast_channel *requestor) +{ + + struct ast_channel *chn; + + pvt->answered = 0; + pvt->alignment_count = 0; + pvt->alignment_detection_triggered = 0; + if (pvt->adapter->alignment_detection) + pvt->do_alignment_detection = 1; + else + pvt->do_alignment_detection = 0; + + ast_smoother_reset(pvt->smoother, DEVICE_FRAME_SIZE); + ast_dsp_digitreset(pvt->dsp); + + chn = ast_channel_alloc(1, state, cid_num, pvt->id, 0, 0, pvt->context, + requestor ? requestor->linkedid : "", 0, + "Mobile/%s-%04lx", pvt->id, ast_random() & 0xffff); + if (!chn) { + goto e_return; + } + + chn->tech = &mbl_tech; + chn->nativeformats = prefformat; + chn->rawreadformat = prefformat; + chn->rawwriteformat = prefformat; + chn->writeformat = prefformat; + chn->readformat = prefformat; + chn->tech_pvt = pvt; + + if (state == AST_STATE_RING) + chn->rings = 1; + + ast_string_field_set(chn, language, "en"); + pvt->owner = chn; + + if (pvt->sco_socket != -1) { + ast_channel_set_fd(chn, 0, pvt->sco_socket); + } + + return chn; + +e_return: + return NULL; +} + +static struct ast_channel *mbl_request(const char *type, int format, + const struct ast_channel *requestor, void *data, int *cause) +{ + + struct ast_channel *chn = NULL; + struct mbl_pvt *pvt; + char *dest_dev = NULL; + char *dest_num = NULL; + int oldformat, group = -1; + + if (!data) { + ast_log(LOG_WARNING, "Channel requested with no data\n"); + *cause = AST_CAUSE_INCOMPATIBLE_DESTINATION; + return NULL; + } + + oldformat = format; + format &= (AST_FORMAT_SLINEAR); + if (!format) { + ast_log(LOG_WARNING, "Asked to get a channel of unsupported format '%d'\n", oldformat); + *cause = AST_CAUSE_FACILITY_NOT_IMPLEMENTED; + return NULL; + } + + dest_dev = ast_strdupa((char *)data); + + dest_num = strchr(dest_dev, '/'); + if (dest_num) + *dest_num++ = 0x00; + + if (((dest_dev[0] == 'g') || (dest_dev[0] == 'G')) && ((dest_dev[1] >= '0') && (dest_dev[1] <= '9'))) { + group = atoi(&dest_dev[1]); + } + + /* Find requested device and make sure it's connected. */ + AST_RWLIST_RDLOCK(&devices); + AST_RWLIST_TRAVERSE(&devices, pvt, entry) { + if (group > -1 && pvt->group == group && pvt->connected && !pvt->owner) { + break; + } else if (!strcmp(pvt->id, dest_dev)) { + break; + } + } + AST_RWLIST_UNLOCK(&devices); + if (!pvt || !pvt->connected || pvt->owner) { + ast_log(LOG_WARNING, "Request to call on device %s which is not connected / already in use.\n", dest_dev); + *cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL; + return NULL; + } + + if ((pvt->type == MBL_TYPE_PHONE) && !dest_num) { + ast_log(LOG_WARNING, "Can't determine destination number.\n"); + *cause = AST_CAUSE_INCOMPATIBLE_DESTINATION; + return NULL; + } + + ast_mutex_lock(&pvt->lock); + chn = mbl_new(AST_STATE_DOWN, pvt, NULL, requestor); + ast_mutex_unlock(&pvt->lock); + if (!chn) { + ast_log(LOG_WARNING, "Unable to allocate channel structure.\n"); + *cause = AST_CAUSE_REQUESTED_CHAN_UNAVAIL; + return NULL; + } + + return chn; + +} + +static int mbl_call(struct ast_channel *ast, char *dest, int timeout) +{ + + struct mbl_pvt *pvt; + char *dest_dev = NULL; + char *dest_num = NULL; + + dest_dev = ast_strdupa((char *)dest); + + pvt = ast->tech_pvt; + + if (pvt->type == MBL_TYPE_PHONE) { + dest_num = strchr(dest_dev, '/'); + if (!dest_num) { + ast_log(LOG_WARNING, "Cant determine destination number.\n"); + return -1; + } + *dest_num++ = 0x00; + } + + if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) { + ast_log(LOG_WARNING, "mbl_call called on %s, neither down nor reserved\n", ast->name); + return -1; + } + + ast_debug(1, "Calling %s on %s\n", dest, ast->name); + + ast_mutex_lock(&pvt->lock); + if (pvt->type == MBL_TYPE_PHONE) { + if (hfp_send_atd(pvt->hfp, dest_num)) { + ast_mutex_unlock(&pvt->lock); + ast_log(LOG_ERROR, "error sending ATD command on %s\n", pvt->id); + return -1; + } + pvt->needchup = 1; + msg_queue_push(pvt, AT_OK, AT_D); + } else { + if (hsp_send_ring(pvt->rfcomm_socket)) { + ast_log(LOG_ERROR, "[%s] error ringing device\n", pvt->id); + ast_mutex_unlock(&pvt->lock); + return -1; + } + + if ((pvt->ring_sched_id = ast_sched_add(pvt->sched, 6000, headset_send_ring, pvt)) == -1) { + ast_log(LOG_ERROR, "[%s] error ringing device\n", pvt->id); + ast_mutex_unlock(&pvt->lock); + return -1; + } + + pvt->outgoing = 1; + pvt->needring = 1; + } + ast_mutex_unlock(&pvt->lock); + + return 0; + +} + +static int mbl_hangup(struct ast_channel *ast) +{ + + struct mbl_pvt *pvt; + + if (!ast->tech_pvt) { + ast_log(LOG_WARNING, "Asked to hangup channel not connected\n"); + return 0; + } + pvt = ast->tech_pvt; + + ast_debug(1, "[%s] hanging up device\n", pvt->id); + + ast_mutex_lock(&pvt->lock); + ast_channel_set_fd(ast, 0, -1); + close(pvt->sco_socket); + pvt->sco_socket = -1; + + if (pvt->needchup) { + hfp_send_chup(pvt->hfp); + msg_queue_push(pvt, AT_OK, AT_CHUP); + pvt->needchup = 0; + } + + pvt->outgoing = 0; + pvt->incoming = 0; + pvt->needring = 0; + pvt->owner = NULL; + ast->tech_pvt = NULL; + + ast_mutex_unlock(&pvt->lock); + + ast_setstate(ast, AST_STATE_DOWN); + + return 0; + +} + +static int mbl_answer(struct ast_channel *ast) +{ + + struct mbl_pvt *pvt; + + pvt = ast->tech_pvt; + + if (pvt->type == MBL_TYPE_HEADSET) + return 0; + + ast_mutex_lock(&pvt->lock); + if (pvt->incoming) { + hfp_send_ata(pvt->hfp); + msg_queue_push(pvt, AT_OK, AT_A); + pvt->answered = 1; + } + ast_mutex_unlock(&pvt->lock); + + return 0; + +} + +static int mbl_digit_end(struct ast_channel *ast, char digit, unsigned int duration) +{ + struct mbl_pvt *pvt = ast->tech_pvt; + + if (pvt->type == MBL_TYPE_HEADSET) + return 0; + + ast_mutex_lock(&pvt->lock); + if (hfp_send_dtmf(pvt->hfp, digit)) { + ast_mutex_unlock(&pvt->lock); + ast_debug(1, "[%s] error sending digit %c\n", pvt->id, digit); + return -1; + } + msg_queue_push(pvt, AT_OK, AT_VTS); + ast_mutex_unlock(&pvt->lock); + + ast_debug(1, "[%s] dialed %c\n", pvt->id, digit); + + return 0; +} + +static struct ast_frame *mbl_read(struct ast_channel *ast) +{ + + struct mbl_pvt *pvt = ast->tech_pvt; + struct ast_frame *fr = &ast_null_frame; + int r; + + ast_debug(3, "*** mbl_read()\n"); + + while (ast_mutex_trylock(&pvt->lock)) { + CHANNEL_DEADLOCK_AVOIDANCE(ast); + } + + if (!pvt->owner || pvt->sco_socket == -1) { + goto e_return; + } + + memset(&pvt->fr, 0x00, sizeof(struct ast_frame)); + pvt->fr.frametype = AST_FRAME_VOICE; + pvt->fr.subclass = DEVICE_FRAME_FORMAT; + pvt->fr.src = "Mobile"; + pvt->fr.offset = AST_FRIENDLY_OFFSET; + pvt->fr.mallocd = 0; + pvt->fr.delivery.tv_sec = 0; + pvt->fr.delivery.tv_usec = 0; + pvt->fr.data.ptr = pvt->io_buf + AST_FRIENDLY_OFFSET; + + if ((r = read(pvt->sco_socket, pvt->fr.data.ptr, DEVICE_FRAME_SIZE)) == -1) { + if (errno != EAGAIN && errno != EINTR) { + ast_debug(1, "[%s] read error %d, going to wait for new connection\n", pvt->id, errno); + close(pvt->sco_socket); + pvt->sco_socket = -1; + ast_channel_set_fd(ast, 0, -1); + } + goto e_return; + } + + pvt->fr.datalen = r; + pvt->fr.samples = r / 2; + + if (pvt->do_alignment_detection) + do_alignment_detection(pvt, pvt->fr.data.ptr, r); + + fr = ast_dsp_process(ast, pvt->dsp, &pvt->fr); + + ast_mutex_unlock(&pvt->lock); + + return fr; + +e_return: + ast_mutex_unlock(&pvt->lock); + return fr; +} + +static int mbl_write(struct ast_channel *ast, struct ast_frame *frame) +{ + + struct mbl_pvt *pvt = ast->tech_pvt; + struct ast_frame *f; + + ast_debug(3, "*** mbl_write\n"); + + if (frame->frametype != AST_FRAME_VOICE) { + return 0; + } + + while (ast_mutex_trylock(&pvt->lock)) { + CHANNEL_DEADLOCK_AVOIDANCE(ast); + } + + ast_smoother_feed(pvt->smoother, frame); + + while ((f = ast_smoother_read(pvt->smoother))) { + sco_write(pvt->sco_socket, f->data.ptr, f->datalen); + ast_frfree(f); + } + + ast_mutex_unlock(&pvt->lock); + + return 0; + +} + +static int mbl_fixup(struct ast_channel *oldchan, struct ast_channel *newchan) +{ + + struct mbl_pvt *pvt = oldchan->tech_pvt; + + if (!pvt) { + ast_debug(1, "fixup failed, no pvt on oldchan\n"); + return -1; + } + + ast_mutex_lock(&pvt->lock); + if (pvt->owner == oldchan) + pvt->owner = newchan; + ast_mutex_unlock(&pvt->lock); + + return 0; + +} + +static int mbl_devicestate(void *data) +{ + + char *device; + int res = AST_DEVICE_INVALID; + struct mbl_pvt *pvt; + + device = ast_strdupa(S_OR(data, "")); + + ast_debug(1, "Checking device state for device %s\n", device); + + AST_RWLIST_RDLOCK(&devices); + AST_RWLIST_TRAVERSE(&devices, pvt, entry) { + if (!strcmp(pvt->id, device)) + break; + } + AST_RWLIST_UNLOCK(&devices); + + if (!pvt) + return res; + + ast_mutex_lock(&pvt->lock); + if (pvt->connected) { + if (pvt->owner) + res = AST_DEVICE_INUSE; + else + res = AST_DEVICE_NOT_INUSE; + } + ast_mutex_unlock(&pvt->lock); + + return res; + +} + +/* + + Callback helpers + +*/ + +/* + + do_alignment_detection() + + This routine attempts to detect where we get misaligned sco audio data from the bluetooth adaptor. + + Its enabled by alignmentdetect=yes under the adapter entry in mobile.conf + + Some adapters suffer a problem where occasionally they will byte shift the audio stream one byte to the right. + The result is static or white noise on the inbound (from the adapter) leg of the call. + This is characterised by a sudden jump in magnitude of the value of the 16 bit samples. + + Here we look at the first 4 48 byte frames. We average the absolute values of each sample in the frame, + then average the sum of the averages of frames 1, 2, and 3. + Frame zero is usually zero. + If the end result > 100, and it usually is if we have the problem, set a flag and compensate by shifting the bytes + for each subsequent frame during the call. + + If the result is <= 100 then clear the flag so we dont come back in here... + + This seems to work OK.... + +*/ + +static void do_alignment_detection(struct mbl_pvt *pvt, char *buf, int buflen) +{ + + int i; + short a, *s; + char *p; + + if (pvt->alignment_detection_triggered) { + for (i=buflen, p=buf+buflen-1; i>0; i--, p--) + *p = *(p-1); + *(p+1) = 0; + return; + } + + if (pvt->alignment_count < 4) { + s = (short *)buf; + for (i=0, a=0; ialignment_samples[pvt->alignment_count++] = a; + return; + } + + ast_debug(1, "Alignment Detection result is [%-d %-d %-d %-d]\n", pvt->alignment_samples[0], pvt->alignment_samples[1], pvt->alignment_samples[2], pvt->alignment_samples[3]); + + a = abs(pvt->alignment_samples[1]) + abs(pvt->alignment_samples[2]) + abs(pvt->alignment_samples[3]); + a /= 3; + if (a > 100) { + pvt->alignment_detection_triggered = 1; + ast_debug(1, "Alignment Detection Triggered.\n"); + } else + pvt->do_alignment_detection = 0; + +} + +static int mbl_queue_control(struct mbl_pvt *pvt, enum ast_control_frame_type control) +{ + for (;;) { + if (pvt->owner) { + if (ast_channel_trylock(pvt->owner)) { + DEADLOCK_AVOIDANCE(&pvt->lock); + } else { + ast_queue_control(pvt->owner, control); + ast_channel_unlock(pvt->owner); + break; + } + } else + break; + } + return 0; +} + +static int mbl_queue_hangup(struct mbl_pvt *pvt) +{ + for (;;) { + if (pvt->owner) { + if (ast_channel_trylock(pvt->owner)) { + DEADLOCK_AVOIDANCE(&pvt->lock); + } else { + ast_queue_hangup(pvt->owner); + ast_channel_unlock(pvt->owner); + break; + } + } else + break; + } + return 0; +} + +static int mbl_ast_hangup(struct mbl_pvt *pvt) +{ + int res = 0; + for (;;) { + if (pvt->owner) { + if (ast_channel_trylock(pvt->owner)) { + DEADLOCK_AVOIDANCE(&pvt->lock); + } else { + res = ast_hangup(pvt->owner); + /* no need to unlock, ast_hangup() frees the + * channel */ + break; + } + } else + break; + } + return res; +} + +/* + + rfcomm helpers + +*/ + +static int rfcomm_connect(bdaddr_t src, bdaddr_t dst, int remote_channel) +{ + + struct sockaddr_rc addr; + int s; + + if ((s = socket(PF_BLUETOOTH, SOCK_STREAM, BTPROTO_RFCOMM)) < 0) { + ast_debug(1, "socket() failed (%d).\n", errno); + return -1; + } + + memset(&addr, 0, sizeof(addr)); + addr.rc_family = AF_BLUETOOTH; + bacpy(&addr.rc_bdaddr, &src); + addr.rc_channel = (uint8_t) 1; + if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + ast_debug(1, "bind() failed (%d).\n", errno); + close(s); + return -1; + } + + memset(&addr, 0, sizeof(addr)); + addr.rc_family = AF_BLUETOOTH; + bacpy(&addr.rc_bdaddr, &dst); + addr.rc_channel = remote_channel; + if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + ast_debug(1, "connect() failed (%d).\n", errno); + close(s); + return -1; + } + + return s; + +} + +/*! + * \brief Write to an rfcomm socket. + * \param rsock the socket to write to + * \param buf the null terminated buffer to write + * + * This function will write characters from buf. The buffer must be null + * terminated. + * + * \retval -1 error + * \retval 0 success + */ +static int rfcomm_write(int rsock, char *buf) +{ + return rfcomm_write_full(rsock, buf, strlen(buf)); +} + + +/*! + * \brief Write to an rfcomm socket. + * \param rsock the socket to write to + * \param buf the buffer to write + * \param count the number of characters from the buffer to write + * + * This function will write count characters from buf. It will always write + * count chars unless it encounters an error. + * + * \retval -1 error + * \retval 0 success + */ +static int rfcomm_write_full(int rsock, char *buf, size_t count) +{ + char *p = buf; + ssize_t out_count; + + ast_debug(1, "rfcomm_write() (%d) [%.*s]\n", rsock, (int) count, buf); + while (count > 0) { + if ((out_count = write(rsock, p, count)) == -1) { + ast_debug(1, "rfcomm_write() error [%d]\n", errno); + return -1; + } + count -= out_count; + p += out_count; + } + + return 0; +} + +/*! + * \brief Wait for activity on an rfcomm socket. + * \param rsock the socket to watch + * \param ms a pointer to an int containing a timeout in ms + * \return zero on timeout and the socket fd (non-zero) otherwise + * \retval 0 timeout + */ +static int rfcomm_wait(int rsock, int *ms) +{ + int exception, outfd; + outfd = ast_waitfor_n_fd(&rsock, 1, ms, &exception); + if (outfd < 0) + outfd = 0; + + return outfd; +} + +#ifdef RFCOMM_READ_DEBUG +#define rfcomm_read_debug(c) __rfcomm_read_debug(c) +static void __rfcomm_read_debug(char c) +{ + if (c == '\r') + ast_debug(2, "rfcomm_read: \\r\n"); + else if (c == '\n') + ast_debug(2, "rfcomm_read: \\n\n"); + else + ast_debug(2, "rfcomm_read: %c\n", c); +} +#else +#define rfcomm_read_debug(c) +#endif + +/*! + * \brief Append the given character to the given buffer and increase the + * in_count. + */ +static void inline rfcomm_append_buf(char **buf, size_t count, size_t *in_count, char c) +{ + if (*in_count < count) { + (*in_count)++; + *(*buf)++ = c; + } +} + +/*! + * \brief Read a character from the given stream and check if it matches what + * we expected. + */ +static int rfcomm_read_and_expect_char(int rsock, char *result, char expected) +{ + int res; + char c; + + if (!result) + result = &c; + + if ((res = read(rsock, result, 1)) < 1) { + return res; + } + rfcomm_read_debug(*result); + + if (*result != expected) { + return -2; + } + + return 1; +} + +/*! + * \brief Read a character from the given stream and append it to the given + * buffer if it matches the expected character. + */ +static int rfcomm_read_and_append_char(int rsock, char **buf, size_t count, size_t *in_count, char *result, char expected) +{ + int res; + char c; + + if (!result) + result = &c; + + if ((res = rfcomm_read_and_expect_char(rsock, result, expected)) < 1) { + return res; + } + + rfcomm_append_buf(buf, count, in_count, *result); + return 1; +} + +/*! + * \brief Read until '\r\n'. + * This function consumes the '\r\n' but does not add it to buf. + */ +static int rfcomm_read_until_crlf(int rsock, char **buf, size_t count, size_t *in_count) +{ + int res; + char c; + + while ((res = read(rsock, &c, 1)) == 1) { + rfcomm_read_debug(c); + if (c == '\r') { + if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) == 1) { + break; + } else if (res == -2) { + rfcomm_append_buf(buf, count, in_count, '\r'); + } else { + rfcomm_append_buf(buf, count, in_count, '\r'); + break; + } + } + + rfcomm_append_buf(buf, count, in_count, c); + } + return res; +} + +/*! + * \brief Read the remainder of an AT SMS prompt. + * \note the entire parsed string is '\r\n> ' + * + * By the time this function is executed, only a ' ' is left to read. + */ +static int rfcomm_read_sms_prompt(int rsock, char **buf, size_t count, size_t *in_count) +{ + int res; + if ((res = rfcomm_read_and_append_char(rsock, buf, count, in_count, NULL, ' ')) < 1) + goto e_return; + + return 1; + +e_return: + ast_log(LOG_ERROR, "error parsing SMS prompt on rfcomm socket\n"); + return res; +} + +/*! + * \brief Read and AT result code. + * \note the entire parsed string is '\r\n\r\n' + */ +static int rfcomm_read_result(int rsock, char **buf, size_t count, size_t *in_count) +{ + int res; + char c; + + if ((res = rfcomm_read_and_expect_char(rsock, &c, '\n')) < 1) { + goto e_return; + } + + if ((res = rfcomm_read_and_append_char(rsock, buf, count, in_count, &c, '>')) == 1) { + return rfcomm_read_sms_prompt(rsock, buf, count, in_count); + } else if (res != -2) { + goto e_return; + } + + rfcomm_append_buf(buf, count, in_count, c); + res = rfcomm_read_until_crlf(rsock, buf, count, in_count); + + if (res != 1) + return res; + + /* check for CMGR, which contains an embedded \r\n */ + if (*in_count >= 5 && !strncmp(*buf - *in_count, "+CMGR", 5)) { + rfcomm_append_buf(buf, count, in_count, '\r'); + rfcomm_append_buf(buf, count, in_count, '\n'); + return rfcomm_read_until_crlf(rsock, buf, count, in_count); + } + + return 1; + +e_return: + ast_log(LOG_ERROR, "error parsing AT result on rfcomm socket"); + return res; +} + +/*! + * \brief Read the remainder of an AT command. + * \note the entire parsed string is '\r' + */ +static int rfcomm_read_command(int rsock, char **buf, size_t count, size_t *in_count) +{ + int res; + char c; + + while ((res = read(rsock, &c, 1)) == 1) { + rfcomm_read_debug(c); + /* stop when we get to '\r' */ + if (c == '\r') + break; + + rfcomm_append_buf(buf, count, in_count, c); + } + return res; +} + +/*! + * \brief Read one Hayes AT message from an rfcomm socket. + * \param rsock the rfcomm socket to read from + * \param buf the buffer to store the result in + * \param count the size of the buffer or the maximum number of characters to read + * + * Here we need to read complete Hayes AT messages. The AT message formats we + * support are listed below. + * + * \verbatim + * \r\n\r\n + * \r + * \r\n> + * \endverbatim + * + * These formats correspond to AT result codes, AT commands, and the AT SMS + * prompt respectively. When messages are read the leading and trailing '\r' + * and '\n' characters are discarded. If the given buffer is not large enough + * to hold the response, what does not fit in the buffer will be dropped. + * + * \note The rfcomm connection to the device is asynchronous, so there is no + * guarantee that responses will be returned in a single read() call. We handle + * this by blocking until we can read an entire response. + * + * \retval 0 end of file + * \retval -1 read error + * \retval -2 parse error + * \retval other the number of characters added to buf + */ +static ssize_t rfcomm_read(int rsock, char *buf, size_t count) +{ + ssize_t res; + size_t in_count = 0; + char c; + + if ((res = rfcomm_read_and_expect_char(rsock, &c, '\r')) == 1) { + res = rfcomm_read_result(rsock, &buf, count, &in_count); + } else if (res == -2) { + rfcomm_append_buf(&buf, count, &in_count, c); + res = rfcomm_read_command(rsock, &buf, count, &in_count); + } + + if (res < 1) + return res; + else + return in_count; +} + +/* + + sco helpers and callbacks + +*/ + +static int sco_connect(bdaddr_t src, bdaddr_t dst) +{ + + struct sockaddr_sco addr; + int s; + + if ((s = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) { + ast_debug(1, "socket() failed (%d).\n", errno); + return -1; + } + +/* XXX this does not work with the do_sco_listen() thread (which also bind()s + * to this address). Also I am not sure if it is necessary. */ +#if 0 + memset(&addr, 0, sizeof(addr)); + addr.sco_family = AF_BLUETOOTH; + bacpy(&addr.sco_bdaddr, &src); + if (bind(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + ast_debug(1, "bind() failed (%d).\n", errno); + close(s); + return -1; + } +#endif + + memset(&addr, 0, sizeof(addr)); + addr.sco_family = AF_BLUETOOTH; + bacpy(&addr.sco_bdaddr, &dst); + + if (connect(s, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + ast_debug(1, "sco connect() failed (%d).\n", errno); + close(s); + return -1; + } + + return s; + +} + +static int sco_write(int s, char *buf, int len) +{ + + int r; + + if (s == -1) { + ast_debug(3, "sco_write() not ready\n"); + return 0; + } + + ast_debug(3, "sco_write()\n"); + + r = write(s, buf, len); + if (r == -1) { + ast_debug(3, "sco write error %d\n", errno); + return 0; + } + + return 1; + +} + +/*! + * \brief Accept SCO connections. + * This function is an ast_io callback function used to accept incoming sco + * audio connections. + */ +static int sco_accept(int *id, int fd, short events, void *data) +{ + struct adapter_pvt *adapter = (struct adapter_pvt *) data; + struct sockaddr_sco addr; + socklen_t addrlen; + struct mbl_pvt *pvt; + socklen_t len; + char saddr[18]; + struct sco_options so; + int sock; + + addrlen = sizeof(struct sockaddr_sco); + if ((sock = accept(fd, (struct sockaddr *)&addr, &addrlen)) == -1) { + ast_log(LOG_ERROR, "error accepting audio connection on adapter %s\n", adapter->id); + return 0; + } + + len = sizeof(so); + getsockopt(sock, SOL_SCO, SCO_OPTIONS, &so, &len); + + ba2str(&addr.sco_bdaddr, saddr); + ast_debug(1, "Incoming Audio Connection from device %s MTU is %d\n", saddr, so.mtu); + + /* figure out which device this sco connection belongs to */ + pvt = NULL; + AST_RWLIST_RDLOCK(&devices); + AST_RWLIST_TRAVERSE(&devices, pvt, entry) { + if (!bacmp(&pvt->addr, &addr.sco_bdaddr)) + break; + } + AST_RWLIST_UNLOCK(&devices); + if (!pvt) { + ast_log(LOG_WARNING, "could not find device for incoming audio connection\n"); + close(sock); + return 1; + } + + ast_mutex_lock(&pvt->lock); + if (pvt->sco_socket != -1) { + close(pvt->sco_socket); + pvt->sco_socket = -1; + } + + pvt->sco_socket = sock; + if (pvt->owner) { + ast_channel_set_fd(pvt->owner, 0, sock); + } else { + ast_debug(1, "incoming audio connection for pvt without owner\n"); + } + + ast_mutex_unlock(&pvt->lock); + + return 1; +} + +/*! + * \brief Bind an SCO listener socket for the given adapter. + * \param adapter an adapter_pvt + * \return -1 on error, non zero on success + */ +static int sco_bind(struct adapter_pvt *adapter) +{ + struct sockaddr_sco addr; + int opt = 1; + + if ((adapter->sco_socket = socket(PF_BLUETOOTH, SOCK_SEQPACKET, BTPROTO_SCO)) < 0) { + ast_log(LOG_ERROR, "Unable to create sco listener socket for adapter %s.\n", adapter->id); + goto e_return; + } + + memset(&addr, 0, sizeof(addr)); + addr.sco_family = AF_BLUETOOTH; + bacpy(&addr.sco_bdaddr, &adapter->addr); + if (bind(adapter->sco_socket, (struct sockaddr *)&addr, sizeof(addr)) < 0) { + ast_log(LOG_ERROR, "Unable to bind sco listener socket. (%d)\n", errno); + goto e_close_socket; + } + if (setsockopt(adapter->sco_socket, SOL_SOCKET, SO_REUSEADDR, &opt, sizeof(opt)) == -1) { + ast_log(LOG_ERROR, "Unable to setsockopt sco listener socket.\n"); + goto e_close_socket; + } + if (listen(adapter->sco_socket, 5) < 0) { + ast_log(LOG_ERROR, "Unable to listen sco listener socket.\n"); + goto e_close_socket; + } + + return adapter->sco_socket; + +e_close_socket: + close(adapter->sco_socket); + adapter->sco_socket = -1; +e_return: + return -1; +} + + +/* + * Hayes AT command helpers. + */ + +/*! + * \brief Match the given buffer with the given prefix. + * \param buf the buffer to match + * \param prefix the prefix to match + */ +static int at_match_prefix(char *buf, char *prefix) +{ + return !strncmp(buf, prefix, strlen(prefix)); +} + +/*! + * \brief Read an AT message and clasify it. + * \param rsock an rfcomm socket + * \param buf the buffer to store the result in + * \param count the size of the buffer or the maximum number of characters to read + * \return the type of message received, in addition buf will contain the + * message received and will be null terminated + * \see at_read() + */ +static at_message_t at_read_full(int rsock, char *buf, size_t count) +{ + ssize_t s; + if ((s = rfcomm_read(rsock, buf, count - 1)) < 1) + return s; + buf[s] = '\0'; + + if (!strcmp("OK", buf)) { + return AT_OK; + } else if (!strcmp("ERROR", buf)) { + return AT_ERROR; + } else if (!strcmp("RING", buf)) { + return AT_RING; + } else if (!strcmp("AT+CKPD=200", buf)) { + return AT_CKPD; + } else if (!strcmp("> ", buf)) { + return AT_SMS_PROMPT; + } else if (at_match_prefix(buf, "+CMTI:")) { + return AT_CMTI; + } else if (at_match_prefix(buf, "+CIEV:")) { + return AT_CIEV; + } else if (at_match_prefix(buf, "+BRSF:")) { + return AT_BRSF; + } else if (at_match_prefix(buf, "+CIND:")) { + return AT_CIND; + } else if (at_match_prefix(buf, "+CLIP:")) { + return AT_CLIP; + } else if (at_match_prefix(buf, "+CMGR:")) { + return AT_CMGR; + } else if (at_match_prefix(buf, "+VGM:")) { + return AT_VGM; + } else if (at_match_prefix(buf, "+VGS:")) { + return AT_VGS; + } else if (at_match_prefix(buf, "+CMS ERROR:")) { + return AT_CMS_ERROR; + } else if (at_match_prefix(buf, "AT+VGM=")) { + return AT_VGM; + } else if (at_match_prefix(buf, "AT+VGS=")) { + return AT_VGS; + } else { + return AT_UNKNOWN; + } +} + +/*! + * \brief Get the string representation of the given AT message. + * \param msg the message to process + * \return a string describing the given message + */ +static inline const char *at_msg2str(at_message_t msg) +{ + switch (msg) { + /* errors */ + case AT_PARSE_ERROR: + return "PARSE ERROR"; + case AT_READ_ERROR: + return "READ ERROR"; + default: + case AT_UNKNOWN: + return "UNKNOWN"; + /* at responses */ + case AT_OK: + return "OK"; + case AT_ERROR: + return "ERROR"; + case AT_RING: + return "RING"; + case AT_BRSF: + return "AT+BRSF"; + case AT_CIND: + return "AT+CIND"; + case AT_CIEV: + return "AT+CIEV"; + case AT_CLIP: + return "AT+CLIP"; + case AT_CMTI: + return "AT+CMTI"; + case AT_CMGR: + return "AT+CMGR"; + case AT_SMS_PROMPT: + return "SMS PROMPT"; + case AT_CMS_ERROR: + return "+CMS ERROR"; + /* at commands */ + case AT_A: + return "ATA"; + case AT_D: + return "ATD"; + case AT_CHUP: + return "AT+CHUP"; + case AT_CKPD: + return "AT+CKPD"; + case AT_CMGS: + return "AT+CMGS"; + case AT_VGM: + return "AT+VGM"; + case AT_VGS: + return "AT+VGS"; + case AT_VTS: + return "AT+VTS"; + case AT_CMGF: + return "AT+CMGF"; + case AT_CNMI: + return "AT+CNMI"; + case AT_CMER: + return "AT+CMER"; + case AT_CIND_TEST: + return "AT+CIND=?"; + } +} + + +/* + * bluetooth handsfree profile helpers + */ + +/*! + * \brief Parse a CIEV event. + * \param hfp an hfp_pvt struct + * \param buf the buffer to parse (null terminated) + * \param value a pointer to an int to store the event value in (can be NULL) + * \return 0 on error (parse error, or unknown event) or a HFP_CIND_* value on + * success + */ +static int hfp_parse_ciev(struct hfp_pvt *hfp, char *buf, int *value) +{ + int i, v; + if (!value) + value = &v; + + if (!sscanf(buf, "+CIEV: %d,%d", &i, value)) { + ast_debug(2, "[%s] error parsing CIEV event '%s'\n", hfp->owner->id, buf); + return HFP_CIND_NONE; + } + + if (i >= sizeof(hfp->cind_state)) { + ast_debug(2, "[%s] CIEV event index too high (%s)\n", hfp->owner->id, buf); + return HFP_CIND_NONE; + } + + hfp->cind_state[i] = *value; + return hfp->cind_index[i]; +} + +/*! + * \brief Parse a CLIP event. + * \param hfp an hfp_pvt struct + * \param buf the buffer to parse (null terminated) + * @note buf will be modified when the CID string is parsed + * \return NULL on error (parse error) or a pointer to the caller id + * inforamtion in buf + * success + */ +static char *hfp_parse_clip(struct hfp_pvt *hfp, char *buf) +{ + int i, state; + char *clip = NULL; + size_t s; + + /* parse clip info in the following format: + * +CLIP: "123456789",128,... + */ + state = 0; + s = strlen(buf); + for (i = 0; i < s && state != 3; i++) { + switch (state) { + case 0: /* search for start of the number (") */ + if (buf[i] == '"') { + state++; + } + break; + case 1: /* mark the number */ + clip = &buf[i]; + state++; + /* fall through */ + case 2: /* search for the end of the number (") */ + if (buf[i] == '"') { + buf[i] = '\0'; + state++; + } + break; + } + } + + if (state != 3) { + return NULL; + } + + return clip; +} + +/*! + * \brief Parse a CMTI notification. + * \param hfp an hfp_pvt struct + * \param buf the buffer to parse (null terminated) + * @note buf will be modified when the CMTI message is parsed + * \return -1 on error (parse error) or the index of the new sms message + */ +static int hfp_parse_cmti(struct hfp_pvt *hfp, char *buf) +{ + int index = -1; + + /* parse cmti info in the following format: + * +CMTI: , + */ + if (!sscanf(buf, "+CMTI: %*[^,],%d", &index)) { + ast_debug(2, "[%s] error parsing CMTI event '%s'\n", hfp->owner->id, buf); + return -1; + } + + return index; +} + +/*! + * \brief Parse a CMGR message. + * \param hfp an hfp_pvt struct + * \param buf the buffer to parse (null terminated) + * \param from_number a pointer to a char pointer which will store the from + * number + * \param text a pointer to a char pointer which will store the message text + * @note buf will be modified when the CMGR message is parsed + * \retval -1 parse error + * \retval 0 success + */ +static int hfp_parse_cmgr(struct hfp_pvt *hfp, char *buf, char **from_number, char **text) +{ + int i, state; + size_t s; + + /* parse cmgr info in the following format: + * +CMGR: ,"+123456789",...\r\n + * + */ + state = 0; + s = strlen(buf); + for (i = 0; i < s && s != 6; i++) { + switch (state) { + case 0: /* search for start of the number section (,) */ + if (buf[i] == ',') { + state++; + } + break; + case 1: /* find the opening quote (") */ + if (buf[i] == '"') { + state++; + } + case 2: /* mark the start of the number */ + if (from_number) { + *from_number = &buf[i]; + state++; + } + /* fall through */ + case 3: /* search for the end of the number (") */ + if (buf[i] == '"') { + buf[i] = '\0'; + state++; + } + break; + case 4: /* search for the start of the message text (\n) */ + if (buf[i] == '\n') { + state++; + } + break; + case 5: /* mark the start of the message text */ + if (text) { + *text = &buf[i]; + state++; + } + break; + } + } + + if (state != 6) { + return -1; + } + + return 0; +} + +/*! + * \brief Convert a hfp_hf struct to a BRSF int. + * \param hf an hfp_hf brsf object + * \return an integer representing the given brsf struct + */ +static int hfp_brsf2int(struct hfp_hf *hf) +{ + int brsf = 0; + + brsf |= hf->ecnr ? HFP_HF_ECNR : 0; + brsf |= hf->cw ? HFP_HF_CW : 0; + brsf |= hf->cid ? HFP_HF_CID : 0; + brsf |= hf->voice ? HFP_HF_VOICE : 0; + brsf |= hf->volume ? HFP_HF_VOLUME : 0; + brsf |= hf->status ? HFP_HF_STATUS : 0; + brsf |= hf->control ? HFP_HF_CONTROL : 0; + + return brsf; +} + +/*! + * \brief Convert a BRSF int to an hfp_ag struct. + * \param brsf a brsf integer + * \param ag a AG (hfp_ag) brsf object + * \return a pointer to the given hfp_ag object populated with the values from + * the given brsf integer + */ +static struct hfp_ag *hfp_int2brsf(int brsf, struct hfp_ag *ag) +{ + ag->cw = brsf & HFP_AG_CW ? 1 : 0; + ag->ecnr = brsf & HFP_AG_ECNR ? 1 : 0; + ag->voice = brsf & HFP_AG_VOICE ? 1 : 0; + ag->ring = brsf & HFP_AG_RING ? 1 : 0; + ag->tag = brsf & HFP_AG_TAG ? 1 : 0; + ag->reject = brsf & HFP_AG_REJECT ? 1 : 0; + ag->status = brsf & HFP_AG_STATUS ? 1 : 0; + ag->control = brsf & HFP_AG_CONTROL ? 1 : 0; + ag->errors = brsf & HFP_AG_ERRORS ? 1 : 0; + + return ag; +} + + +/*! + * \brief Send a BRSF request. + * \param hfp an hfp_pvt struct + * \param brsf an hfp_hf brsf struct + * + * \retval 0 on success + * \retval -1 on error + */ +static int hfp_send_brsf(struct hfp_pvt *hfp, struct hfp_hf *brsf) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "AT+BRSF=%d\r", hfp_brsf2int(brsf)); + return rfcomm_write(hfp->rsock, cmd); +} + +/*! + * \brief Send the CIND read command. + * \param hfp an hfp_pvt struct + */ +static int hfp_send_cind(struct hfp_pvt *hfp) +{ + return rfcomm_write(hfp->rsock, "AT+CIND?\r"); +} + +/*! + * \brief Send the CIND test command. + * \param hfp an hfp_pvt struct + */ +static int hfp_send_cind_test(struct hfp_pvt *hfp) +{ + return rfcomm_write(hfp->rsock, "AT+CIND=?\r"); +} + +/*! + * \brief Enable or disable indicator events reporting. + * \param hfp an hfp_pvt struct + * \param status enable or disable events reporting (should be 1 or 0) + */ +static int hfp_send_cmer(struct hfp_pvt *hfp, int status) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "AT+CMER=3,0,0,%d\r", status ? 1 : 0); + return rfcomm_write(hfp->rsock, cmd); +} + +/*! + * \brief Send the current speaker gain level. + * \param hfp an hfp_pvt struct + * \param value the value to send (must be between 0 and 15) + */ +static int hfp_send_vgs(struct hfp_pvt *hfp, int value) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "AT+VGS=%d\r", value); + return rfcomm_write(hfp->rsock, cmd); +} + +#if 0 +/*! + * \brief Send the current microphone gain level. + * \param hfp an hfp_pvt struct + * \param value the value to send (must be between 0 and 15) + */ +static int hfp_send_vgm(struct hfp_pvt *hfp, int value) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "AT+VGM=%d\r", value); + return rfcomm_write(hfp->rsock, cmd); +} +#endif + +/*! + * \brief Enable or disable calling line identification. + * \param hfp an hfp_pvt struct + * \param status enable or disable calling line identification (should be 1 or + * 0) + */ +static int hfp_send_clip(struct hfp_pvt *hfp, int status) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "AT+CLIP=%d\r", status ? 1 : 0); + return rfcomm_write(hfp->rsock, cmd); +} + +/*! + * \brief Send a DTMF command. + * \param hfp an hfp_pvt struct + * \param digit the dtmf digit to send + * \return the result of rfcomm_write() or -1 on an invalid digit being sent + */ +static int hfp_send_dtmf(struct hfp_pvt *hfp, char digit) +{ + char cmd[10]; + + switch(digit) { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + case '*': + case '#': + snprintf(cmd, sizeof(cmd), "AT+VTS=%c\r", digit); + return rfcomm_write(hfp->rsock, cmd); + default: + return -1; + } +} + +/*! + * \brief Set the SMS mode. + * \param hfp an hfp_pvt struct + * \param mode the sms mode (0 = PDU, 1 = Text) + */ +static int hfp_send_cmgf(struct hfp_pvt *hfp, int mode) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "AT+CMGF=%d\r", mode); + return rfcomm_write(hfp->rsock, cmd); +} + +/*! + * \brief Setup SMS new message indication. + * \param hfp an hfp_pvt struct + */ +static int hfp_send_cnmi(struct hfp_pvt *hfp) +{ + return rfcomm_write(hfp->rsock, "AT+CNMI=2,1,0,0,0\r"); +} + +/*! + * \brief Read an SMS message. + * \param hfp an hfp_pvt struct + * \param index the location of the requested message + */ +static int hfp_send_cmgr(struct hfp_pvt *hfp, int index) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "AT+CMGR=%d\r", index); + return rfcomm_write(hfp->rsock, cmd); +} + +/*! + * \brief Start sending an SMS message. + * \param hfp an hfp_pvt struct + * \param number the destination of the message + */ +static int hfp_send_cmgs(struct hfp_pvt *hfp, const char *number) +{ + char cmd[64]; + snprintf(cmd, sizeof(cmd), "AT+CMGS=\"%s\"\r", number); + return rfcomm_write(hfp->rsock, cmd); +} + +/*! + * \brief Send the text of an SMS message. + * \param hfp an hfp_pvt struct + * \param message the text of the message + */ +static int hfp_send_sms_text(struct hfp_pvt *hfp, const char *message) +{ + char cmd[162]; + snprintf(cmd, sizeof(cmd), "%.160s\x1a", message); + return rfcomm_write(hfp->rsock, cmd); +} + +/*! + * \brief Send AT+CHUP. + * \param hfp an hfp_pvt struct + */ +static int hfp_send_chup(struct hfp_pvt *hfp) +{ + return rfcomm_write(hfp->rsock, "AT+CHUP\r"); +} + +/*! + * \brief Send ATD. + * \param hfp an hfp_pvt struct + * \param number the number to send + */ +static int hfp_send_atd(struct hfp_pvt *hfp, const char *number) +{ + char cmd[64]; + snprintf(cmd, sizeof(cmd), "ATD%s;\r", number); + return rfcomm_write(hfp->rsock, cmd); +} + +/*! + * \brief Send ATA. + * \param hfp an hfp_pvt struct + */ +static int hfp_send_ata(struct hfp_pvt *hfp) +{ + return rfcomm_write(hfp->rsock, "ATA\r"); +} + +/*! + * \brief Parse BRSF data. + * \param hfp an hfp_pvt struct + * \param buf the buffer to parse (null terminated) + */ +static int hfp_parse_brsf(struct hfp_pvt *hfp, const char *buf) +{ + int brsf; + + if (!sscanf(buf, "+BRSF:%d", &brsf)) + return -1; + + hfp_int2brsf(brsf, &hfp->brsf); + + return 0; +} + +/*! + * \brief Parse and store the given indicator. + * \param hfp an hfp_pvt struct + * \param group the indicator group + * \param indicator the indicator to parse + */ +static int hfp_parse_cind_indicator(struct hfp_pvt *hfp, int group, char *indicator) +{ + int value; + + /* store the current indicator */ + if (group >= sizeof(hfp->cind_state)) { + ast_debug(1, "ignoring CIND state '%s' for group %d, we only support up to %d indicators\n", indicator, group, (int) sizeof(hfp->cind_state)); + return -1; + } + + if (!sscanf(indicator, "%d", &value)) { + ast_debug(1, "error parsing CIND state '%s' for group %d\n", indicator, group); + return -1; + } + + hfp->cind_state[group] = value; + return 0; +} + +/*! + * \brief Read the result of the AT+CIND? command. + * \param hfp an hfp_pvt struct + * \param buf the buffer to parse (null terminated) + * \note hfp_send_cind_test() and hfp_parse_cind_test() should be called at + * least once before this function is called. + */ +static int hfp_parse_cind(struct hfp_pvt *hfp, char *buf) +{ + int i, state, group; + size_t s; + char *indicator = NULL; + + /* parse current state of all of our indicators. The list is in the + * following format: + * +CIND: 1,0,2,0,0,0,0 + */ + group = 0; + state = 0; + s = strlen(buf); + for (i = 0; i < s; i++) { + switch (state) { + case 0: /* search for start of the status indicators (a space) */ + if (buf[i] == ' ') { + group++; + state++; + } + break; + case 1: /* mark this indicator */ + indicator = &buf[i]; + state++; + break; + case 2: /* search for the start of the next indicator (a comma) */ + if (buf[i] == ',') { + buf[i] = '\0'; + + hfp_parse_cind_indicator(hfp, group, indicator); + + group++; + state = 1; + } + break; + } + } + + /* store the last indicator */ + if (state == 2) + hfp_parse_cind_indicator(hfp, group, indicator); + + return 0; +} + +/*! + * \brief Parse the result of the AT+CIND=? command. + * \param hfp an hfp_pvt struct + * \param buf the buffer to parse (null terminated) + */ +static int hfp_parse_cind_test(struct hfp_pvt *hfp, char *buf) +{ + int i, state, group; + size_t s; + char *indicator = NULL, *values; + + hfp->nocallsetup = 1; + + /* parse the indications list. It is in the follwing format: + * +CIND: ("ind1",(0-1)),("ind2",(0-5)) + */ + group = 0; + state = 0; + s = strlen(buf); + for (i = 0; i < s; i++) { + switch (state) { + case 0: /* search for start of indicator block */ + if (buf[i] == '(') { + group++; + state++; + } + break; + case 1: /* search for '"' in indicator block */ + if (buf[i] == '"') { + state++; + } + break; + case 2: /* mark the start of the indicator name */ + indicator = &buf[i]; + state++; + break; + case 3: /* look for the end of the indicator name */ + if (buf[i] == '"') { + buf[i] = '\0'; + state++; + } + break; + case 4: /* find the start of the value range */ + if (buf[i] == '(') { + state++; + } + break; + case 5: /* mark the start of the value range */ + values = &buf[i]; + state++; + break; + case 6: /* find the end of the value range */ + if (buf[i] == ')') { + buf[i] = '\0'; + state++; + } + break; + case 7: /* process the values we found */ + if (group < sizeof(hfp->cind_index)) { + if (!strcmp(indicator, "service")) { + hfp->cind_map.service = group; + hfp->cind_index[group] = HFP_CIND_SERVICE; + } else if (!strcmp(indicator, "call")) { + hfp->cind_map.call = group; + hfp->cind_index[group] = HFP_CIND_CALL; + } else if (!strcmp(indicator, "callsetup")) { + hfp->nocallsetup = 0; + hfp->cind_map.callsetup = group; + hfp->cind_index[group] = HFP_CIND_CALLSETUP; + } else if (!strcmp(indicator, "call_setup")) { /* non standard call setup identifier */ + hfp->nocallsetup = 0; + hfp->cind_map.callsetup = group; + hfp->cind_index[group] = HFP_CIND_CALLSETUP; + } else if (!strcmp(indicator, "callheld")) { + hfp->cind_map.callheld = group; + hfp->cind_index[group] = HFP_CIND_CALLHELD; + } else if (!strcmp(indicator, "signal")) { + hfp->cind_map.signal = group; + hfp->cind_index[group] = HFP_CIND_SIGNAL; + } else if (!strcmp(indicator, "roam")) { + hfp->cind_map.roam = group; + hfp->cind_index[group] = HFP_CIND_ROAM; + } else if (!strcmp(indicator, "battchg")) { + hfp->cind_map.battchg = group; + hfp->cind_index[group] = HFP_CIND_BATTCHG; + } else { + hfp->cind_index[group] = HFP_CIND_UNKNOWN; + ast_debug(2, "ignoring unknown CIND indicator '%s'\n", indicator); + } + } else { + ast_debug(1, "can't store indicator %d (%s), we only support up to %d indicators", group, indicator, (int) sizeof(hfp->cind_index)); + } + + state = 0; + break; + } + } + + hfp->owner->no_callsetup = hfp->nocallsetup; + + return 0; +} + + +/* + * Bluetooth Headset Profile helpers + */ + +/*! + * \brief Send an OK AT response. + * \param rsock the rfcomm socket to use + */ +static int hsp_send_ok(int rsock) +{ + return rfcomm_write(rsock, "\r\nOK\r\n"); +} + +/*! + * \brief Send an ERROR AT response. + * \param rsock the rfcomm socket to use + */ +static int hsp_send_error(int rsock) +{ + return rfcomm_write(rsock, "\r\nERROR\r\n"); +} + +/*! + * \brief Send a speaker gain unsolicited AT response + * \param rsock the rfcomm socket to use + * \param gain the speaker gain value + */ +static int hsp_send_vgs(int rsock, int gain) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "\r\n+VGS=%d\r\n", gain); + return rfcomm_write(rsock, cmd); +} + +/*! + * \brief Send a microphone gain unsolicited AT response + * \param rsock the rfcomm socket to use + * \param gain the microphone gain value + */ +static int hsp_send_vgm(int rsock, int gain) +{ + char cmd[32]; + snprintf(cmd, sizeof(cmd), "\r\n+VGM=%d\r\n", gain); + return rfcomm_write(rsock, cmd); +} + +/*! + * \brief Send a RING unsolicited AT response. + * \param rsock the rfcomm socket to use + */ +static int hsp_send_ring(int rsock) +{ + return rfcomm_write(rsock, "\r\nRING\r\n"); +} + +/* + * message queue functions + */ + +/*! + * \brief Add an item to the back of the queue. + * \param pvt a mbl_pvt structure + * \param expect the msg we expect to recieve + * \param response_to the message that was sent to generate the expected + * response + */ +static int msg_queue_push(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to) +{ + struct msg_queue_entry *msg; + if (!(msg = ast_calloc(1, sizeof(*msg)))) { + return -1; + } + msg->expected = expect; + msg->response_to = response_to; + + AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry); + return 0; +} + +/*! + * \brief Add an item to the back of the queue with data. + * \param pvt a mbl_pvt structure + * \param expect the msg we expect to recieve + * \param response_to the message that was sent to generate the expected + * response + * \param data data associated with this message, it will be freed when the + * message is freed + */ +static int msg_queue_push_data(struct mbl_pvt *pvt, at_message_t expect, at_message_t response_to, void *data) +{ + struct msg_queue_entry *msg; + if (!(msg = ast_calloc(1, sizeof(*msg)))) { + return -1; + } + msg->expected = expect; + msg->response_to = response_to; + msg->data = data; + + AST_LIST_INSERT_TAIL(&pvt->msg_queue, msg, entry); + return 0; +} + +/*! + * \brief Remove an item from the front of the queue. + * \param pvt a mbl_pvt structure + * \return a pointer to the removed item + */ +static struct msg_queue_entry *msg_queue_pop(struct mbl_pvt *pvt) +{ + return AST_LIST_REMOVE_HEAD(&pvt->msg_queue, entry); +} + +/*! + * \brief Remove an item from the front of the queue, and free it. + * \param pvt a mbl_pvt structure + */ +static void msg_queue_free_and_pop(struct mbl_pvt *pvt) +{ + struct msg_queue_entry *msg; + if ((msg = msg_queue_pop(pvt))) { + if (msg->data) + ast_free(msg->data); + ast_free(msg); + } +} + +/*! + * \brief Remove all itmes from the queue and free them. + * \param pvt a mbl_pvt structure + */ +static void msg_queue_flush(struct mbl_pvt *pvt) +{ + struct msg_queue_entry *msg; + while ((msg = msg_queue_head(pvt))) + msg_queue_free_and_pop(pvt); +} + +/*! + * \brief Get the head of a queue. + * \param pvt a mbl_pvt structure + * \return a pointer to the head of the given msg queue + */ +static struct msg_queue_entry *msg_queue_head(struct mbl_pvt *pvt) +{ + return AST_LIST_FIRST(&pvt->msg_queue); +} + + + +/* + + sdp helpers + +*/ + +static int sdp_search(char *addr, int profile) +{ + + sdp_session_t *session = 0; + bdaddr_t bdaddr; + uuid_t svc_uuid; + uint32_t range = 0x0000ffff; + sdp_list_t *response_list, *search_list, *attrid_list; + int status, port; + sdp_list_t *proto_list; + sdp_record_t *sdprec; + + str2ba(addr, &bdaddr); + port = 0; + session = sdp_connect(BDADDR_ANY, &bdaddr, SDP_RETRY_IF_BUSY); + if (!session) { + ast_debug(1, "sdp_connect() failed on device %s.\n", addr); + return 0; + } + + sdp_uuid32_create(&svc_uuid, profile); + search_list = sdp_list_append(0, &svc_uuid); + attrid_list = sdp_list_append(0, &range); + response_list = 0x00; + status = sdp_service_search_attr_req(session, search_list, SDP_ATTR_REQ_RANGE, attrid_list, &response_list); + if (status == 0) { + if (response_list) { + sdprec = (sdp_record_t *) response_list->data; + proto_list = 0x00; + if (sdp_get_access_protos(sdprec, &proto_list) == 0) { + port = sdp_get_proto_port(proto_list, RFCOMM_UUID); + sdp_list_free(proto_list, 0); + } + sdp_record_free(sdprec); + sdp_list_free(response_list, 0); + } else + ast_debug(1, "No responses returned for device %s.\n", addr); + } else + ast_debug(1, "sdp_service_search_attr_req() failed on device %s.\n", addr); + + sdp_list_free(search_list, 0); + sdp_list_free(attrid_list, 0); + sdp_close(session); + + return port; + +} + +static sdp_session_t *sdp_register(void) +{ + + uint32_t service_uuid_int[] = {0, 0, 0, GENERIC_AUDIO_SVCLASS_ID}; + uint8_t rfcomm_channel = 1; + const char *service_name = "Asterisk PABX"; + const char *service_dsc = "Asterisk PABX"; + const char *service_prov = "Asterisk"; + + uuid_t root_uuid, l2cap_uuid, rfcomm_uuid, svc_uuid, svc_class1_uuid, svc_class2_uuid; + sdp_list_t *l2cap_list = 0, *rfcomm_list = 0, *root_list = 0, *proto_list = 0, *access_proto_list = 0, *svc_uuid_list = 0; + sdp_data_t *channel = 0; + + int err = 0; + sdp_session_t *session = 0; + + sdp_record_t *record = sdp_record_alloc(); + + sdp_uuid128_create(&svc_uuid, &service_uuid_int); + sdp_set_service_id(record, svc_uuid); + + sdp_uuid32_create(&svc_class1_uuid, GENERIC_AUDIO_SVCLASS_ID); + sdp_uuid32_create(&svc_class2_uuid, HEADSET_PROFILE_ID); + + svc_uuid_list = sdp_list_append(0, &svc_class1_uuid); + svc_uuid_list = sdp_list_append(svc_uuid_list, &svc_class2_uuid); + sdp_set_service_classes(record, svc_uuid_list); + + sdp_uuid16_create(&root_uuid, PUBLIC_BROWSE_GROUP); + root_list = sdp_list_append(0, &root_uuid); + sdp_set_browse_groups( record, root_list ); + + sdp_uuid16_create(&l2cap_uuid, L2CAP_UUID); + l2cap_list = sdp_list_append(0, &l2cap_uuid); + proto_list = sdp_list_append(0, l2cap_list); + + sdp_uuid16_create(&rfcomm_uuid, RFCOMM_UUID); + channel = sdp_data_alloc(SDP_UINT8, &rfcomm_channel); + rfcomm_list = sdp_list_append(0, &rfcomm_uuid); + sdp_list_append(rfcomm_list, channel); + sdp_list_append(proto_list, rfcomm_list); + + access_proto_list = sdp_list_append(0, proto_list); + sdp_set_access_protos(record, access_proto_list); + + sdp_set_info_attr(record, service_name, service_prov, service_dsc); + + if (!(session = sdp_connect(BDADDR_ANY, BDADDR_LOCAL, SDP_RETRY_IF_BUSY))) + ast_log(LOG_WARNING, "Failed to connect sdp and create session.\n"); + else + err = sdp_record_register(session, record, 0); + + sdp_data_free(channel); + sdp_list_free(rfcomm_list, 0); + sdp_list_free(root_list, 0); + sdp_list_free(access_proto_list, 0); + sdp_list_free(svc_uuid_list, 0); + + return session; + +} + +/* + + Thread routines + +*/ + +/*! + * \brief Handle the BRSF response. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_brsf(struct mbl_pvt *pvt, char *buf) +{ + struct msg_queue_entry *entry; + if ((entry = msg_queue_head(pvt)) && entry->expected == AT_BRSF) { + if (hfp_parse_brsf(pvt->hfp, buf)) { + ast_debug(1, "[%s] error parsing BRSF\n", pvt->id); + goto e_return; + } + + if (msg_queue_push(pvt, AT_OK, AT_BRSF)) { + ast_debug(1, "[%s] error handling BRSF\n", pvt->id); + goto e_return; + } + + msg_queue_free_and_pop(pvt); + } else if (entry) { + ast_debug(1, "[%s] recieved unexpected AT message 'BRSF' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected)); + } else { + ast_debug(1, "[%s] recieved unexpected AT message 'BRSF'\n", pvt->id); + } + + return 0; + +e_return: + msg_queue_free_and_pop(pvt); + return -1; +} + +/*! + * \brief Handle the CIND response. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_cind(struct mbl_pvt *pvt, char *buf) +{ + struct msg_queue_entry *entry; + if ((entry = msg_queue_head(pvt)) && entry->expected == AT_CIND) { + switch (entry->response_to) { + case AT_CIND_TEST: + if (hfp_parse_cind_test(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND_TEST)) { + ast_debug(1, "[%s] error performing CIND test\n", pvt->id); + goto e_return; + } + break; + case AT_CIND: + if (hfp_parse_cind(pvt->hfp, buf) || msg_queue_push(pvt, AT_OK, AT_CIND)) { + ast_debug(1, "[%s] error getting CIND state\n", pvt->id); + goto e_return; + } + break; + default: + ast_debug(1, "[%s] error getting CIND state\n", pvt->id); + goto e_return; + } + msg_queue_free_and_pop(pvt); + } else if (entry) { + ast_debug(1, "[%s] recieved unexpected AT message 'CIND' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected)); + } else { + ast_debug(1, "[%s] recieved unexpected AT message 'CIND'\n", pvt->id); + } + + return 0; + +e_return: + msg_queue_free_and_pop(pvt); + return -1; +} + +/*! + * \brief Handle OK AT messages. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_ok(struct mbl_pvt *pvt, char *buf) +{ + struct msg_queue_entry *entry; + if ((entry = msg_queue_head(pvt)) && entry->expected == AT_OK) { + switch (entry->response_to) { + + /* initilization stuff */ + case AT_BRSF: + ast_debug(1, "[%s] BSRF sent successfully\n", pvt->id); + + /* If this is a blackberry do CMER now, otherwise + * continue with CIND as normal. */ + if (pvt->blackberry) { + if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) { + ast_debug(1, "[%s] error sending CMER\n", pvt->id); + goto e_return; + } + } else { + if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) { + ast_debug(1, "[%s] error sending CIND test\n", pvt->id); + goto e_return; + } + } + break; + case AT_CIND_TEST: + ast_debug(1, "[%s] CIND test sent successfully\n", pvt->id); + + ast_debug(2, "[%s] call: %d\n", pvt->id, pvt->hfp->cind_map.call); + ast_debug(2, "[%s] callsetup: %d\n", pvt->id, pvt->hfp->cind_map.callsetup); + + if (hfp_send_cind(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND)) { + ast_debug(1, "[%s] error requesting CIND state\n", pvt->id); + goto e_return; + } + break; + case AT_CIND: + ast_debug(1, "[%s] CIND sent successfully\n", pvt->id); + + /* check if a call is active */ + if (pvt->hfp->cind_state[pvt->hfp->cind_map.call]) { + ast_verb(3, "Bluetooth Device %s has a call in progress - delaying connection.\n", pvt->id); + goto e_return; + } + + /* If this is NOT a blackberry proceed with CMER, + * otherwise send CLIP. */ + if (!pvt->blackberry) { + if (hfp_send_cmer(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMER)) { + ast_debug(1, "[%s] error sending CMER\n", pvt->id); + goto e_return; + } + } else { + if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) { + ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id); + goto e_return; + } + } + break; + case AT_CMER: + ast_debug(1, "[%s] CMER sent successfully\n", pvt->id); + + /* If this is a blackberry proceed with the CIND test, + * otherwise send CLIP. */ + if (pvt->blackberry) { + if (hfp_send_cind_test(pvt->hfp) || msg_queue_push(pvt, AT_CIND, AT_CIND_TEST)) { + ast_debug(1, "[%s] error sending CIND test\n", pvt->id); + goto e_return; + } + } else { + if (hfp_send_clip(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CLIP)) { + ast_debug(1, "[%s] error enabling calling line notification\n", pvt->id); + goto e_return; + } + } + break; + case AT_CLIP: + ast_debug(1, "[%s] caling line indication enabled\n", pvt->id); + if (hfp_send_vgs(pvt->hfp, 15) || msg_queue_push(pvt, AT_OK, AT_VGS)) { + ast_debug(1, "[%s] error synchronizing gain settings\n", pvt->id); + goto e_return; + } + + pvt->timeout = -1; + pvt->hfp->initialized = 1; + ast_verb(3, "Bluetooth Device %s initialized and ready.\n", pvt->id); + + break; + case AT_VGS: + ast_debug(1, "[%s] volume level synchronization successful\n", pvt->id); + + /* set the SMS operating mode to text mode */ + if (hfp_send_cmgf(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMGF)) { + ast_debug(1, "[%s] error setting CMGF\n", pvt->id); + goto e_return; + } + break; + case AT_CMGF: + ast_debug(1, "[%s] sms text mode enabled\n", pvt->id); + /* turn on SMS new message indication */ + if (hfp_send_cnmi(pvt->hfp) || msg_queue_push(pvt, AT_OK, AT_CNMI)) { + ast_debug(1, "[%s] error setting CNMI\n", pvt->id); + goto e_return; + } + break; + case AT_CNMI: + ast_debug(1, "[%s] sms new message indication enabled\n", pvt->id); + pvt->has_sms = 1; + break; + /* end initilization stuff */ + + case AT_A: + ast_debug(1, "[%s] answer sent successfully\n", pvt->id); + pvt->needchup = 1; + break; + case AT_D: + ast_debug(1, "[%s] dial sent successfully\n", pvt->id); + pvt->needchup = 1; + pvt->outgoing = 1; + mbl_queue_control(pvt, AST_CONTROL_PROGRESS); + break; + case AT_CHUP: + ast_debug(1, "[%s] successful hangup\n", pvt->id); + break; + case AT_CMGR: + ast_debug(1, "[%s] successfully read sms message\n", pvt->id); + pvt->incoming_sms = 0; + break; + case AT_CMGS: + ast_debug(1, "[%s] successfully sent sms message\n", pvt->id); + pvt->outgoing_sms = 0; + break; + case AT_VTS: + ast_debug(1, "[%s] digit sent successfully\n", pvt->id); + break; + case AT_UNKNOWN: + default: + ast_debug(1, "[%s] recieved OK for unhandled request: %s\n", pvt->id, at_msg2str(entry->response_to)); + break; + } + msg_queue_free_and_pop(pvt); + } else if (entry) { + ast_debug(1, "[%s] recieved AT message 'OK' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected)); + } else { + ast_debug(1, "[%s] recieved unexpected AT message 'OK'\n", pvt->id); + } + return 0; + +e_return: + msg_queue_free_and_pop(pvt); + return -1; +} + +/*! + * \brief Handle ERROR AT messages. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_error(struct mbl_pvt *pvt, char *buf) +{ + struct msg_queue_entry *entry; + if ((entry = msg_queue_head(pvt)) + && (entry->expected == AT_OK + || entry->expected == AT_ERROR + || entry->expected == AT_CMS_ERROR + || entry->expected == AT_CMGR + || entry->expected == AT_SMS_PROMPT)) { + switch (entry->response_to) { + + /* initilization stuff */ + case AT_BRSF: + ast_debug(1, "[%s] error reading BSRF\n", pvt->id); + goto e_return; + case AT_CIND_TEST: + ast_debug(1, "[%s] error during CIND test\n", pvt->id); + goto e_return; + case AT_CIND: + ast_debug(1, "[%s] error requesting CIND state\n", pvt->id); + goto e_return; + case AT_CMER: + ast_debug(1, "[%s] error during CMER request\n", pvt->id); + goto e_return; + case AT_CLIP: + ast_debug(1, "[%s] error enabling calling line indication\n", pvt->id); + goto e_return; + case AT_VGS: + ast_debug(1, "[%s] volume level synchronization failed\n", pvt->id); + + /* this is not a fatal error, let's continue with initilization */ + + /* set the SMS operating mode to text mode */ + if (hfp_send_cmgf(pvt->hfp, 1) || msg_queue_push(pvt, AT_OK, AT_CMGF)) { + ast_debug(1, "[%s] error setting CMGF\n", pvt->id); + goto e_return; + } + break; + case AT_CMGF: + ast_debug(1, "[%s] error setting CMGF\n", pvt->id); + ast_debug(1, "[%s] no SMS support\n", pvt->id); + break; + case AT_CNMI: + ast_debug(1, "[%s] error setting CNMI\n", pvt->id); + ast_debug(1, "[%s] no SMS support\n", pvt->id); + break; + /* end initilization stuff */ + + case AT_A: + ast_debug(1, "[%s] answer failed\n", pvt->id); + mbl_queue_hangup(pvt); + break; + case AT_D: + ast_debug(1, "[%s] dial failed\n", pvt->id); + pvt->needchup = 0; + mbl_queue_control(pvt, AST_CONTROL_CONGESTION); + break; + case AT_CHUP: + ast_debug(1, "[%s] error sending hangup, disconnecting\n", pvt->id); + goto e_return; + case AT_CMGR: + ast_debug(1, "[%s] error reading sms message\n", pvt->id); + pvt->incoming_sms = 0; + break; + case AT_CMGS: + ast_debug(1, "[%s] error sending sms message\n", pvt->id); + pvt->outgoing_sms = 0; + break; + case AT_VTS: + ast_debug(1, "[%s] error sending digit\n", pvt->id); + break; + case AT_UNKNOWN: + default: + ast_debug(1, "[%s] recieved ERROR for unhandled request: %s\n", pvt->id, at_msg2str(entry->response_to)); + break; + } + msg_queue_free_and_pop(pvt); + } else if (entry) { + ast_debug(1, "[%s] recieved AT message 'ERROR' when expecting %s, ignoring\n", pvt->id, at_msg2str(entry->expected)); + } else { + ast_debug(1, "[%s] recieved unexpected AT message 'ERROR'\n", pvt->id); + } + + return 0; + +e_return: + msg_queue_free_and_pop(pvt); + return -1; +} + +/*! + * \brief Handle AT+CIEV messages. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_ciev(struct mbl_pvt *pvt, char *buf) +{ + int i; + switch (hfp_parse_ciev(pvt->hfp, buf, &i)) { + case HFP_CIND_CALL: + switch (i) { + case HFP_CIND_CALL_NONE: + ast_debug(1, "[%s] line disconnected\n", pvt->id); + if (pvt->owner) { + ast_debug(1, "[%s] hanging up owner\n", pvt->id); + if (mbl_queue_hangup(pvt)) { + ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnectiong...\n", pvt->id); + return -1; + } + } + pvt->needchup = 0; + pvt->needcallerid = 0; + pvt->incoming = 0; + pvt->outgoing = 0; + break; + case HFP_CIND_CALL_ACTIVE: + if (pvt->outgoing) { + ast_debug(1, "[%s] remote end answered\n", pvt->id); + mbl_queue_control(pvt, AST_CONTROL_ANSWER); + } else if (pvt->incoming && pvt->answered) { + ast_setstate(pvt->owner, AST_STATE_UP); + } else if (pvt->incoming) { + /* user answered from handset, disconnecting */ + ast_verb(3, "[%s] user answered bluetooth device from handset, disconnecting\n", pvt->id); + mbl_queue_hangup(pvt); + return -1; + } + break; + } + break; + + case HFP_CIND_CALLSETUP: + switch (i) { + case HFP_CIND_CALLSETUP_NONE: + if (pvt->hfp->cind_state[pvt->hfp->cind_map.call] != HFP_CIND_CALL_ACTIVE) { + if (pvt->owner) { + if (mbl_queue_hangup(pvt)) { + ast_log(LOG_ERROR, "[%s] error queueing hangup, disconnectiong...\n", pvt->id); + return -1; + } + } + pvt->needchup = 0; + pvt->needcallerid = 0; + pvt->incoming = 0; + pvt->outgoing = 0; + } + break; + case HFP_CIND_CALLSETUP_INCOMING: + ast_debug(1, "[%s] incoming call, waiting for caller id\n", pvt->id); + pvt->needcallerid = 1; + pvt->incoming = 1; + break; + case HFP_CIND_CALLSETUP_OUTGOING: + if (pvt->outgoing) { + ast_debug(1, "[%s] outgoing call\n", pvt->id); + } else { + ast_verb(3, "[%s] user dialed from handset, disconnecting\n", pvt->id); + return -1; + } + break; + case HFP_CIND_CALLSETUP_ALERTING: + if (pvt->outgoing) { + ast_debug(1, "[%s] remote alerting\n", pvt->id); + mbl_queue_control(pvt, AST_CONTROL_RINGING); + } + break; + } + break; + case HFP_CIND_NONE: + ast_debug(1, "[%s] error parsing CIND: %s\n", pvt->id, buf); + break; + } + return 0; +} + +/*! + * \brief Handle AT+CLIP messages. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_clip(struct mbl_pvt *pvt, char *buf) +{ + char *clip; + struct msg_queue_entry *msg; + struct ast_channel *chan; + + if ((msg = msg_queue_head(pvt)) && msg->expected == AT_CLIP) { + msg_queue_free_and_pop(pvt); + + pvt->needcallerid = 0; + if (!(clip = hfp_parse_clip(pvt->hfp, buf))) { + ast_debug(1, "[%s] error parsing CLIP: %s\n", pvt->id, buf); + } + + if (!(chan = mbl_new(AST_STATE_RING, pvt, clip, NULL))) { + ast_log(LOG_ERROR, "[%s] unable to allocate channel for incoming call\n", pvt->id); + hfp_send_chup(pvt->hfp); + msg_queue_push(pvt, AT_OK, AT_CHUP); + return -1; + } + + /* from this point on, we need to send a chup in the event of a + * hangup */ + pvt->needchup = 1; + + if (ast_pbx_start(chan)) { + ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming call\n", pvt->id); + mbl_ast_hangup(pvt); + return -1; + } + } + + return 0; +} + +/*! + * \brief Handle RING messages. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_ring(struct mbl_pvt *pvt, char *buf) +{ + if (pvt->needcallerid) { + ast_debug(1, "[%s] got ring while waiting for caller id\n", pvt->id); + return msg_queue_push(pvt, AT_CLIP, AT_UNKNOWN); + } else { + return 0; + } +} + +/*! + * \brief Handle AT+CMTI messages. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_cmti(struct mbl_pvt *pvt, char *buf) +{ + int index = hfp_parse_cmti(pvt->hfp, buf); + if (index > 0) { + ast_debug(1, "[%s] incoming sms message\n", pvt->id); + + if (hfp_send_cmgr(pvt->hfp, index) + || msg_queue_push(pvt, AT_CMGR, AT_CMGR)) { + ast_debug(1, "[%s] error sending CMGR to retrieve SMS message\n", pvt->id); + return -1; + } + + pvt->incoming_sms = 1; + return 0; + } else { + ast_debug(1, "[%s] error parsing incoming sms message alert, disconnecting\n", pvt->id); + return -1; + } +} + +/*! + * \brief Handle AT+CMGR messages. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_response_cmgr(struct mbl_pvt *pvt, char *buf) +{ + char *from_number = NULL, *text = NULL; + struct ast_channel *chan; + struct msg_queue_entry *msg; + + if ((msg = msg_queue_head(pvt)) && msg->expected == AT_CMGR) { + msg_queue_free_and_pop(pvt); + + if (hfp_parse_cmgr(pvt->hfp, buf, &from_number, &text) + || msg_queue_push(pvt, AT_OK, AT_CMGR)) { + + ast_debug(1, "[%s] error parsing sms message, disconnecting\n", pvt->id); + return -1; + } + + /* XXX this channel probably does not need to be associated with this pvt */ + if (!(chan = mbl_new(AST_STATE_DOWN, pvt, NULL, NULL))) { + ast_debug(1, "[%s] error creating sms message channel, disconnecting\n", pvt->id); + return -1; + } + + strcpy(chan->exten, "sms"); + pbx_builtin_setvar_helper(chan, "SMSSRC", from_number); + pbx_builtin_setvar_helper(chan, "SMSTXT", text); + + if (ast_pbx_start(chan)) { + ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming sms\n", pvt->id); + mbl_ast_hangup(pvt); + } + } else { + ast_debug(1, "[%s] got unexpected +CMGR message, ignoring\n", pvt->id); + } + + return 0; +} + +/*! + * \brief Send an SMS message from the queue. + * \param pvt a mbl_pvt structure + * \param buf a null terminated buffer containing an AT message + * \retval 0 success + * \retval -1 error + */ +static int handle_sms_prompt(struct mbl_pvt *pvt, char *buf) +{ + struct msg_queue_entry *msg; + if (!(msg = msg_queue_head(pvt))) { + ast_debug(1, "[%s] error, got sms prompt with no pending sms messages\n", pvt->id); + return 0; + } + + if (msg->expected != AT_SMS_PROMPT) { + ast_debug(1, "[%s] error, got sms prompt but no pending sms messages\n", pvt->id); + return 0; + } + + if (hfp_send_sms_text(pvt->hfp, msg->data) + || msg_queue_push(pvt, AT_OK, AT_CMGS)) { + msg_queue_free_and_pop(pvt); + ast_debug(1, "[%s] error sending sms message\n", pvt->id); + return 0; + } + + msg_queue_free_and_pop(pvt); + return 0; +} + + +static void *do_monitor_phone(void *data) +{ + struct mbl_pvt *pvt = (struct mbl_pvt *)data; + struct hfp_pvt *hfp = pvt->hfp; + char buf[256]; + int t; + at_message_t at_msg; + struct msg_queue_entry *entry; + + /* Note: At one point the initilization procedure was neatly contained + * in the hfp_init() function, but that initilization method did not + * work with non standard devices. As a result, the initilization + * procedure is not spread throughout the event handling loop. + */ + + /* start initilization with the BRSF request */ + ast_mutex_lock(&pvt->lock); + pvt->timeout = 10000; + if (hfp_send_brsf(hfp, &hfp_our_brsf) || msg_queue_push(pvt, AT_BRSF, AT_BRSF)) { + ast_debug(1, "[%s] error sending BRSF\n", hfp->owner->id); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + + while (!check_unloading()) { + ast_mutex_lock(&pvt->lock); + t = pvt->timeout; + ast_mutex_unlock(&pvt->lock); + + if (!rfcomm_wait(pvt->rfcomm_socket, &t)) { + ast_debug(1, "[%s] timeout waiting for rfcomm data, disconnecting\n", pvt->id); + ast_mutex_lock(&pvt->lock); + if (!hfp->initialized) { + if ((entry = msg_queue_head(pvt))) { + switch (entry->response_to) { + case AT_CIND_TEST: + if (pvt->blackberry) + ast_debug(1, "[%s] timeout during CIND test\n", hfp->owner->id); + else + ast_debug(1, "[%s] timeout during CIND test, try setting 'blackberry=yes'\n", hfp->owner->id); + break; + case AT_CMER: + if (pvt->blackberry) + ast_debug(1, "[%s] timeout after sending CMER, try setting 'blackberry=no'\n", hfp->owner->id); + else + ast_debug(1, "[%s] timeout after sending CMER\n", hfp->owner->id); + break; + default: + ast_debug(1, "[%s] timeout while waiting for %s in response to %s\n", pvt->id, at_msg2str(entry->expected), at_msg2str(entry->response_to)); + break; + } + } + } + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + + if ((at_msg = at_read_full(hfp->rsock, buf, sizeof(buf))) < 0) { + /* XXX gnu specific strerror_r is assummed here, this + * is not really safe. See the strerror(3) man page + * for more info. */ + ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, strerror_r(errno, buf, sizeof(buf)), errno); + break; + } + + ast_debug(1, "[%s] %s\n", pvt->id, buf); + + switch (at_msg) { + case AT_BRSF: + ast_mutex_lock(&pvt->lock); + if (handle_response_brsf(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_CIND: + ast_mutex_lock(&pvt->lock); + if (handle_response_cind(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_OK: + ast_mutex_lock(&pvt->lock); + if (handle_response_ok(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_CMS_ERROR: + case AT_ERROR: + ast_mutex_lock(&pvt->lock); + if (handle_response_error(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_RING: + ast_mutex_lock(&pvt->lock); + if (handle_response_ring(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_CIEV: + ast_mutex_lock(&pvt->lock); + if (handle_response_ciev(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_CLIP: + ast_mutex_lock(&pvt->lock); + if (handle_response_clip(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_CMTI: + ast_mutex_lock(&pvt->lock); + if (handle_response_cmti(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_CMGR: + ast_mutex_lock(&pvt->lock); + if (handle_response_cmgr(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_SMS_PROMPT: + ast_mutex_lock(&pvt->lock); + if (handle_sms_prompt(pvt, buf)) { + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + ast_mutex_unlock(&pvt->lock); + break; + case AT_UNKNOWN: + ast_debug(1, "[%s] ignoring unknown message: %s\n", pvt->id, buf); + break; + case AT_PARSE_ERROR: + ast_debug(1, "[%s] error parsing message\n", pvt->id); + goto e_cleanup; + case AT_READ_ERROR: + ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, strerror_r(errno, buf, sizeof(buf)), errno); + goto e_cleanup; + default: + break; + } + } + +e_cleanup: + + if (!hfp->initialized) + ast_verb(3, "Error initializing Bluetooth device %s.\n", pvt->id); + + ast_mutex_lock(&pvt->lock); + if (pvt->owner) { + ast_debug(1, "[%s] device disconnected, hanging up owner\n", pvt->id); + pvt->needchup = 0; + mbl_queue_hangup(pvt); + } + + close(pvt->rfcomm_socket); + close(pvt->sco_socket); + pvt->sco_socket = -1; + + msg_queue_flush(pvt); + + pvt->connected = 0; + hfp->initialized = 0; + + pvt->adapter->inuse = 0; + ast_mutex_unlock(&pvt->lock); + + ast_verb(3, "Bluetooth Device %s has disconnected.\n", pvt->id); + manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Disconnect\r\nDevice: %s\r\n", pvt->id); + + return NULL; +} + +static int headset_send_ring(const void *data) +{ + struct mbl_pvt *pvt = (struct mbl_pvt *) data; + ast_mutex_lock(&pvt->lock); + if (!pvt->needring) { + ast_mutex_unlock(&pvt->lock); + return 0; + } + ast_mutex_unlock(&pvt->lock); + + if (hsp_send_ring(pvt->rfcomm_socket)) { + ast_debug(1, "[%s] error sending RING\n", pvt->id); + return 0; + } + return 1; +} + +static void *do_monitor_headset(void *data) +{ + + struct mbl_pvt *pvt = (struct mbl_pvt *)data; + char buf[256]; + int t; + at_message_t at_msg; + struct ast_channel *chan = NULL; + + ast_verb(3, "Bluetooth Device %s initialised and ready.\n", pvt->id); + + while (!check_unloading()) { + + t = ast_sched_wait(pvt->sched); + if (t == -1) { + t = 6000; + } + + ast_sched_runq(pvt->sched); + + if (rfcomm_wait(pvt->rfcomm_socket, &t) == 0) + continue; + + if ((at_msg = at_read_full(pvt->rfcomm_socket, buf, sizeof(buf))) < 0) { + if (strerror_r(errno, buf, sizeof(buf))) + ast_debug(1, "[%s] error reading from device\n", pvt->id); + else + ast_debug(1, "[%s] error reading from device: %s (%d)\n", pvt->id, buf, errno); + + goto e_cleanup; + } + ast_debug(1, "[%s] %s\n", pvt->id, buf); + + switch (at_msg) { + case AT_VGS: + case AT_VGM: + /* XXX volume change requested, we will just + * pretend to do something with it */ + if (hsp_send_ok(pvt->rfcomm_socket)) { + ast_debug(1, "[%s] error sending AT message 'OK'\n", pvt->id); + goto e_cleanup; + } + break; + case AT_CKPD: + ast_mutex_lock(&pvt->lock); + if (pvt->outgoing) { + pvt->needring = 0; + hsp_send_ok(pvt->rfcomm_socket); + if (pvt->answered) { + /* we have an answered call up to the + * HS, he wants to hangup */ + mbl_queue_hangup(pvt); + } else { + /* we have an outgoing call to the HS, + * he wants to answer */ + if ((pvt->sco_socket = sco_connect(pvt->adapter->addr, pvt->addr)) == -1) { + ast_log(LOG_ERROR, "[%s] unable to create audio connection\n", pvt->id); + mbl_queue_hangup(pvt); + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + + ast_channel_set_fd(pvt->owner, 0, pvt->sco_socket); + + mbl_queue_control(pvt, AST_CONTROL_ANSWER); + pvt->answered = 1; + + if (hsp_send_vgs(pvt->rfcomm_socket, 13) || hsp_send_vgm(pvt->rfcomm_socket, 13)) { + ast_debug(1, "[%s] error sending VGS/VGM\n", pvt->id); + mbl_queue_hangup(pvt); + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + } + } else if (pvt->incoming) { + /* we have an incoming call from the + * HS, he wants to hang up */ + mbl_queue_hangup(pvt); + } else { + /* no call is up, HS wants to dial */ + hsp_send_ok(pvt->rfcomm_socket); + + if ((pvt->sco_socket = sco_connect(pvt->adapter->addr, pvt->addr)) == -1) { + ast_log(LOG_ERROR, "[%s] unable to create audio connection\n", pvt->id); + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + + pvt->incoming = 1; + + if (!(chan = mbl_new(AST_STATE_UP, pvt, NULL, NULL))) { + ast_log(LOG_ERROR, "[%s] unable to allocate channel for incoming call\n", pvt->id); + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + + ast_channel_set_fd(chan, 0, pvt->sco_socket); + + ast_copy_string(chan->exten, "s", AST_MAX_EXTENSION); + if (ast_pbx_start(chan)) { + ast_log(LOG_ERROR, "[%s] unable to start pbx on incoming call\n", pvt->id); + ast_hangup(chan); + ast_mutex_unlock(&pvt->lock); + goto e_cleanup; + } + } + ast_mutex_unlock(&pvt->lock); + break; + default: + ast_debug(1, "[%s] received unknown AT command: %s (%s)\n", pvt->id, buf, at_msg2str(at_msg)); + if (hsp_send_error(pvt->rfcomm_socket)) { + ast_debug(1, "[%s] error sending AT message 'ERROR'\n", pvt->id); + goto e_cleanup; + } + break; + } + } + +e_cleanup: + ast_mutex_lock(&pvt->lock); + if (pvt->owner) { + ast_debug(1, "[%s] device disconnected, hanging up owner\n", pvt->id); + mbl_queue_hangup(pvt); + } + + + close(pvt->rfcomm_socket); + close(pvt->sco_socket); + pvt->sco_socket = -1; + + pvt->connected = 0; + + pvt->needring = 0; + pvt->outgoing = 0; + pvt->incoming = 0; + + pvt->adapter->inuse = 0; + ast_mutex_unlock(&pvt->lock); + + manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Disconnect\r\nDevice: %s\r\n", pvt->id); + ast_verb(3, "Bluetooth Device %s has disconnected\n", pvt->id); + + return NULL; + +} + +static int start_monitor(struct mbl_pvt *pvt) +{ + + if (pvt->type == MBL_TYPE_PHONE) { + pvt->hfp->rsock = pvt->rfcomm_socket; + + if (ast_pthread_create_background(&pvt->monitor_thread, NULL, do_monitor_phone, pvt) < 0) { + pvt->monitor_thread = AST_PTHREADT_NULL; + return 0; + } + } else { + if (ast_pthread_create_background(&pvt->monitor_thread, NULL, do_monitor_headset, pvt) < 0) { + pvt->monitor_thread = AST_PTHREADT_NULL; + return 0; + } + } + + return 1; + +} + +static void *do_discovery(void *data) +{ + + struct adapter_pvt *adapter; + struct mbl_pvt *pvt; + + while (!check_unloading()) { + AST_RWLIST_RDLOCK(&adapters); + AST_RWLIST_TRAVERSE(&adapters, adapter, entry) { + if (!adapter->inuse) { + AST_RWLIST_RDLOCK(&devices); + AST_RWLIST_TRAVERSE(&devices, pvt, entry) { + ast_mutex_lock(&pvt->lock); + if (!adapter->inuse && !pvt->connected && !strcmp(adapter->id, pvt->adapter->id)) { + if ((pvt->rfcomm_socket = rfcomm_connect(adapter->addr, pvt->addr, pvt->rfcomm_port)) > -1) { + if (start_monitor(pvt)) { + pvt->connected = 1; + adapter->inuse = 1; + manager_event(EVENT_FLAG_SYSTEM, "MobileStatus", "Status: Connect\r\nDevice: %s\r\n", pvt->id); + ast_verb(3, "Bluetooth Device %s has connected, initilizing...\n", pvt->id); + } + } + } + ast_mutex_unlock(&pvt->lock); + } + AST_RWLIST_UNLOCK(&devices); + } + } + AST_RWLIST_UNLOCK(&adapters); + + + /* Go to sleep (only if we are not unloading) */ + if (!check_unloading()) + sleep(discovery_interval); + } + + return NULL; +} + +/*! + * \brief Service new and existing SCO connections. + * This thread accepts new sco connections and handles audio data. There is + * one do_sco_listen thread for each adapter. + */ +static void *do_sco_listen(void *data) +{ + struct adapter_pvt *adapter = (struct adapter_pvt *) data; + int res; + + while (!check_unloading()) { + /* check for new sco connections */ + if ((res = ast_io_wait(adapter->accept_io, 0)) == -1) { + /* handle errors */ + ast_log(LOG_ERROR, "ast_io_wait() failed for adapter %s\n", adapter->id); + break; + } + + /* handle audio data */ + if ((res = ast_io_wait(adapter->io, 1)) == -1) { + ast_log(LOG_ERROR, "ast_io_wait() failed for audio on adapter %s\n", adapter->id); + break; + } + } + + return NULL; +} + +/* + + Module + +*/ + +/*! + * \brief Load an adapter from the configuration file. + * \param cfg the config to load the adapter from + * \param cat the adapter to load + * + * This function loads the given adapter and starts the sco listener thread for + * that adapter. + * + * \return NULL on error, a pointer to the adapter that was loaded on success + */ +static struct adapter_pvt *mbl_load_adapter(struct ast_config *cfg, const char *cat) +{ + const char *id, *address; + struct adapter_pvt *adapter; + struct ast_variable *v; + struct hci_dev_req dr; + uint16_t vs; + + id = ast_variable_retrieve(cfg, cat, "id"); + address = ast_variable_retrieve(cfg, cat, "address"); + + if (ast_strlen_zero(id) || ast_strlen_zero(address)) { + ast_log(LOG_ERROR, "Skipping adapter. Missing id or address settings.\n"); + goto e_return; + } + + ast_debug(1, "Reading configuration for adapter %s %s.\n", id, address); + + if (!(adapter = ast_calloc(1, sizeof(*adapter)))) { + ast_log(LOG_ERROR, "Skipping adapter %s. Error allocating memory.\n", id); + goto e_return; + } + + ast_copy_string(adapter->id, id, sizeof(adapter->id)); + str2ba(address, &adapter->addr); + + /* attempt to connect to the adapter */ + adapter->dev_id = hci_devid(address); + adapter->hci_socket = hci_open_dev(adapter->dev_id); + if (adapter->dev_id < 0 || adapter->hci_socket < 0) { + ast_log(LOG_ERROR, "Skipping adapter %s. Unable to communicate with adapter.\n", adapter->id); + goto e_free_adapter; + } + + /* check voice setting */ + hci_read_voice_setting(adapter->hci_socket, &vs, 1000); + vs = htobs(vs); + if (vs != 0x0060) { + ast_log(LOG_ERROR, "Skipping adapter %s. Voice setting must be 0x0060 - see 'man hciconfig' for details.\n", adapter->id); + goto e_hci_close_dev; + } + + for (v = ast_variable_browse(cfg, cat); v; v = v->next) { + if (!strcasecmp(v->name, "forcemaster")) { + if (ast_true(v->value)) { + dr.dev_id = adapter->dev_id; + if (hci_strtolm("master", &dr.dev_opt)) { + if (ioctl(adapter->hci_socket, HCISETLINKMODE, (unsigned long) &dr) < 0) { + ast_log(LOG_WARNING, "Unable to set adapter %s link mode to MASTER. Ignoring 'forcemaster' option.\n", adapter->id); + } + } + } + } else if (!strcasecmp(v->name, "alignmentdetection")) { + adapter->alignment_detection = ast_true(v->value); + } + } + + /* create io contexts */ + if (!(adapter->accept_io = io_context_create())) { + ast_log(LOG_ERROR, "Unable to create I/O context for audio connection listener\n"); + goto e_hci_close_dev; + } + + if (!(adapter->io = io_context_create())) { + ast_log(LOG_ERROR, "Unable to create I/O context for audio connections\n"); + goto e_destroy_accept_io; + } + + /* bind the sco listener socket */ + if (sco_bind(adapter) < 0) { + ast_log(LOG_ERROR, "Skipping adapter %s. Error binding audio connection listerner socket.\n", adapter->id); + goto e_destroy_io; + } + + /* add the socket to the io context */ + if (!(adapter->sco_id = ast_io_add(adapter->accept_io, adapter->sco_socket, sco_accept, AST_IO_IN, adapter))) { + ast_log(LOG_ERROR, "Skipping adapter %s. Error adding listener socket to I/O context.\n", adapter->id); + goto e_close_sco; + } + + /* start the sco listener for this adapter */ + if (ast_pthread_create_background(&adapter->sco_listener_thread, NULL, do_sco_listen, adapter)) { + ast_log(LOG_ERROR, "Skipping adapter %s. Error creating audio connection listerner thread.\n", adapter->id); + goto e_remove_sco; + } + + /* add the adapter to our global list */ + AST_RWLIST_WRLOCK(&adapters); + AST_RWLIST_INSERT_HEAD(&adapters, adapter, entry); + AST_RWLIST_UNLOCK(&adapters); + ast_debug(1, "Loaded adapter %s %s.\n", adapter->id, address); + + return adapter; + +e_remove_sco: + ast_io_remove(adapter->accept_io, adapter->sco_id); +e_close_sco: + close(adapter->sco_socket); +e_destroy_io: + io_context_destroy(adapter->io); +e_destroy_accept_io: + io_context_destroy(adapter->accept_io); +e_hci_close_dev: + hci_close_dev(adapter->hci_socket); +e_free_adapter: + ast_free(adapter); +e_return: + return NULL; +} + +/*! + * \brief Load a device from the configuration file. + * \param cfg the config to load the device from + * \param cat the device to load + * \return NULL on error, a pointer to the device that was loaded on success + */ +static struct mbl_pvt *mbl_load_device(struct ast_config *cfg, const char *cat) +{ + struct mbl_pvt *pvt; + struct adapter_pvt *adapter; + struct ast_variable *v; + const char *address, *adapter_str, *port; + ast_debug(1, "Reading configuration for device %s.\n", cat); + + adapter_str = ast_variable_retrieve(cfg, cat, "adapter"); + if(ast_strlen_zero(adapter_str)) { + ast_log(LOG_ERROR, "Skipping device %s. No adapter specified.\n", cat); + goto e_return; + } + + /* find the adapter */ + AST_RWLIST_RDLOCK(&adapters); + AST_RWLIST_TRAVERSE(&adapters, adapter, entry) { + if (!strcmp(adapter->id, adapter_str)) + break; + } + AST_RWLIST_UNLOCK(&adapters); + if (!adapter) { + ast_log(LOG_ERROR, "Skiping device %s. Unknown adapter '%s' specified.\n", cat, adapter_str); + goto e_return; + } + + address = ast_variable_retrieve(cfg, cat, "address"); + port = ast_variable_retrieve(cfg, cat, "port"); + if (ast_strlen_zero(port) || ast_strlen_zero(address)) { + ast_log(LOG_ERROR, "Skipping device %s. Missing required port or address setting.\n", cat); + goto e_return; + } + + /* create and initialize our pvt structure */ + if (!(pvt = ast_calloc(1, sizeof(*pvt)))) { + ast_log(LOG_ERROR, "Skipping device %s. Error allocating memory.\n", cat); + goto e_return; + } + + ast_mutex_init(&pvt->lock); + AST_LIST_HEAD_INIT_NOLOCK(&pvt->msg_queue); + + /* set some defaults */ + + pvt->type = MBL_TYPE_PHONE; + ast_copy_string(pvt->context, "default", sizeof(pvt->context)); + + /* populate the pvt structure */ + pvt->adapter = adapter; + ast_copy_string(pvt->id, cat, sizeof(pvt->id)); + str2ba(address, &pvt->addr); + pvt->timeout = -1; + pvt->rfcomm_socket = -1; + pvt->rfcomm_port = atoi(port); + pvt->sco_socket = -1; + pvt->monitor_thread = AST_PTHREADT_NULL; + pvt->ring_sched_id = -1; + + /* setup the smoother */ + if (!(pvt->smoother = ast_smoother_new(DEVICE_FRAME_SIZE))) { + ast_log(LOG_ERROR, "Skipping device %s. Error setting up frame smoother.\n", cat); + goto e_free_pvt; + } + + /* setup the dsp */ + if (!(pvt->dsp = ast_dsp_new())) { + ast_log(LOG_ERROR, "Skipping device %s. Error setting up dsp for dtmf detection.\n", cat); + goto e_free_smoother; + } + + /* setup the scheduler */ + if (!(pvt->sched = sched_context_create())) { + ast_log(LOG_ERROR, "Unable to create scheduler context for headset device\n"); + goto e_free_dsp; + } + + ast_dsp_set_features(pvt->dsp, DSP_FEATURE_DIGIT_DETECT); + ast_dsp_set_digitmode(pvt->dsp, DSP_DIGITMODE_DTMF | DSP_DIGITMODE_RELAXDTMF); + + for (v = ast_variable_browse(cfg, cat); v; v = v->next) { + if (!strcasecmp(v->name, "type")) { + if (!strcasecmp(v->value, "headset")) + pvt->type = MBL_TYPE_HEADSET; + else + pvt->type = MBL_TYPE_PHONE; + } else if (!strcasecmp(v->name, "context")) { + ast_copy_string(pvt->context, v->value, sizeof(pvt->context)); + } else if (!strcasecmp(v->name, "group")) { + /* group is set to 0 if invalid */ + pvt->group = atoi(v->value); + } else if (!strcasecmp(v->name, "nocallsetup")) { + pvt->no_callsetup = ast_true(v->value); + + if (pvt->no_callsetup) + ast_debug(1, "Setting nocallsetup mode for device %s.\n", pvt->id); + } else if (!strcasecmp(v->name, "blackberry")) { + pvt->blackberry = ast_true(v->value); + } + } + + if (pvt->type == MBL_TYPE_PHONE) { + if (!(pvt->hfp = ast_calloc(1, sizeof(*pvt->hfp)))) { + ast_log(LOG_ERROR, "Skipping device %s. Error allocating memory.\n", pvt->id); + goto e_free_sched; + } + + pvt->hfp->owner = pvt; + pvt->hfp->rport = pvt->rfcomm_port; + pvt->hfp->nocallsetup = pvt->no_callsetup; + } + + AST_RWLIST_WRLOCK(&devices); + AST_RWLIST_INSERT_HEAD(&devices, pvt, entry); + AST_RWLIST_UNLOCK(&devices); + ast_debug(1, "Loaded device %s.\n", pvt->id); + + return pvt; + +e_free_sched: + sched_context_destroy(pvt->sched); +e_free_dsp: + ast_dsp_free(pvt->dsp); +e_free_smoother: + ast_smoother_free(pvt->smoother); +e_free_pvt: + ast_free(pvt); +e_return: + return NULL; +} + +static int mbl_load_config(void) +{ + struct ast_config *cfg; + const char *cat; + struct ast_variable *v; + struct ast_flags config_flags = { 0 }; + + cfg = ast_config_load(MBL_CONFIG, config_flags); + if (!cfg) + return -1; + + /* parse [general] section */ + for (v = ast_variable_browse(cfg, "general"); v; v = v->next) { + if (!strcasecmp(v->name, "interval")) { + if (!sscanf(v->value, "%d", &discovery_interval)) { + ast_log(LOG_NOTICE, "error parsing 'interval' in general section, using default value\n"); + } + } + } + + /* load adapters */ + for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) { + if (!strcasecmp(cat, "adapter")) { + mbl_load_adapter(cfg, cat); + } + } + + if (AST_RWLIST_EMPTY(&adapters)) { + ast_log(LOG_ERROR, + "***********************************************************************\n" + "No adapters could be loaded from the configuration file.\n" + "Please review mobile.conf. See sample for details.\n" + "***********************************************************************\n" + ); + ast_config_destroy(cfg); + return -1; + } + + /* now load devices */ + for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) { + if (strcasecmp(cat, "general") && strcasecmp(cat, "adapter")) { + mbl_load_device(cfg, cat); + } + } + + ast_config_destroy(cfg); + + return 0; +} + +/*! + * \brief Check if the module is unloading. + * \retval 0 not unloading + * \retval 1 unloading + */ +static inline int check_unloading() +{ + int res; + ast_mutex_lock(&unload_mutex); + res = unloading_flag; + ast_mutex_unlock(&unload_mutex); + + return res; +} + +/*! + * \brief Set the unloading flag. + */ +static inline void set_unloading() +{ + ast_mutex_lock(&unload_mutex); + unloading_flag = 1; + ast_mutex_unlock(&unload_mutex); +} + +static int unload_module(void) +{ + struct mbl_pvt *pvt; + struct adapter_pvt *adapter; + + /* First, take us out of the channel loop */ + ast_channel_unregister(&mbl_tech); + + /* Unregister the CLI & APP */ + ast_cli_unregister_multiple(mbl_cli, sizeof(mbl_cli) / sizeof(mbl_cli[0])); + ast_unregister_application(app_mblstatus); + ast_unregister_application(app_mblsendsms); + + /* signal everyone we are unloading */ + set_unloading(); + + /* Kill the discovery thread */ + if (discovery_thread != AST_PTHREADT_NULL) { + pthread_kill(discovery_thread, SIGURG); + pthread_join(discovery_thread, NULL); + } + + /* stop the sco listener threads */ + AST_RWLIST_WRLOCK(&adapters); + AST_RWLIST_TRAVERSE(&adapters, adapter, entry) { + pthread_kill(adapter->sco_listener_thread, SIGURG); + pthread_join(adapter->sco_listener_thread, NULL); + } + AST_RWLIST_UNLOCK(&adapters); + + /* Destroy the device list */ + AST_RWLIST_WRLOCK(&devices); + while ((pvt = AST_RWLIST_REMOVE_HEAD(&devices, entry))) { + if (pvt->monitor_thread != AST_PTHREADT_NULL) { + pthread_kill(pvt->monitor_thread, SIGURG); + pthread_join(pvt->monitor_thread, NULL); + } + + close(pvt->sco_socket); + close(pvt->rfcomm_socket); + + msg_queue_flush(pvt); + + if (pvt->hfp) { + ast_free(pvt->hfp); + } + + ast_smoother_free(pvt->smoother); + ast_dsp_free(pvt->dsp); + sched_context_destroy(pvt->sched); + ast_free(pvt); + } + AST_RWLIST_UNLOCK(&devices); + + /* Destroy the adapter list */ + AST_RWLIST_WRLOCK(&adapters); + while ((adapter = AST_RWLIST_REMOVE_HEAD(&adapters, entry))) { + close(adapter->sco_socket); + io_context_destroy(adapter->io); + io_context_destroy(adapter->accept_io); + hci_close_dev(adapter->hci_socket); + ast_free(adapter); + } + AST_RWLIST_UNLOCK(&adapters); + + if (sdp_session) + sdp_close(sdp_session); + + return 0; +} + +static int load_module(void) +{ + + int dev_id, s; + + /* Check if we have Bluetooth, no point loading otherwise... */ + dev_id = hci_get_route(NULL); + s = hci_open_dev(dev_id); + if (dev_id < 0 || s < 0) { + ast_log(LOG_ERROR, "No Bluetooth devices found. Not loading module.\n"); + return AST_MODULE_LOAD_DECLINE; + } + + hci_close_dev(s); + + if (mbl_load_config()) { + ast_log(LOG_ERROR, "Errors reading config file %s. Not loading module.\n", MBL_CONFIG); + return AST_MODULE_LOAD_DECLINE; + } + + sdp_session = sdp_register(); + + /* Spin the discovery thread */ + if (ast_pthread_create_background(&discovery_thread, NULL, do_discovery, NULL) < 0) { + ast_log(LOG_ERROR, "Unable to create discovery thread.\n"); + goto e_cleanup; + } + + /* register our channel type */ + if (ast_channel_register(&mbl_tech)) { + ast_log(LOG_ERROR, "Unable to register channel class %s\n", "Mobile"); + goto e_cleanup; + } + + ast_cli_register_multiple(mbl_cli, sizeof(mbl_cli) / sizeof(mbl_cli[0])); + ast_register_application(app_mblstatus, mbl_status_exec, mblstatus_synopsis, mblstatus_desc); + ast_register_application(app_mblsendsms, mbl_sendsms_exec, mblsendsms_synopsis, mblsendsms_desc); + + return AST_MODULE_LOAD_SUCCESS; + +e_cleanup: + if (sdp_session) + sdp_close(sdp_session); + + return AST_MODULE_LOAD_FAILURE; +} + +AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "Bluetooth Mobile Device Channel Driver", + .load = load_module, + .unload = unload_module, +); diff --git a/addons/chan_ooh323.c b/addons/chan_ooh323.c new file mode 100644 index 000000000..70c0f0209 --- /dev/null +++ b/addons/chan_ooh323.c @@ -0,0 +1,3162 @@ +/* + * 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 "chan_ooh323.h" + +/*** MODULEINFO + no + ***/ + +/* Defaults */ +#define DEFAULT_CONTEXT "default" +#define DEFAULT_H323ID "Asterisk PBX" +#define DEFAULT_LOGFILE "/var/log/asterisk/h323_log" +#define DEFAULT_H323ACCNT "ast_h323" + +/* Flags */ +#define H323_SILENCESUPPRESSION (1<<0) +#define H323_GKROUTED (1<<1) +#define H323_TUNNELING (1<<2) +#define H323_FASTSTART (1<<3) +#define H323_OUTGOING (1<<4) +#define H323_ALREADYGONE (1<<5) +#define H323_NEEDDESTROY (1<<6) +#define H323_DISABLEGK (1<<7) + +/* Channel description */ +static const char type[] = "OOH323"; +static const char tdesc[] = "Objective Systems H323 Channel Driver"; +static const char config[] = "ooh323.conf"; + + +/* Channel Definition */ +static struct ast_channel *ooh323_request(const char *type, int format, + void *data, int *cause); +static int ooh323_digit_begin(struct ast_channel *ast, char digit); +static int ooh323_digit_end(struct ast_channel *ast, char digit, unsigned int duration); +static int ooh323_call(struct ast_channel *ast, char *dest, int timeout); +static int ooh323_hangup(struct ast_channel *ast); +static int ooh323_answer(struct ast_channel *ast); +static struct ast_frame *ooh323_read(struct ast_channel *ast); +static int ooh323_write(struct ast_channel *ast, struct ast_frame *f); +static int ooh323_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen); +static int ooh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan); + +static enum ast_rtp_get_result ooh323_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp); +static enum ast_rtp_get_result ooh323_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp); +static int ooh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, + struct ast_rtp *vrtp, struct ast_rtp *trtp, int codecs, int nat_active); + +static void print_codec_to_cli(int fd, struct ast_codec_pref *pref); + +#if 0 +static void ast_ooh323c_exit(); +#endif + +static const struct ast_channel_tech ooh323_tech = { + .type = type, + .description = tdesc, + .capabilities = -1, + .requester = ooh323_request, + .send_digit_begin = ooh323_digit_begin, + .send_digit_end = ooh323_digit_end, + .call = ooh323_call, + .hangup = ooh323_hangup, + .answer = ooh323_answer, + .read = ooh323_read, + .write = ooh323_write, + .exception = ooh323_read, + .indicate = ooh323_indicate, + .fixup = ooh323_fixup, + .send_html = 0, + .bridge = ast_rtp_bridge, +}; + +static struct ast_rtp_protocol ooh323_rtp = { + .type = type, + .get_rtp_info = ooh323_get_rtp_peer, + .get_vrtp_info = ooh323_get_vrtp_peer, + .set_rtp_peer = ooh323_set_rtp_peer +}; + +/* H.323 channel private structure */ +static struct ooh323_pvt { + ast_mutex_t lock; /* Channel private lock */ + struct ast_rtp *rtp; + struct ast_rtp *vrtp; /* Placeholder for now */ + struct ast_channel *owner; /* Master Channel */ + time_t lastrtptx; + time_t lastrtprx; + unsigned int flags; + unsigned int call_reference; + char *callToken; + char *username; + char *host; + char *callerid_name; + char *callerid_num; + char caller_h323id[AST_MAX_EXTENSION]; + char caller_dialedDigits[AST_MAX_EXTENSION]; + char caller_email[AST_MAX_EXTENSION]; + char caller_url[256]; + char callee_h323id[AST_MAX_EXTENSION]; + char callee_dialedDigits[AST_MAX_EXTENSION]; + char callee_email[AST_MAX_EXTENSION]; + char callee_url[AST_MAX_EXTENSION]; + + int port; + int readformat; /* negotiated read format */ + int writeformat; /* negotiated write format */ + int capability; + struct ast_codec_pref prefs; + int dtmfmode; + char exten[AST_MAX_EXTENSION]; /* Requested extension */ + char context[AST_MAX_EXTENSION]; /* Context where to start */ + char accountcode[256]; /* Account code */ + int nat; + int amaflags; + struct ast_dsp *vad; + struct ooh323_pvt *next; /* Next entity */ +} *iflist = NULL; + +/* Protect the channel/interface list (ooh323_pvt) */ +AST_MUTEX_DEFINE_STATIC(iflock); + +/* Profile of H.323 user registered with PBX*/ +struct ooh323_user{ + ast_mutex_t lock; + char name[256]; + char context[AST_MAX_EXTENSION]; + int incominglimit; + unsigned inUse; + char accountcode[20]; + int amaflags; + int capability; + struct ast_codec_pref prefs; + int dtmfmode; + int rtptimeout; + int mUseIP; /* Use IP address or H323-ID to search user */ + char mIP[20]; + struct ooh323_user *next; +}; + +/* Profile of valid asterisk peers */ +struct ooh323_peer{ + ast_mutex_t lock; + char name[256]; + unsigned outgoinglimit; + unsigned outUse; + int capability; + struct ast_codec_pref prefs; + char accountcode[20]; + int amaflags; + int dtmfmode; + int mFriend; /* indicates defined as friend */ + char ip[20]; + int port; + char *h323id; /* H323-ID alias, which asterisk will register with gk to reach this peer*/ + char *email; /* Email alias, which asterisk will register with gk to reach this peer*/ + char *url; /* url alias, which asterisk will register with gk to reach this peer*/ + char *e164; /* e164 alias, which asterisk will register with gk to reach this peer*/ + int rtptimeout; + struct ooh323_peer *next; +}; + + +/* List of H.323 users known to PBX */ +static struct ast_user_list { + struct ooh323_user *users; + ast_mutex_t lock; +} userl; + +static struct ast_peer_list { + struct ooh323_peer *peers; + ast_mutex_t lock; +} peerl; + +/* Mutex to protect H.323 reload process */ +static int h323_reloading = 0; +AST_MUTEX_DEFINE_STATIC(h323_reload_lock); + +/* Mutex to protect usage counter */ +static int usecnt = 0; +AST_MUTEX_DEFINE_STATIC(usecnt_lock); + +AST_MUTEX_DEFINE_STATIC(ooh323c_cmd_lock); + +/* stack callbacks */ +int onAlerting(ooCallData *call); +int onNewCallCreated(ooCallData *call); +int onCallEstablished(ooCallData *call); +int onCallCleared(ooCallData *call); + +static char gLogFile[256] = DEFAULT_LOGFILE; +static int gPort = 1720; +static char gIP[20]; +static char gCallerID[AST_MAX_EXTENSION] = DEFAULT_H323ID; +static struct ooAliases *gAliasList; +static int gCapability = AST_FORMAT_ULAW; +static struct ast_codec_pref gPrefs; +static int gDTMFMode = H323_DTMF_RFC2833; +static char gGatekeeper[100]; +static enum RasGatekeeperMode gRasGkMode = RasNoGatekeeper; + +static int gIsGateway = 0; +static int gFastStart = 1; +static int gTunneling = 1; +static int gMediaWaitForConnect = 0; +static int gTOS = 0; +static int gRTPTimeout = 60; +static char gAccountcode[80] = DEFAULT_H323ACCNT; +static int gAMAFLAGS; +static char gContext[AST_MAX_EXTENSION] = DEFAULT_CONTEXT; +static int gIncomingLimit = 4; +static int gOutgoingLimit = 4; +OOBOOL gH323Debug = FALSE; + +static struct ooh323_config +{ + int mTCPPortStart; + int mTCPPortEnd; +} ooconfig; + +/** Asterisk RTP stuff*/ +static struct sched_context *sched; +static struct io_context *io; + +/* Protect the monitoring thread, so only one process can kill or start it, + and not when it's doing something critical. */ +AST_MUTEX_DEFINE_STATIC(monlock); + + +/* This is the thread for the monitor which checks for input on the channels + which are not currently in use. */ +static pthread_t monitor_thread = AST_PTHREADT_NULL; + + +static struct ast_channel *ooh323_new(struct ooh323_pvt *i, int state, + const char *host) +{ + struct ast_channel *ch = NULL; + int fmt; + if (gH323Debug) + ast_verbose("--- ooh323_new - %s\n", host); + + + /* Don't hold a h323 pvt lock while we allocate a channel */ + ast_mutex_unlock(&i->lock); + ch = ast_channel_alloc(1, state, i->callerid_num, i->callerid_name, i->accountcode, i->exten, i->context, i->amaflags, "OOH323/%s-%08x", host, (unsigned int)(unsigned long) i); + ast_mutex_lock(&i->lock); + + if (ch) { + ast_channel_lock(ch); + ch->tech = &ooh323_tech; + + ch->nativeformats = i->capability; + + fmt = ast_best_codec(ch->nativeformats); + + ch->fds[0] = ast_rtp_fd(i->rtp); + ch->fds[1] = ast_rtcp_fd(i->rtp); + + if (state == AST_STATE_RING) + ch->rings = 1; + + ch->adsicpe = AST_ADSI_UNAVAILABLE; + ch->writeformat = fmt; + ch->rawwriteformat = fmt; + ch->readformat = fmt; + ch->rawreadformat = fmt; + ch->tech_pvt = i; + i->owner = ch; + + /* Allocate dsp for in-band DTMF support */ + if (i->dtmfmode & H323_DTMF_INBAND) { + i->vad = ast_dsp_new(); + ast_dsp_set_features(i->vad, DSP_FEATURE_DIGIT_DETECT); + } + + ast_mutex_lock(&usecnt_lock); + usecnt++; + ast_mutex_unlock(&usecnt_lock); + + /* Notify the module monitors that use count for resource has changed*/ + ast_update_use_count(); + + ast_copy_string(ch->context, i->context, sizeof(ch->context)); + ast_copy_string(ch->exten, i->exten, sizeof(ch->exten)); + + ch->priority = 1; + if (i->callerid_name) { + ch->cid.cid_name = strdup(i->callerid_name); + } + if (i->callerid_num) { + + ch->cid.cid_num = strdup(i->callerid_num); + } + + if (!ast_test_flag(i, H323_OUTGOING)) { + + if (!ast_strlen_zero(i->caller_h323id)) { + pbx_builtin_setvar_helper(ch, "_CALLER_H323ID", i->caller_h323id); + + } + if (!ast_strlen_zero(i->caller_dialedDigits)) { + pbx_builtin_setvar_helper(ch, "_CALLER_H323DIALEDDIGITS", + i->caller_dialedDigits); + } + if (!ast_strlen_zero(i->caller_email)) { + pbx_builtin_setvar_helper(ch, "_CALLER_H323EMAIL", + i->caller_email); + } + if (!ast_strlen_zero(i->caller_url)) { + pbx_builtin_setvar_helper(ch, "_CALLER_H323URL", i->caller_url); + } + } + + if (!ast_strlen_zero(i->accountcode)) + ast_string_field_set(ch, accountcode, i->accountcode); + + if (i->amaflags) + ch->amaflags = i->amaflags; + + ast_setstate(ch, state); + if (state != AST_STATE_DOWN) { + if (ast_pbx_start(ch)) { + ast_log(LOG_WARNING, "Unable to start PBX on %s\n", ch->name); + ast_channel_unlock(ch); + ast_hangup(ch); + ch = NULL; + } + } + } else + ast_log(LOG_WARNING, "Unable to allocate channel structure\n"); + + + if (ch) + ast_channel_unlock(ch); + + if (gH323Debug) + ast_verbose("+++ h323_new\n"); + + return ch; +} + + + +static struct ooh323_pvt *ooh323_alloc(int callref, char *callToken) +{ + struct ooh323_pvt *pvt = NULL; + struct in_addr ipAddr; + if (gH323Debug) + ast_verbose("--- ooh323_alloc\n"); + + if (!(pvt = ast_calloc(1, sizeof(*pvt)))) { + ast_log(LOG_ERROR, "Couldn't allocate private ooh323 structure\n"); + return NULL; + } + + ast_mutex_init(&pvt->lock); + ast_mutex_lock(&pvt->lock); + + if (!inet_aton(gIP, &ipAddr)) { + ast_log(LOG_ERROR, "Invalid OOH323 driver ip address\n"); + ast_mutex_unlock(&pvt->lock); + ast_mutex_destroy(&pvt->lock); + free(pvt); + return NULL; + } + + if (!(pvt->rtp = ast_rtp_new_with_bindaddr(sched, io, 1, 0, ipAddr))) { + ast_log(LOG_WARNING, "Unable to create RTP session: %s\n", + strerror(errno)); + ast_mutex_unlock(&pvt->lock); + ast_mutex_destroy(&pvt->lock); + free(pvt); + return NULL; + } + + ast_rtp_setqos(pvt->rtp, gTOS, 0, "ooh323"); + + pvt->call_reference = callref; + if (callToken) + pvt->callToken = strdup(callToken); + + /* whether to use gk for this call */ + if (gRasGkMode == RasNoGatekeeper) + OO_SETFLAG(pvt->flags, H323_DISABLEGK); + + pvt->dtmfmode = gDTMFMode; + ast_copy_string(pvt->context, gContext, sizeof(pvt->context)); + ast_copy_string(pvt->accountcode, gAccountcode, sizeof(pvt->accountcode)); + pvt->amaflags = gAMAFLAGS; + pvt->capability = gCapability; + memcpy(&pvt->prefs, &gPrefs, sizeof(pvt->prefs)); + + ast_mutex_unlock(&pvt->lock); + /* Add to interface list */ + ast_mutex_lock(&iflock); + pvt->next = iflist; + iflist = pvt; + ast_mutex_unlock(&iflock); + + if (gH323Debug) + ast_verbose("+++ ooh323_alloc\n"); + + return pvt; +} + + +/* + Possible data values - peername, exten/peername, exten@ip + */ +static struct ast_channel *ooh323_request(const char *type, int format, + void *data, int *cause) +{ + struct ast_channel *chan = NULL; + struct ooh323_pvt *p = NULL; + struct ooh323_peer *peer = NULL; + char *dest = NULL; + char *ext = NULL; + char tmp[256]; + char formats[512]; + int oldformat; + int port = 0; + + if (gH323Debug) + ast_verbose("--- ooh323_request - data %s format %s\n", (char*)data, + ast_getformatname_multiple(formats,512,format)); + + oldformat = format; + format &= AST_FORMAT_AUDIO_MASK; + if (!format) { + ast_log(LOG_NOTICE, "Asked to get a channel of unsupported format " + "'%d'\n", format); + return NULL; + } + + p = ooh323_alloc(0,0); /* Initial callRef is zero */ + + if (!p) { + ast_log(LOG_WARNING, "Unable to build pvt data for '%s'\n", (char*)data); + return NULL; + } + ast_mutex_lock(&p->lock); + + /* This is an outgoing call, since ooh323_request is called */ + ast_set_flag(p, H323_OUTGOING); + + ast_copy_string(tmp, data, sizeof(data)); + + dest = strchr(tmp, '/'); + + if (dest) { + *dest = '\0'; + dest++; + ext = tmp; + } else if ((dest = strchr(tmp, '@'))) { + *dest = '\0'; + dest++; + ext = tmp; + } else { + dest = tmp; + ext = NULL; + } + +#if 0 + if ((sport = strchr(dest, ':'))) { + *sport = '\0'; + sport++; + port = atoi(sport); + } +#endif + + if (dest) { + peer = find_peer(dest, port); + } else{ + ast_log(LOG_ERROR, "Destination format is not supported\n"); + return NULL; + } + + if (peer) { + p->username = strdup(peer->name); + p->host = strdup(peer->ip); + p->port = peer->port; + /* Disable gk as we are going to call a known peer*/ + OO_SETFLAG(p->flags, H323_DISABLEGK); + + if (ext) + ast_copy_string(p->exten, ext, sizeof(p->exten)); + + if (peer->capability & format) { + p->capability = peer->capability & format; + } else { + p->capability = peer->capability; + } + memcpy(&p->prefs, &peer->prefs, sizeof(struct ast_codec_pref)); + p->dtmfmode = peer->dtmfmode; + ast_copy_string(p->accountcode, peer->accountcode, sizeof(p->accountcode)); + p->amaflags = peer->amaflags; + } else { + p->dtmfmode = gDTMFMode; + p->capability = gCapability; + + memcpy(&p->prefs, &gPrefs, sizeof(struct ast_codec_pref)); + p->username = strdup(dest); + + p->host = strdup(dest); + if (port > 0) { + p->port = port; + } + if (ext) { + ast_copy_string(p->exten, ext, sizeof(p->exten)); + } + } + + + chan = ooh323_new(p, AST_STATE_DOWN, p->username); + + ast_mutex_unlock(&p->lock); + + if (!chan) { + ast_mutex_lock(&iflock); + ooh323_destroy(p); + ast_mutex_unlock(&iflock); + } + + restart_monitor(); + if (gH323Debug) + ast_verbose("+++ ooh323_request\n"); + + return chan; + +} + + +static struct ooh323_pvt* find_call(ooCallData *call) +{ + struct ooh323_pvt *p; + + if (gH323Debug) + ast_verbose("--- find_call\n"); + + ast_mutex_lock(&iflock); + + for (p = iflist; p; p = p->next) { + if (p->callToken && !strcmp(p->callToken, call->callToken)) { + break; + } + } + ast_mutex_unlock(&iflock); + + if (gH323Debug) + ast_verbose("+++ find_call\n"); + + return p; +} + +struct ooh323_user *find_user(const char * name, const char* ip) +{ + struct ooh323_user *user; + + if (gH323Debug) + ast_verbose("--- find_user\n"); + + ast_mutex_lock(&userl.lock); + for (user = userl.users; user; user = user->next) { + if (ip && user->mUseIP && !strcmp(user->mIP, ip)) { + break; + } + if (name && !strcmp(user->name, name)) { + break; + } + } + ast_mutex_unlock(&userl.lock); + + if (gH323Debug) + ast_verbose("+++ find_user\n"); + + return user; +} + +struct ooh323_peer *find_friend(const char *name, int port) +{ + struct ooh323_peer *peer; + + if (gH323Debug) + ast_verbose("--- find_friend \"%s\"\n", name); + + + ast_mutex_lock(&peerl.lock); + for (peer = peerl.peers; peer; peer = peer->next) { + if (gH323Debug) { + ast_verbose(" comparing with \"%s\"\n", peer->ip); + } + if (!strcmp(peer->ip, name)) { + if (port <= 0 || (port > 0 && peer->port == port)) { + break; + } + } + } + ast_mutex_unlock(&peerl.lock); + + if (gH323Debug) { + if (peer) { + ast_verbose(" found matching friend\n"); + } + ast_verbose("+++ find_friend \"%s\"\n", name); + } + + return peer; +} + + +struct ooh323_peer *find_peer(const char * name, int port) +{ + struct ooh323_peer *peer; + + if (gH323Debug) + ast_verbose("--- find_peer \"%s\"\n", name); + + ast_mutex_lock(&peerl.lock); + for (peer = peerl.peers; peer; peer = peer->next) { + if (gH323Debug) { + ast_verbose(" comparing with \"%s\"\n", peer->ip); + } + if (!strcasecmp(peer->name, name)) + break; + if (peer->h323id && !strcasecmp(peer->h323id, name)) + break; + if (peer->e164 && !strcasecmp(peer->e164, name)) + break; + /* + if (!strcmp(peer->ip, name)) { + if (port > 0 && peer->port == port) { break; } + else if (port <= 0) { break; } + } + */ + } + ast_mutex_unlock(&peerl.lock); + + if (gH323Debug) { + if (peer) { + ast_verbose(" found matching peer\n"); + } + ast_verbose("+++ find_peer \"%s\"\n", name); + } + + return peer; +} + +static int ooh323_digit_begin(struct ast_channel *chan, char digit) +{ + char dtmf[2]; + struct ooh323_pvt *p = (struct ooh323_pvt *) chan->tech_pvt; + + if (gH323Debug) + ast_verbose("--- ooh323_digit_begin\n"); + + if (!p) { + ast_log(LOG_ERROR, "No private structure for call\n"); + return -1; + } + ast_mutex_lock(&p->lock); + if (p->rtp && (p->dtmfmode & H323_DTMF_RFC2833)) { + ast_rtp_senddigit_begin(p->rtp, digit); + } else if (((p->dtmfmode & H323_DTMF_Q931) || + (p->dtmfmode & H323_DTMF_H245ALPHANUMERIC) || + (p->dtmfmode & H323_DTMF_H245SIGNAL))) { + dtmf[0] = digit; + dtmf[1] = '\0'; + ast_mutex_lock(&ooh323c_cmd_lock); + ooSendDTMFDigit(p->callToken, dtmf); + ast_mutex_unlock(&ooh323c_cmd_lock); + } + ast_mutex_unlock(&p->lock); + if (gH323Debug) + ast_verbose("+++ ooh323_digit_begin\n"); + + return 0; +} + +static int ooh323_digit_end(struct ast_channel *chan, char digit, unsigned int duration) +{ + struct ooh323_pvt *p = (struct ooh323_pvt *) chan->tech_pvt; + + if (gH323Debug) + ast_verbose("--- ooh323_digit_end\n"); + + if (!p) { + ast_log(LOG_ERROR, "No private structure for call\n"); + return -1; + } + ast_mutex_lock(&p->lock); + if (p->rtp && (p->dtmfmode & H323_DTMF_RFC2833)) + ast_rtp_senddigit_end(p->rtp, digit); + + ast_mutex_unlock(&p->lock); + if (gH323Debug) + ast_verbose("+++ ooh323_digit_end\n"); + + return 0; +} + + +static int ooh323_call(struct ast_channel *ast, char *dest, int timeout) +{ + struct ooh323_pvt *p = ast->tech_pvt; + char destination[256]; + int res = 0; + const char *val = NULL; + ooCallOptions opts = { + .fastStart = TRUE, + .tunneling = TRUE, + .disableGk = TRUE, + .callMode = OO_CALLMODE_AUDIOCALL + }; + if (gH323Debug) + ast_verbose("--- ooh323_call- %s\n", dest); + + if ((ast->_state != AST_STATE_DOWN) && (ast->_state != AST_STATE_RESERVED)) { + ast_log(LOG_WARNING, "ooh323_call called on %s, neither down nor " + "reserved\n", ast->name); + return -1; + } + ast_mutex_lock(&p->lock); + ast_set_flag(p, H323_OUTGOING); + if (ast->cid.cid_num) { + if (p->callerid_num) { + free(p->callerid_num); + } + p->callerid_num = strdup(ast->cid.cid_num); + } + + if (ast->cid.cid_name) { + if (p->callerid_name) { + free(p->callerid_name); + } + p->callerid_name = strdup(ast->cid.cid_name); + } + else{ + ast->cid.cid_name = strdup(gCallerID); + if (p->callerid_name) { + free(p->callerid_name); + } + p->callerid_name = strdup(ast->cid.cid_name); + } + + /* Retrieve vars */ + + + if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323ID"))) { + ast_copy_string(p->caller_h323id, val, sizeof(p->caller_h323id)); + } + + if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323DIALEDDIGITS"))) { + ast_copy_string(p->caller_dialedDigits, val, sizeof(p->caller_dialedDigits)); + if (!p->callerid_num) { + p->callerid_num = strdup(val); + } + } + + if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323EMAIL"))) { + ast_copy_string(p->caller_email, val, sizeof(p->caller_email)); + } + + if ((val = pbx_builtin_getvar_helper(ast, "CALLER_H323URL"))) { + ast_copy_string(p->caller_url, val, sizeof(p->caller_url)); + } + + + if (!(p->callToken = (char*)malloc(AST_MAX_EXTENSION))) { + ast_mutex_unlock(&p->lock); + ast_log(LOG_ERROR, "Failed to allocate memory for callToken\n"); + return -1; /* TODO: need to clean/hangup?? */ + } + + if (p->host && p->port != 0) + snprintf(destination, sizeof(destination), "%s:%d", p->host, p->port); + else if (p->host) + snprintf(destination, sizeof(destination), "%s", p->host); + else + ast_copy_string(destination, dest, sizeof(destination)); + + ast_mutex_lock(&ooh323c_cmd_lock); + if (OO_TESTFLAG(p->flags, H323_DISABLEGK)) + res = ooMakeCall(destination, p->callToken, AST_MAX_EXTENSION, &opts); + else + res = ooMakeCall(destination, p->callToken, AST_MAX_EXTENSION, NULL); + ast_mutex_unlock(&ooh323c_cmd_lock); + + ast_mutex_unlock(&p->lock); + if (res != OO_OK) { + ast_log(LOG_ERROR, "Failed to make call\n"); + return -1; /* TODO: cleanup */ + } + if (gH323Debug) + ast_verbose("+++ ooh323_call\n"); + + return 0; +} + +static int ooh323_hangup(struct ast_channel *ast) +{ + struct ooh323_pvt *p = ast->tech_pvt; + + if (gH323Debug) + ast_verbose("--- ooh323_hangup\n"); + + if (p) { + ast_mutex_lock(&p->lock); + + if (gH323Debug) + ast_verbose(" hanging %s\n", p->username); + ast->tech_pvt = NULL; + if (!ast_test_flag(p, H323_ALREADYGONE)) { + ast_mutex_lock(&ooh323c_cmd_lock); + ooHangCall(p->callToken, + ooh323_convert_hangupcause_asteriskToH323(p->owner->hangupcause)); + ast_mutex_unlock(&ooh323c_cmd_lock); + ast_set_flag(p, H323_ALREADYGONE); + /* ast_mutex_unlock(&p->lock); */ + } else { + ast_set_flag(p, H323_NEEDDESTROY); + } + /* detach channel here */ + if (p->owner) { + p->owner->tech_pvt = NULL; + p->owner = NULL; + } + + ast_mutex_unlock(&p->lock); + ast_mutex_lock(&usecnt_lock); + usecnt--; + ast_mutex_unlock(&usecnt_lock); + + /* Notify the module monitors that use count for resource has changed */ + ast_update_use_count(); + + } else { + ast_log(LOG_ERROR, "No call to hangup\n" ); + return -1; + } + + if (gH323Debug) + ast_verbose("+++ ooh323_hangup\n"); + + return 0; +} + +static int ooh323_answer(struct ast_channel *ast) +{ + struct ooh323_pvt *p = ast->tech_pvt; + + if (gH323Debug) + ast_verbose("--- ooh323_answer\n"); + + ast_mutex_lock(&p->lock); + if (ast->_state != AST_STATE_UP) { + ast_channel_lock(ast); + ast_setstate(ast, AST_STATE_UP); + ast_debug(1, "ooh323_answer(%s)\n", ast->name); + ast_channel_unlock(ast); + ast_mutex_lock(&ooh323c_cmd_lock); + ooAnswerCall(p->callToken); + ast_mutex_unlock(&ooh323c_cmd_lock); + } + ast_mutex_unlock(&p->lock); + + if (gH323Debug) + ast_verbose("+++ ooh323_answer\n"); + + return 0; +} + +static struct ast_frame *ooh323_read(struct ast_channel *ast) +{ + struct ast_frame *fr; + static struct ast_frame null_frame = { AST_FRAME_NULL, }; + struct ooh323_pvt *p = ast->tech_pvt; + + ast_mutex_lock(&p->lock); + if (p->rtp) + fr = ooh323_rtp_read(ast, p); + else + fr = &null_frame; + /* time(&p->lastrtprx); */ + ast_mutex_unlock(&p->lock); + return fr; +} + +static int ooh323_write(struct ast_channel *ast, struct ast_frame *f) +{ + struct ooh323_pvt *p = ast->tech_pvt; + int res = 0; + + if (f->frametype == AST_FRAME_VOICE) { + if (!(f->subclass & ast->nativeformats)) { + ast_log(LOG_WARNING, "Asked to transmit frame type %d, while native " + "formats is %d (read/write = %d/%d)\n", + f->subclass, ast->nativeformats, ast->readformat, + ast->writeformat); + return 0; + } + if (p) { + ast_mutex_lock(&p->lock); + if (p->rtp) + res = ast_rtp_write(p->rtp, f); + ast_mutex_unlock(&p->lock); + } + } else if (f->frametype == AST_FRAME_IMAGE) { + return 0; + } else { + ast_log(LOG_WARNING, "Can't send %d type frames with SIP write\n", + f->frametype); + return 0; + } + + return res; +} + +static int ooh323_indicate(struct ast_channel *ast, int condition, const void *data, size_t datalen) +{ + + struct ooh323_pvt *p = (struct ooh323_pvt *) ast->tech_pvt; + char *callToken = (char *)NULL; + + ast_mutex_lock(&p->lock); + callToken = (p->callToken ? strdup(p->callToken) : NULL); + ast_mutex_unlock(&p->lock); + + if (!callToken) { + if (gH323Debug) + ast_verbose(" ooh323_indicate - No callToken\n"); + return -1; + } + + if (gH323Debug) + ast_verbose("----- ooh323_indicate %d on call %s\n", condition, callToken); + + + switch (condition) { + case AST_CONTROL_CONGESTION: + if (!ast_test_flag(p, H323_ALREADYGONE)) { + ast_mutex_lock(&ooh323c_cmd_lock); + ooHangCall(callToken, OO_REASON_LOCAL_CONGESTED); + ast_mutex_unlock(&ooh323c_cmd_lock); + ast_set_flag(p, H323_ALREADYGONE); + } + break; + case AST_CONTROL_BUSY: + if (!ast_test_flag(p, H323_ALREADYGONE)) { + ast_mutex_lock(&ooh323c_cmd_lock); + ooHangCall(callToken, OO_REASON_LOCAL_BUSY); + ast_mutex_unlock(&ooh323c_cmd_lock); + ast_set_flag(p, H323_ALREADYGONE); + } + break; + case AST_CONTROL_HOLD: + ast_moh_start(ast, data, NULL); + break; + case AST_CONTROL_UNHOLD: + ast_moh_stop(ast); + break; + case AST_CONTROL_PROCEEDING: + case AST_CONTROL_RINGING: + case AST_CONTROL_PROGRESS: + case -1: + break; + default: + ast_log(LOG_WARNING, "Don't know how to indicate condition %d on %s\n", + condition, callToken); + } + + if (gH323Debug) + ast_verbose("++++ ooh323_indicate %d on %s\n", condition, callToken); + + + return -1; +} + +static int ooh323_fixup(struct ast_channel *oldchan, struct ast_channel *newchan) +{ + struct ooh323_pvt *p = newchan->tech_pvt; + + if (gH323Debug) + ast_verbose("--- ooh323c ooh323_fixup\n"); + + ast_mutex_lock(&p->lock); + if (p->owner != oldchan) { + ast_log(LOG_WARNING, "Old channel wasn't %p but was %p\n", oldchan, p->owner); + ast_mutex_unlock(&p->lock); + return -1; + } + + if (p->owner == oldchan) { + p->owner = newchan; + } else { + p->owner = oldchan; + } + + ast_mutex_unlock(&p->lock); + + if (gH323Debug) + ast_verbose("+++ ooh323c ooh323_fixup \n"); + + return 0; +} + + +void ooh323_set_write_format(ooCallData *call, int fmt) +{ +#if 0 + struct ooh323_pvt *p = NULL; + char formats[512]; +#ifdef print_debug + printf("--- ooh323_update_writeformat %s\n", + ast_getformatname_multiple(formats,512, fmt)); +#endif + + p = find_call(call); + if (!p) { + ast_log(LOG_ERROR, "No matching call found for %s\n", call->callToken); + return; + } + + ast_mutex_lock(&p->lock); + + p->writeformat = fmt; + ast_mutex_unlock(&p->lock); + + if (p->owner) { + printf("Writeformat before update %s\n", + ast_getformatname_multiple(formats,512, p->owner->writeformat)); + ast_set_write_format(p->owner, fmt); + } + else + ast_log(LOG_ERROR, "No owner found\n"); + + +#ifdef print_debug + printf("+++ ooh323_update_writeformat\n"); +#endif +#endif +} + + +void ooh323_set_read_format(ooCallData *call, int fmt) +{ +#if 0 + struct ooh323_pvt *p = NULL; + char formats[512]; +#ifdef print_debug + printf("--- ooh323_update_readformat %s\n", + ast_getformatname_multiple(formats,512, fmt)); +#endif + + p = find_call(call); + if (!p) { + ast_log(LOG_ERROR, "No matching call found for %s\n", call->callToken); + return; + } + + ast_mutex_lock(&p->lock); + p->readformat = fmt; + ast_mutex_unlock(&p->lock); + ast_set_read_format(p->owner, fmt); + +#ifdef print_debug + printf("+++ ooh323_update_readformat\n"); +#endif +#endif +} + +int onAlerting(ooCallData *call) +{ + struct ooh323_pvt *p = NULL; + struct ast_channel *c = NULL; + + if (gH323Debug) + ast_verbose("--- onAlerting %s\n", call->callToken); + + if (!(p = find_call(call))) { + ast_log(LOG_ERROR, "No matching call found\n"); + return -1; + } + ast_mutex_lock(&p->lock); + if (!ast_test_flag(p, H323_OUTGOING)) { + if (!(c = ooh323_new(p, AST_STATE_RING, p->username))) { + ast_mutex_unlock(&p->lock); + ast_log(LOG_ERROR, "Could not create ast_channel\n"); + return -1; + } + ast_mutex_unlock(&p->lock); + } else { + if (!p->owner) { + ast_mutex_unlock(&p->lock); + ast_log(LOG_ERROR, "Channel has no owner\n"); + return 0; + } + c = p->owner; + ast_mutex_unlock(&p->lock); + ast_channel_lock(c); + ast_setstate(c, AST_STATE_RINGING); + ast_channel_unlock(c); + ast_queue_control(c, AST_CONTROL_RINGING); + } + + if (gH323Debug) + ast_verbose("+++ onAlerting %s\n", call->callToken); + + return OO_OK; +} + +/** + * Callback for sending digits from H.323 up to asterisk + * + */ +int ooh323_onReceivedDigit(OOH323CallData *call, const char *digit) +{ + struct ooh323_pvt *p = NULL; + struct ast_frame f; + int res; + + ast_debug(1, "Received Digit: %c\n", digit[0]); + p = find_call(call); + if (!p) { + ast_log(LOG_ERROR, "Failed to find a matching call.\n"); + return -1; + } + if (!p->owner) { + ast_log(LOG_ERROR, "Channel has no owner\n"); + return -1; + } + ast_mutex_lock(&p->lock); + memset(&f, 0, sizeof(f)); + f.frametype = AST_FRAME_DTMF; + f.subclass = digit[0]; + f.datalen = 0; + f.samples = 800; + f.offset = 0; + f.data.ptr = NULL; + f.mallocd = 0; + f.src = "SEND_DIGIT"; + ast_mutex_unlock(&p->lock); + res = ast_queue_frame(p->owner, &f); + return res; +} + +int ooh323_onReceivedSetup(ooCallData *call, Q931Message *pmsg) +{ + struct ooh323_pvt *p = NULL; + struct ooh323_user *user = NULL; + ooAliases *alias = NULL; + char *at = NULL; + char number [OO_MAX_NUMBER_LENGTH]; + + if (gH323Debug) + ast_verbose("--- ooh323_onReceivedSetup %s\n", call->callToken); + + + if (!(p = ooh323_alloc(call->callReference, call->callToken))) { + ast_log(LOG_ERROR, "Failed to create a new call.\n"); + return -1; + } + ast_mutex_lock(&p->lock); + ast_clear_flag(p, H323_OUTGOING); + + + if (call->remoteDisplayName) { + p->callerid_name = strdup(call->remoteDisplayName); + } + + if (ooCallGetCallingPartyNumber(call, number, OO_MAX_NUMBER_LENGTH) == OO_OK) { + p->callerid_num = strdup(number); + } + + if (call->remoteAliases) { + for (alias = call->remoteAliases; alias; alias = alias->next) { + if (alias->type == T_H225AliasAddress_h323_ID) { + if (!p->callerid_name) { + p->callerid_name = strdup(alias->value); + } + ast_copy_string(p->caller_h323id, alias->value, sizeof(p->caller_h323id)); + } else if (alias->type == T_H225AliasAddress_dialedDigits) { + if (!p->callerid_num) { + p->callerid_num = strdup(alias->value); + } + ast_copy_string(p->caller_dialedDigits, alias->value, + sizeof(p->caller_dialedDigits)); + } else if (alias->type == T_H225AliasAddress_email_ID) { + ast_copy_string(p->caller_email, alias->value, sizeof(p->caller_email)); + } else if (alias->type == T_H225AliasAddress_url_ID) { + ast_copy_string(p->caller_url, alias->value, sizeof(p->caller_url)); + } + } + } + + number[0] = '\0'; + if (ooCallGetCalledPartyNumber(call, number, OO_MAX_NUMBER_LENGTH) == OO_OK) { + ast_copy_string(p->exten, number, sizeof(p->exten)); + } else { + update_our_aliases(call, p); + if (!ast_strlen_zero(p->callee_dialedDigits)) { + ast_copy_string(p->exten, p->callee_dialedDigits, sizeof(p->exten)); + } else if (!ast_strlen_zero(p->callee_h323id)) { + ast_copy_string(p->exten, p->callee_h323id, sizeof(p->exten)); + } else if (!ast_strlen_zero(p->callee_email)) { + ast_copy_string(p->exten, p->callee_email, sizeof(p->exten)); + if ((at = strchr(p->exten, '@'))) { + *at = '\0'; + } + } + } + + /* if no extension found, set to default 's' */ + if (ast_strlen_zero(p->exten)) { + ast_copy_string(p->exten, "s", sizeof(p->exten)); + } + + if (!p->callerid_name) { + p->callerid_name = strdup(call->remoteIP); + } + + if (p->callerid_name) { + if ((user = find_user(p->callerid_name, call->remoteIP))) { + ast_mutex_lock(&user->lock); + p->username = strdup(user->name); + ast_copy_string(p->context, user->context, sizeof(p->context)); + ast_copy_string(p->accountcode, user->accountcode, sizeof(p->accountcode)); + p->amaflags = user->amaflags; + p->capability = user->capability; + memcpy(&p->prefs, &user->prefs, sizeof(struct ast_codec_pref)); + p->dtmfmode = user->dtmfmode; + /* Since, call is coming from a pbx user, no need to use gk */ + OO_SETFLAG(p->flags, H323_DISABLEGK); + OO_SETFLAG(call->flags, OO_M_DISABLEGK); + ast_mutex_unlock(&user->lock); + } + } + + + ooh323c_set_capability_for_call(call, &p->prefs, p->capability, p->dtmfmode); + configure_local_rtp(p, call); + + ast_mutex_unlock(&p->lock); + + if (gH323Debug) + ast_verbose("+++ ooh323_onReceivedSetup - Determined context %s, " + "extension %s\n", p->context, p->exten); + + return OO_OK; +} + + + +int onNewCallCreated(ooCallData *call) +{ + struct ooh323_pvt *p = NULL; + int i = 0; + + if (gH323Debug) + ast_verbose("--- onNewCallCreated %s\n", call->callToken); + + if (!strcmp(call->callType, "outgoing")) { + p = find_call(call); + if (!p) { + ast_log(LOG_ERROR, "No matching call found for outgoing call\n"); + return -1; + } + ast_mutex_lock(&p->lock); + if (p->callerid_name) { + ooCallSetCallerId(call, p->callerid_name); + } + if (p->callerid_num) { + i = 0; + while (*(p->callerid_num + i) != '\0') { + if (!isdigit(*(p->callerid_num + i))) { + break; + } + i++; + } + if (*(p->callerid_num + i) == '\0') { + ooCallSetCallingPartyNumber(call, p->callerid_num); + } else { + if (!p->callerid_name) { + ooCallSetCallerId(call, p->callerid_num); + } + } + } + + if (!ast_strlen_zero(p->caller_h323id)) + ooCallAddAliasH323ID(call, p->caller_h323id); + + if (!ast_strlen_zero(p->caller_dialedDigits)) { + if (gH323Debug) { + ast_verbose("Setting dialed digits %s\n", p->caller_dialedDigits); + } + ooCallAddAliasDialedDigits(call, p->caller_dialedDigits); + } else if (p->callerid_num) { + if (ooIsDailedDigit(p->callerid_num)) { + if (gH323Debug) { + ast_verbose("setting callid number %s\n", p->callerid_num); + } + ooCallAddAliasDialedDigits(call, p->callerid_num); + } else if (ast_strlen_zero(p->caller_h323id)) { + ooCallAddAliasH323ID(call, p->callerid_num); + } + } + + + if (!ast_strlen_zero(p->exten)) { + if (ooIsDailedDigit(p->exten)) { + ooCallSetCalledPartyNumber(call, p->exten); + ooCallAddRemoteAliasDialedDigits(call, p->exten); + } else { + ooCallAddRemoteAliasH323ID(call, p->exten); + } + } + + if (gH323Debug) { + char prefsBuf[256]; + ast_codec_pref_string(&p->prefs, prefsBuf, sizeof(prefsBuf)); + ast_verbose(" Outgoing call %s(%s) - Codec prefs - %s\n", + p->username?p->username:"NULL", call->callToken, prefsBuf); + } + + ooh323c_set_capability_for_call(call, &p->prefs, p->capability, p->dtmfmode); + + configure_local_rtp(p, call); + ast_mutex_unlock(&p->lock); + } + if (gH323Debug) + ast_verbose("+++ onNewCallCreated %s\n", call->callToken); + + return OO_OK; +} + +int onCallEstablished(ooCallData *call) +{ + struct ooh323_pvt *p = NULL; + + if (gH323Debug) + ast_verbose("--- onCallEstablished %s\n", call->callToken); + + if (!(p = find_call(call))) { + ast_log(LOG_ERROR, "Failed to find a matching call.\n"); + return -1; + } + ast_mutex_lock(&p->lock); + if (!p->owner) { + ast_mutex_unlock(&p->lock); + ast_log(LOG_ERROR, "Channel has no owner\n"); + return -1; + } + + while (ast_channel_trylock(p->owner)) { + ast_debug(1,"Failed to grab lock, trying again\n"); + ast_mutex_unlock(&p->lock); + usleep(1); + ast_mutex_lock(&p->lock); + } + if (p->owner->_state != AST_STATE_UP) { + ast_setstate(p->owner, AST_STATE_UP); + } + ast_channel_unlock(p->owner); + if (ast_test_flag(p, H323_OUTGOING)) { + struct ast_channel* c = p->owner; + ast_mutex_unlock(&p->lock); + ast_queue_control(c, AST_CONTROL_ANSWER); + } else { + ast_mutex_unlock(&p->lock); + } + + if (gH323Debug) + ast_verbose("+++ onCallEstablished %s\n", call->callToken); + + return OO_OK; +} + +int onCallCleared(ooCallData *call) +{ + struct ooh323_pvt *p = NULL; + int ownerLock = 0; + + if (gH323Debug) + ast_verbose("--- onCallCleared %s \n", call->callToken); + + p = find_call(call); + if (!p) { + return 0; + } + ast_mutex_lock(&p->lock); + + while (p->owner) { + if (ast_channel_trylock(p->owner)) { + ooTrace(OOTRCLVLINFO, "Failed to grab lock, trying again\n"); + ast_debug(1,"Failed to grab lock, trying again\n"); + ast_mutex_unlock(&p->lock); + usleep(1); + ast_mutex_lock(&p->lock); + } else { + ownerLock = 1; + break; + } + } + + if (ownerLock) { + if (!ast_test_flag(p, H323_ALREADYGONE)) { + + /* NOTE: Channel is not detached yet */ + ast_set_flag(p, H323_ALREADYGONE); + p->owner->hangupcause = + ooh323_convert_hangupcause_h323ToAsterisk(call->callEndReason); + p->owner->_softhangup |= AST_SOFTHANGUP_DEV; + ast_channel_unlock(p->owner); + ast_queue_hangup(p->owner); + ast_mutex_unlock(&p->lock); + return OO_OK; + } + ast_channel_unlock(p->owner); + } + ast_set_flag(p, H323_NEEDDESTROY); + ast_mutex_unlock(&p->lock); + + if (gH323Debug) + ast_verbose("+++ onCallCleared\n"); + + return OO_OK; +} + +#if 0 +static void ooh323_delete_user(struct ooh323_user *user) +{ + struct ooh323_user *prev = NULL, *cur = NULL; + + if (gH323Debug) + ast_verbose("--- ooh323_delete_user\n"); + + if (user) { + cur = userl.users; + ast_mutex_lock(&userl.lock); + while (cur) { + if (cur == user) break; + prev = cur; + cur = cur->next; + } + + if (cur) { + if (prev) + prev->next = cur->next; + else + userl.users = cur->next; + } + ast_mutex_unlock(&userl.lock); + + free(user); + } + + if (gH323Debug) + ast_verbose("+++ ooh323_delete_user\n"); + +} +#endif + +void ooh323_delete_peer(struct ooh323_peer *peer) +{ + struct ooh323_peer *prev = NULL, *cur = NULL; + + if (gH323Debug) + ast_verbose("--- ooh323_delete_peer\n"); + + if (peer) { + ast_mutex_lock(&peerl.lock); + for (cur = peerl.peers; cur; prev = cur, cur = cur->next) { + if (cur == peer) { + break; + } + } + + if (cur) { + if (prev) { + prev->next = cur->next; + } else { + peerl.peers = cur->next; + } + } + ast_mutex_unlock(&peerl.lock); + + if (peer->h323id) + free(peer->h323id); + if (peer->email) + free(peer->email); + if (peer->url) + free(peer->url); + if (peer->e164) + free(peer->e164); + + free(peer); + } + + if (gH323Debug) + ast_verbose("+++ ooh323_delete_peer\n"); +} + + + +static struct ooh323_user *build_user(const char *name, struct ast_variable *v) +{ + struct ooh323_user *user = NULL; + + if (gH323Debug) + ast_verbose("--- build_user\n"); + + user = ast_calloc(1, sizeof(*user)); + if (user) { + ast_mutex_init(&user->lock); + ast_copy_string(user->name, name, sizeof(user->name)); + user->capability = gCapability; + memcpy(&user->prefs, &gPrefs, sizeof(user->prefs)); + user->rtptimeout = gRTPTimeout; + user->dtmfmode = gDTMFMode; + /* set default context */ + ast_copy_string(user->context, gContext, sizeof(user->context)); + ast_copy_string(user->accountcode, gAccountcode, sizeof(user->accountcode)); + user->amaflags = gAMAFLAGS; + + while (v) { + if (!strcasecmp(v->name, "context")) { + ast_copy_string(user->context, v->value, sizeof(user->context)); + } else if (!strcasecmp(v->name, "incominglimit")) { + user->incominglimit = atoi(v->value); + if (user->incominglimit < 0) + user->incominglimit = 0; + } else if (!strcasecmp(v->name, "accountcode")) { + ast_copy_string(user->accountcode, v->value, sizeof(user->accountcode)); + } else if (!strcasecmp(v->name, "rtptimeout")) { + user->rtptimeout = atoi(v->value); + if (user->rtptimeout < 0) + user->rtptimeout = gRTPTimeout; + } else if (!strcasecmp(v->name, "disallow")) { + ast_parse_allow_disallow(&user->prefs, &user->capability, + v->value, 0); + } else if (!strcasecmp(v->name, "allow")) { + const char* tcodecs = v->value; + if (!strcasecmp(v->value, "all")) { + tcodecs = "ulaw,alaw,g729,g723,gsm"; + } + ast_parse_allow_disallow(&user->prefs, &user->capability, + tcodecs, 1); + } else if (!strcasecmp(v->name, "amaflags")) { + user->amaflags = ast_cdr_amaflags2int(v->value); + } else if (!strcasecmp(v->name, "ip")) { + ast_copy_string(user->mIP, v->value, sizeof(user->mIP)); + user->mUseIP = 1; + } else if (!strcasecmp(v->name, "dtmfmode")) { + if (!strcasecmp(v->value, "rfc2833")) + user->dtmfmode = H323_DTMF_RFC2833; + else if (!strcasecmp(v->value, "q931keypad")) + user->dtmfmode = H323_DTMF_Q931; + else if (!strcasecmp(v->value, "h245alphanumeric")) + user->dtmfmode = H323_DTMF_H245ALPHANUMERIC; + else if (!strcasecmp(v->value, "h245signal")) + user->dtmfmode = H323_DTMF_H245SIGNAL; + } + v = v->next; + } + } + + if (gH323Debug) + ast_verbose("+++ build_user\n"); + + return user; +} + +static struct ooh323_peer *build_peer(const char *name, struct ast_variable *v, int friend_type) +{ + struct ooh323_peer *peer = NULL; + + if (gH323Debug) + ast_verbose("--- build_peer\n"); + + peer = ast_calloc(1, sizeof(*peer)); + if (peer) { + memset(peer, 0, sizeof(struct ooh323_peer)); + ast_mutex_init(&peer->lock); + ast_copy_string(peer->name, name, sizeof(peer->name)); + peer->capability = gCapability; + memcpy(&peer->prefs, &gPrefs, sizeof(struct ast_codec_pref)); + peer->rtptimeout = gRTPTimeout; + ast_copy_string(peer->accountcode, gAccountcode, sizeof(peer->accountcode)); + peer->amaflags = gAMAFLAGS; + peer->dtmfmode = gDTMFMode; + if (0 == friend_type) { + peer->mFriend = 1; + } + + while (v) { + if (!strcasecmp(v->name, "h323id")) { + if (!(peer->h323id = ast_strdup(v->value))) { + ast_log(LOG_ERROR, "Could not allocate memory for h323id of " + "peer %s\n", name); + ooh323_delete_peer(peer); + return NULL; + } + } else if (!strcasecmp(v->name, "e164")) { + if (!(peer->e164 = ast_strdup(v->value))) { + ast_log(LOG_ERROR, "Could not allocate memory for e164 of " + "peer %s\n", name); + ooh323_delete_peer(peer); + return NULL; + } + } else if (!strcasecmp(v->name, "email")) { + if (!(peer->email = ast_strdup(v->value))) { + ast_log(LOG_ERROR, "Could not allocate memory for email of " + "peer %s\n", name); + ooh323_delete_peer(peer); + return NULL; + } + } else if (!strcasecmp(v->name, "url")) { + if (!(peer->url = ast_strdup(v->value))) { + ast_log(LOG_ERROR, "Could not allocate memory for h323id of " + "peer %s\n", name); + ooh323_delete_peer(peer); + return NULL; + } + } else if (!strcasecmp(v->name, "port")) { + peer->port = atoi(v->value); + } else if (!strcasecmp(v->name, "ip")) { + ast_copy_string(peer->ip, v->value, sizeof(peer->ip)); + } else if (!strcasecmp(v->name, "outgoinglimit")) { + if ((peer->outgoinglimit = atoi(v->value)) < 0) { + peer->outgoinglimit = 0; + } + } else if (!strcasecmp(v->name, "accountcode")) { + ast_copy_string(peer->accountcode, v->value, sizeof(peer->accountcode)); + } else if (!strcasecmp(v->name, "rtptimeout")) { + if ((peer->rtptimeout = atoi(v->value)) < 0) { + peer->rtptimeout = gRTPTimeout; + } + } else if (!strcasecmp(v->name, "disallow")) { + ast_parse_allow_disallow(&peer->prefs, &peer->capability, + v->value, 0); + } else if (!strcasecmp(v->name, "allow")) { + const char* tcodecs = v->value; + if (!strcasecmp(v->value, "all")) { + tcodecs = "ulaw,alaw,g729,g723,gsm"; + } + ast_parse_allow_disallow(&peer->prefs, &peer->capability, + tcodecs, 1); + } else if (!strcasecmp(v->name, "amaflags")) { + peer->amaflags = ast_cdr_amaflags2int(v->value); + } else if (!strcasecmp(v->name, "dtmfmode")) { + if (!strcasecmp(v->value, "rfc2833")) + peer->dtmfmode = H323_DTMF_RFC2833; + else if (!strcasecmp(v->value, "q931keypad")) + peer->dtmfmode = H323_DTMF_Q931; + else if (!strcasecmp(v->value, "h245alphanumeric")) + peer->dtmfmode = H323_DTMF_H245ALPHANUMERIC; + else if (!strcasecmp(v->value, "h245signal")) + peer->dtmfmode = H323_DTMF_H245SIGNAL; + } + v = v->next; + } + } + + if (gH323Debug) + ast_verbose("+++ build_peer\n"); + + return peer; +} + +static int ooh323_do_reload(void) +{ + if (gH323Debug) { + ast_verbose("--- ooh323_do_reload\n"); + } + + reload_config(1); + + if (gH323Debug) { + ast_verbose("+++ ooh323_do_reload\n"); + } + + return 0; +} + +#if 0 +/*--- h323_reload: Force reload of module from cli ---*/ +static int ooh323_reload(int fd, int argc, char *argv[]) +{ + + if (gH323Debug) + ast_verbose("--- ooh323_reload\n"); + + ast_mutex_lock(&h323_reload_lock); + if (h323_reloading) { + ast_verbose("Previous OOH323 reload not yet done\n"); + } + else { + h323_reloading = 1; + } + ast_mutex_unlock(&h323_reload_lock); + restart_monitor(); + + if (gH323Debug) + ast_verbose("+++ ooh323_reload\n"); + + return 0; +} +#endif + +#if 0 +static int reload(void *mod) +{ + return ooh323_reload(0, 0, NULL); +} +#endif + +int reload_config(int reload) +{ + int format; + struct ooAliases *pNewAlias = NULL; + struct ast_config *cfg; + struct ast_variable *v; + struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 }; + struct ooh323_user *user = NULL; + struct ooh323_peer *peer = NULL; + char *cat; + const char *utype; + + if (gH323Debug) + ast_verbose("--- reload_config\n"); + + cfg = ast_config_load((char*)config, config_flags); + + /* We *must* have a config file otherwise stop immediately */ + if (!cfg) { + ast_log(LOG_NOTICE, "Unable to load config %s, OOH323 disabled\n", config); + return 1; + } else if (cfg == CONFIG_STATUS_FILEUNCHANGED) + return RESULT_SUCCESS; + + if (reload) { + delete_users(); + delete_peers(); + } + + /* Inintialize everything to default */ + strcpy(gLogFile, DEFAULT_LOGFILE); + gPort = 1720; + gIP[0] = '\0'; + strcpy(gCallerID, DEFAULT_H323ID); + gCapability = AST_FORMAT_ULAW; + memset(&gPrefs, 0, sizeof(struct ast_codec_pref)); + gDTMFMode = H323_DTMF_RFC2833; + gRasGkMode = RasNoGatekeeper; + gGatekeeper[0] = '\0'; + gRTPTimeout = 60; + strcpy(gAccountcode, DEFAULT_H323ACCNT); + gFastStart = 1; + gTunneling = 1; + gTOS = 0; + strcpy(gContext, DEFAULT_CONTEXT); + gAliasList = NULL; + gMediaWaitForConnect = 0; + ooconfig.mTCPPortStart = 12030; + ooconfig.mTCPPortEnd = 12230; + + v = ast_variable_browse(cfg, "general"); + while (v) { + + if (!strcasecmp(v->name, "port")) { + gPort = (int)strtol(v->value, NULL, 10); + } else if (!strcasecmp(v->name, "bindaddr")) { + ast_copy_string(gIP, v->value, sizeof(gIP)); + } else if (!strcasecmp(v->name, "h225portrange")) { + char* endlimit = 0; + char temp[256]; + ast_copy_string(temp, v->value, sizeof(temp)); + endlimit = strchr(temp, ','); + if (endlimit) { + *endlimit = '\0'; + endlimit++; + ooconfig.mTCPPortStart = atoi(temp); + ooconfig.mTCPPortEnd = atoi(endlimit); + + if (ooH323EpSetTCPPortRange(ooconfig.mTCPPortStart, + ooconfig.mTCPPortEnd) == OO_FAILED) { + ast_log(LOG_ERROR, "h225portrange: Failed to set range\n"); + } + } else { + ast_log(LOG_ERROR, "h225portrange: Invalid format, separate port range with \",\"\n"); + } + } else if (!strcasecmp(v->name, "gateway")) { + gIsGateway = ast_true(v->value); + } else if (!strcasecmp(v->name, "faststart")) { + gFastStart = ast_true(v->value); + if (gFastStart) + ooH323EpEnableFastStart(); + else + ooH323EpDisableFastStart(); + } else if (!strcasecmp(v->name, "mediawaitforconnect")) { + gMediaWaitForConnect = ast_true(v->value); + if (gMediaWaitForConnect) + ooH323EpEnableMediaWaitForConnect(); + else + ooH323EpDisableMediaWaitForConnect(); + } else if (!strcasecmp(v->name, "h245tunneling")) { + gTunneling = ast_true(v->value); + if (gTunneling) + ooH323EpEnableH245Tunneling(); + else + ooH323EpDisableH245Tunneling(); + } else if (!strcasecmp(v->name, "h323id")) { + pNewAlias = malloc(sizeof(*pNewAlias)); + if (!pNewAlias) { + ast_log(LOG_ERROR, "Failed to allocate memory for h323id alias\n"); + return 1; + } + pNewAlias->type = T_H225AliasAddress_h323_ID; + pNewAlias->value = strdup(v->value); + pNewAlias->next = gAliasList; + gAliasList = pNewAlias; + pNewAlias = NULL; + } else if (!strcasecmp(v->name, "e164")) { + pNewAlias = malloc(sizeof(*pNewAlias)); + if (!pNewAlias) { + ast_log(LOG_ERROR, "Failed to allocate memory for e164 alias\n"); + return 1; + } + pNewAlias->type = T_H225AliasAddress_dialedDigits; + pNewAlias->value = strdup(v->value); + pNewAlias->next = gAliasList; + gAliasList = pNewAlias; + pNewAlias = NULL; + } else if (!strcasecmp(v->name, "email")) { + pNewAlias = malloc(sizeof(*pNewAlias)); + if (!pNewAlias) { + ast_log(LOG_ERROR, "Failed to allocate memory for email alias\n"); + return 1; + } + pNewAlias->type = T_H225AliasAddress_email_ID; + pNewAlias->value = strdup(v->value); + pNewAlias->next = gAliasList; + gAliasList = pNewAlias; + pNewAlias = NULL; + } else if (!strcasecmp(v->name, "callerid")) { + ast_copy_string(gCallerID, v->value, sizeof(gCallerID)); + } else if (!strcasecmp(v->name, "incominglimit")) { + gIncomingLimit = atoi(v->value); + } else if (!strcasecmp(v->name, "outgoinglimit")) { + gOutgoingLimit = atoi(v->value); + } else if (!strcasecmp(v->name, "gatekeeper")) { + if (!strcasecmp(v->value, "DISABLE")) { + gRasGkMode = RasNoGatekeeper; + } else if (!strcasecmp(v->value, "DISCOVER")) { + gRasGkMode = RasDiscoverGatekeeper; + } else { + gRasGkMode = RasUseSpecificGatekeeper; + ast_copy_string(gGatekeeper, v->value, sizeof(gGatekeeper)); + } + } else if (!strcasecmp(v->name, "logfile")) { + ast_copy_string(gLogFile, v->value, sizeof(gLogFile)); + } else if (!strcasecmp(v->name, "context")) { + ast_copy_string(gContext, v->value, sizeof(gContext)); + ast_verb(3, " == Setting default context to %s\n", gContext); + } else if (!strcasecmp(v->name, "rtptimeout")) { + gRTPTimeout = atoi(v->value); + if (gRTPTimeout <= 0) + gRTPTimeout = 60; + } else if (!strcasecmp(v->name, "tos")) { + if (sscanf(v->value, "%i", &format) == 1) + gTOS = format & 0xff; + else if (!strcasecmp(v->value, "lowdelay")) + gTOS = IPTOS_LOWDELAY; + else if (!strcasecmp(v->value, "throughput")) + gTOS = IPTOS_THROUGHPUT; + else if (!strcasecmp(v->value, "reliability")) + gTOS = IPTOS_RELIABILITY; + else if (!strcasecmp(v->value, "mincost")) + gTOS = IPTOS_MINCOST; + else if (!strcasecmp(v->value, "none")) + gTOS = 0; + else + ast_log(LOG_WARNING, "Invalid tos value at line %d, should be " + "'lowdelay', 'throughput', 'reliability', " + "'mincost', or 'none'\n", v->lineno); + } else if (!strcasecmp(v->name, "amaflags")) { + gAMAFLAGS = ast_cdr_amaflags2int(v->value); + } else if (!strcasecmp(v->name, "accountcode")) { + ast_copy_string(gAccountcode, v->value, sizeof(gAccountcode)-1); + } else if (!strcasecmp(v->name, "disallow")) { + ast_parse_allow_disallow(&gPrefs, &gCapability, v->value, 0); + } else if (!strcasecmp(v->name, "allow")) { + const char* tcodecs = v->value; + if (!strcasecmp(v->value, "all")) { + tcodecs = "ulaw,alaw,g729,g723,gsm"; + } + ast_parse_allow_disallow(&gPrefs, &gCapability, tcodecs, 1); + } else if (!strcasecmp(v->name, "dtmfmode")) { + if (!strcasecmp(v->value, "inband")) + gDTMFMode = H323_DTMF_INBAND; + else if (!strcasecmp(v->value, "rfc2833")) + gDTMFMode = H323_DTMF_RFC2833; + else if (!strcasecmp(v->value, "q931keypad")) + gDTMFMode = H323_DTMF_Q931; + else if (!strcasecmp(v->value, "h245alphanumeric")) + gDTMFMode = H323_DTMF_H245ALPHANUMERIC; + else if (!strcasecmp(v->value, "h245signal")) + gDTMFMode = H323_DTMF_H245SIGNAL; + else { + ast_log(LOG_WARNING, "Unknown dtmf mode '%s', using rfc2833\n", v->value); + gDTMFMode = H323_DTMF_RFC2833; + } + } + v = v->next; + } + + for (cat = ast_category_browse(cfg, NULL); cat; cat = ast_category_browse(cfg, cat)) { + if (strcasecmp(cat, "general")) { + int friend_type = 0; + utype = ast_variable_retrieve(cfg, cat, "type"); + if (utype) { + friend_type = strcasecmp(utype, "friend"); + if (!strcmp(utype, "user") || 0 == friend_type) { + user = build_user(cat, ast_variable_browse(cfg, cat)); + if (user) { + ast_mutex_lock(&userl.lock); + user->next = userl.users; + userl.users = user; + ast_mutex_unlock(&userl.lock); + } else { + ast_log(LOG_WARNING, "Failed to build user %s\n", cat); + } + } + if (!strcasecmp(utype, "peer") || 0 == friend_type) { + peer = build_peer(cat, ast_variable_browse(cfg, cat), friend_type); + if (peer) { + ast_mutex_lock(&peerl.lock); + peer->next = peerl.peers; + peerl.peers = peer; + ast_mutex_unlock(&peerl.lock); + } else { + ast_log(LOG_WARNING, "Failed to build peer %s\n", cat); + } + } + } + } + } + ast_config_destroy(cfg); + + + /* Determine ip address if neccessary */ + if (ast_strlen_zero(gIP)) { + ooGetLocalIPAddress(gIP); + if (!strcmp(gIP, "127.0.0.1")) { + ast_log(LOG_NOTICE, "Failed to determine local ip address. Please " + "specify it in ooh323.conf. OOH323 Disabled\n"); + return 1; + } + } + + if (gH323Debug) + ast_verbose("+++ reload_config\n"); + + return 0; +} + +static char *handle_cli_ooh323_show_peer(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + char ip_port[30]; + struct ooh323_peer *prev = NULL, *peer = NULL; + + switch (cmd) { + case CLI_INIT: + e->command = "ooh323 show peer"; + e->usage = + "Usage: ooh323 show peer \n" + " List details of specific OOH323 peer.\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 4) + return CLI_SHOWUSAGE; + + ast_mutex_lock(&peerl.lock); + peer = peerl.peers; + while (peer) { + ast_mutex_lock(&peer->lock); + if (!strcmp(peer->name, a->argv[3])) + break; + else { + prev = peer; + peer = peer->next; + ast_mutex_unlock(&prev->lock); + } + } + + if (peer) { + snprintf(ip_port, sizeof(ip_port), "%s:%d", peer->ip, peer->port); + ast_cli(a->fd, "%-15.15s%s\n", "Name: ", peer->name); + ast_cli(a->fd, "%-15.15s%s", "Format Prefs: ", "("); + print_codec_to_cli(a->fd, &peer->prefs); + ast_cli(a->fd, ")\n"); + ast_cli(a->fd, "%-15.15s", "DTMF Mode: "); + if (peer->dtmfmode & H323_DTMF_RFC2833) + ast_cli(a->fd, "%s\n", "rfc2833"); + else if (peer->dtmfmode & H323_DTMF_Q931) + ast_cli(a->fd, "%s\n", "q931keypad"); + else if (peer->dtmfmode & H323_DTMF_H245ALPHANUMERIC) + ast_cli(a->fd, "%s\n", "h245alphanumeric"); + else if (peer->dtmfmode & H323_DTMF_H245SIGNAL) + ast_cli(a->fd, "%s\n", "h245signal"); + else + ast_cli(a->fd, "%s\n", "unknown"); + ast_cli(a->fd, "%-15.15s%s\n", "AccountCode: ", peer->accountcode); + ast_cli(a->fd, "%-15.15s%s\n", "AMA flags: ", + ast_cdr_flags2str(peer->amaflags)); + ast_cli(a->fd, "%-15.15s%s\n", "Ip:Port: ", ip_port); + ast_cli(a->fd, "%-15.15s%d\n", "OutgoingLimit: ", peer->outgoinglimit); + ast_cli(a->fd, "%-15.15s%d\n", "rtptimeout: ", peer->rtptimeout); + ast_mutex_unlock(&peer->lock); + } else { + ast_cli(a->fd, "Peer %s not found\n", a->argv[3]); + ast_cli(a->fd, "\n"); + } + ast_mutex_unlock(&peerl.lock); + + return CLI_SUCCESS; +} + +static char *handle_cli_ooh323_show_peers(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + char ip_port[30]; + char formats[512]; + struct ooh323_peer *prev = NULL, *peer = NULL; + +#define FORMAT "%-15.15s %-15.15s %-23.23s %-s\n" + + switch (cmd) { + case CLI_INIT: + e->command = "ooh323 show peers"; + e->usage = + "Usage: ooh323 show peers\n" + " Lists all known OOH323 peers.\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 3) + return CLI_SHOWUSAGE; + + ast_cli(a->fd, FORMAT, "Name", "Accountcode", "ip:port", "Formats"); + + ast_mutex_lock(&peerl.lock); + peer = peerl.peers; + while (peer) { + ast_mutex_lock(&peer->lock); + snprintf(ip_port, sizeof(ip_port), "%s:%d", peer->ip, peer->port); + ast_cli(a->fd, FORMAT, peer->name, + peer->accountcode, + ip_port, + ast_getformatname_multiple(formats, sizeof(formats), peer->capability)); + prev = peer; + peer = peer->next; + ast_mutex_unlock(&prev->lock); + } + ast_mutex_unlock(&peerl.lock); + +#undef FORMAT + + return CLI_SUCCESS; +} + +/*! \brief Print codec list from preference to CLI/manager */ +static void print_codec_to_cli(int fd, struct ast_codec_pref *pref) +{ + int x, codec; + + for (x = 0; x < 32; x++) { + codec = ast_codec_pref_index(pref, x); + if (!codec) + break; + ast_cli(fd, "%s", ast_getformatname(codec)); + ast_cli(fd, ":%d", pref->framing[x]); + if (x < 31 && ast_codec_pref_index(pref, x + 1)) + ast_cli(fd, ","); + } + if (!x) + ast_cli(fd, "none"); +} + +static char *handle_cli_ooh323_show_user(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct ooh323_user *prev = NULL, *user = NULL; + + switch (cmd) { + case CLI_INIT: + e->command = "ooh323 show user"; + e->usage = + "Usage: ooh323 show user \n" + " List details of specific OOH323 user.\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 4) + return CLI_SHOWUSAGE; + + ast_mutex_lock(&userl.lock); + user = userl.users; + while (user) { + ast_mutex_lock(&user->lock); + if (!strcmp(user->name, a->argv[3])) + break; + else { + prev = user; + user = user->next; + ast_mutex_unlock(&prev->lock); + } + } + + if (user) { + ast_cli(a->fd, "%-15.15s%s\n", "Name: ", user->name); + ast_cli(a->fd, "%-15.15s%s", "Format Prefs: ", "("); + print_codec_to_cli(a->fd, &user->prefs); + ast_cli(a->fd, ")\n"); + ast_cli(a->fd, "%-15.15s", "DTMF Mode: "); + if (user->dtmfmode & H323_DTMF_RFC2833) + ast_cli(a->fd, "%s\n", "rfc2833"); + else if (user->dtmfmode & H323_DTMF_Q931) + ast_cli(a->fd, "%s\n", "q931keypad"); + else if (user->dtmfmode & H323_DTMF_H245ALPHANUMERIC) + ast_cli(a->fd, "%s\n", "h245alphanumeric"); + else if (user->dtmfmode & H323_DTMF_H245SIGNAL) + ast_cli(a->fd, "%s\n", "h245signal"); + else + ast_cli(a->fd, "%s\n", "unknown"); + ast_cli(a->fd, "%-15.15s%s\n", "AccountCode: ", user->accountcode); + ast_cli(a->fd, "%-15.15s%s\n", "AMA flags: ", ast_cdr_flags2str(user->amaflags)); + ast_cli(a->fd, "%-15.15s%s\n", "Context: ", user->context); + ast_cli(a->fd, "%-15.15s%d\n", "IncomingLimit: ", user->incominglimit); + ast_cli(a->fd, "%-15.15s%d\n", "rtptimeout: ", user->rtptimeout); + ast_mutex_unlock(&user->lock); + } else { + ast_cli(a->fd, "User %s not found\n", a->argv[3]); + ast_cli(a->fd, "\n"); + } + ast_mutex_unlock(&userl.lock); + + return CLI_SUCCESS; +} + +static char *handle_cli_ooh323_show_users(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + char formats[512]; + struct ooh323_user *prev = NULL, *user = NULL; + +#define FORMAT1 "%-15.15s %-15.15s %-15.15s %-s\n" + + switch (cmd) { + case CLI_INIT: + e->command = "ooh323 show users"; + e->usage = + "Usage: ooh323 show users \n" + " Lists all known OOH323 users.\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 3) + return CLI_SHOWUSAGE; + + ast_cli(a->fd, FORMAT1, "Username", "Accountcode", "Context", "Formats"); + + ast_mutex_lock(&userl.lock); + user = userl.users; + while (user) { + ast_mutex_lock(&user->lock); + ast_cli(a->fd, FORMAT1, user->name, + user->accountcode, user->context, + ast_getformatname_multiple(formats, 512, user->capability)); + prev = user; + user = user->next; + ast_mutex_unlock(&prev->lock); + } + ast_mutex_unlock(&userl.lock); + +#undef FORMAT1 + + return CLI_SUCCESS; +} + +static char *handle_cli_ooh323_set_debug(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + switch (cmd) { + case CLI_INIT: + e->command = "ooh323 set debug [off]"; + e->usage = + "Usage: ooh323 set debug [off]\n" + " Enables/Disables debugging of OOH323 channel driver\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc < 3 || a->argc > 4) + return CLI_SHOWUSAGE; + if (a->argc == 4 && strcasecmp(a->argv[3], "off")) + return CLI_SHOWUSAGE; + + gH323Debug = (a->argc == 4) ? FALSE : TRUE; + ast_cli(a->fd, "OOH323 Debugging %s\n", gH323Debug ? "Enabled" : "Disabled"); + + return CLI_SUCCESS; +} + +#if 0 +static int ooh323_show_channels(int fd, int argc, char *argv[]) +{ + return RESULT_SUCCESS; +} +#endif + +static char *handle_cli_ooh323_show_config(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + char value[512]; + ooAliases *pAlias = NULL, *pAliasNext = NULL;; + + switch (cmd) { + case CLI_INIT: + e->command = "ooh323 show config"; + e->usage = + "Usage: ooh323 show config\n" + " Shows global configuration of H.323 channel driver\n"; + return NULL; + case CLI_GENERATE: + return NULL; + } + + if (a->argc != 3) + return CLI_SHOWUSAGE; + + snprintf(value, sizeof(value), "%s:%d", gIP, gPort); + ast_cli(a->fd, "\nObjective Open H.323 Channel Driver's Config:\n"); + ast_cli(a->fd, "%-20s%s\n", "IP:Port: ", value); + ast_cli(a->fd, "%-20s%s\n", "FastStart", gFastStart?"yes":"no"); + ast_cli(a->fd, "%-20s%s\n", "Tunneling", gTunneling?"yes":"no"); + ast_cli(a->fd, "%-20s%s\n", "CallerId", gCallerID); + ast_cli(a->fd, "%-20s%s\n", "MediaWaitForConnect", gMediaWaitForConnect ? "yes" : "no"); + +#if 0 + { + extern OOH323EndPoint gH323ep; + + ast_cli(a->fd, "%-20s%s\n", "FASTSTART", + (OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART) != 0) ? "yes" : "no"); + ast_cli(a->fd, "%-20s%s\n", "TUNNELING", + (OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING) != 0) ? "yes" : "no"); + ast_cli(a->fd, "%-20s%s\n", "MEDIAWAITFORCONN", + (OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN) != 0) ? "yes" : "no"); + } +#endif + + if (gRasGkMode == RasNoGatekeeper) + snprintf(value, sizeof(value), "%s", "No Gatekeeper"); + else if (gRasGkMode == RasDiscoverGatekeeper) + snprintf(value, sizeof(value), "%s", "Discover"); + else + snprintf(value, sizeof(value), "%s", gGatekeeper); + + ast_cli(a->fd, "%-20s%s\n", "Gatekeeper:", value); + ast_cli(a->fd, "%-20s%s\n", "H.323 LogFile:", gLogFile); + ast_cli(a->fd, "%-20s%s\n", "Context:", gContext); + ast_cli(a->fd, "%-20s%s\n", "Capability:", ast_getformatname_multiple(value, sizeof(value), gCapability)); + ast_cli(a->fd, "%-20s", "DTMF Mode: "); + if (gDTMFMode & H323_DTMF_RFC2833) + ast_cli(a->fd, "%s\n", "rfc2833"); + else if (gDTMFMode & H323_DTMF_Q931) + ast_cli(a->fd, "%s\n", "q931keypad"); + else if (gDTMFMode & H323_DTMF_H245ALPHANUMERIC) + ast_cli(a->fd, "%s\n", "h245alphanumeric"); + else if (gDTMFMode & H323_DTMF_H245SIGNAL) + ast_cli(a->fd, "%s\n", "h245signal"); + else + ast_cli(a->fd, "%s\n", "unknown"); + ast_cli(a->fd, "%-20s%s\n", "AccountCode: ", gAccountcode); + ast_cli(a->fd, "%-20s%s\n", "AMA flags: ", ast_cdr_flags2str(gAMAFLAGS)); + + pAlias = gAliasList; + if (pAlias) + ast_cli(a->fd, "%-20s\n", "Aliases: "); + while (pAlias) { + pAliasNext = pAlias->next; + if (pAliasNext) { + ast_cli(a->fd, "\t%-30s\t%-30s\n", pAlias->value, pAliasNext->value); + pAlias = pAliasNext->next; + } else { + ast_cli(a->fd, "\t%-30s\n", pAlias->value); + pAlias = pAlias->next; + } + } + + return CLI_SUCCESS; +} + +static struct ast_cli_entry cli_ooh323[] = { + AST_CLI_DEFINE(handle_cli_ooh323_set_debug, "Enable/Disable OOH323 debugging"), + AST_CLI_DEFINE(handle_cli_ooh323_show_config, "Show details on global configuration of H.323 channel driver"), + AST_CLI_DEFINE(handle_cli_ooh323_show_peer, "Show details on specific OOH323 peer"), + AST_CLI_DEFINE(handle_cli_ooh323_show_peers, "Show defined OOH323 peers"), + AST_CLI_DEFINE(handle_cli_ooh323_show_user, "Show details on specific OOH323 user"), + AST_CLI_DEFINE(handle_cli_ooh323_show_users, "Show defined OOH323 users"), +}; + +static int load_module(void) +{ + int res; + struct ooAliases * pNewAlias = NULL; + struct ooh323_peer *peer = NULL; + OOH225MsgCallbacks h225Callbacks = {0, 0, 0, 0}; + + OOH323CALLBACKS h323Callbacks = { + .onNewCallCreated = onNewCallCreated, + .onAlerting = onAlerting, + .onIncomingCall = NULL, + .onOutgoingCall = NULL, + .onCallEstablished = onCallEstablished, + .onCallCleared = onCallCleared, + .openLogicalChannels = NULL, + .onReceivedDTMF = &ooh323_onReceivedDigit + }; + + ast_log(LOG_NOTICE, + "---------------------------------------------------------------------------------\n" + "--- ******* IMPORTANT NOTE ***********\n" + "---\n" + "--- This module is currently unsupported. Use it at your own risk.\n" + "---\n" + "---------------------------------------------------------------------------------\n"); + + h225Callbacks.onReceivedSetup = &ooh323_onReceivedSetup; + + userl.users = NULL; + ast_mutex_init(&userl.lock); + peerl.peers = NULL; + ast_mutex_init(&peerl.lock); + +#if 0 + ast_register_atexit(&ast_ooh323c_exit); +#endif + + if (!(sched = sched_context_create())) { + ast_log(LOG_WARNING, "Unable to create schedule context\n"); + } + if (!(io = io_context_create())) { + ast_log(LOG_WARNING, "Unable to create I/O context\n"); + } + + + if (!(res = reload_config(0))) { + /* Make sure we can register our OOH323 channel type */ + if (ast_channel_register(&ooh323_tech)) { + ast_log(LOG_ERROR, "Unable to register channel class %s\n", type); + return 0; + } + ast_rtp_proto_register(&ooh323_rtp); + ast_cli_register_multiple(cli_ooh323, sizeof(cli_ooh323) / sizeof(struct ast_cli_entry)); + + /* fire up the H.323 Endpoint */ + if (OO_OK != ooH323EpInitialize(OO_CALLMODE_AUDIOCALL, gLogFile)) { + ast_log(LOG_ERROR, "Failed to initialize OOH323 endpoint-OOH323 Disabled\n"); + return 1; + } + + if (gIsGateway) + ooH323EpSetAsGateway(); + + ooH323EpDisableAutoAnswer(); + ooH323EpSetH225MsgCallbacks(h225Callbacks); + ooH323EpSetTraceLevel(OOTRCLVLDBGC); + ooH323EpSetLocalAddress(gIP, gPort); + ooH323EpSetCallerID(gCallerID); + + /* Set aliases if any */ + for (pNewAlias = gAliasList; pNewAlias; pNewAlias = pNewAlias->next) { + switch (pNewAlias->type) { + case T_H225AliasAddress_h323_ID: + ooH323EpAddAliasH323ID(pNewAlias->value); + break; + case T_H225AliasAddress_dialedDigits: + ooH323EpAddAliasDialedDigits(pNewAlias->value); + break; + case T_H225AliasAddress_email_ID: + ooH323EpAddAliasEmailID(pNewAlias->value); + break; + } + } + + ast_mutex_lock(&peerl.lock); + peer = peerl.peers; + while (peer) { + if (peer->h323id) + ooH323EpAddAliasH323ID(peer->h323id); + if (peer->email) + ooH323EpAddAliasEmailID(peer->email); + if (peer->e164) + ooH323EpAddAliasDialedDigits(peer->e164); + if (peer->url) + ooH323EpAddAliasURLID(peer->url); + peer = peer->next; + } + ast_mutex_unlock(&peerl.lock); + + + if (gMediaWaitForConnect) + ooH323EpEnableMediaWaitForConnect(); + else + ooH323EpDisableMediaWaitForConnect(); + + /* Fast start and tunneling options */ + if (gFastStart) + ooH323EpEnableFastStart(); + else + ooH323EpDisableFastStart(); + + if (!gTunneling) + ooH323EpDisableH245Tunneling(); + + /* Gatekeeper */ + if (gRasGkMode == RasUseSpecificGatekeeper) + ooGkClientInit(gRasGkMode, gGatekeeper, 0); + else if (gRasGkMode == RasDiscoverGatekeeper) + ooGkClientInit(gRasGkMode, 0, 0); + + /* Register callbacks */ + ooH323EpSetH323Callbacks(h323Callbacks); + + /* Add endpoint capabilities */ + if (ooh323c_set_capability(&gPrefs, gCapability, gDTMFMode) < 0) { + ast_log(LOG_ERROR, "Capabilities failure for OOH323. OOH323 Disabled.\n"); + return 1; + } + + + /* Create H.323 listener */ + if (ooCreateH323Listener() != OO_OK) { + ast_log(LOG_ERROR, "OOH323 Listener Creation failure. OOH323 DISABLED\n"); + + ooH323EpDestroy(); + return 1; + } + + if (ooh323c_start_stack_thread() < 0) { + ast_log(LOG_ERROR, "Failed to start OOH323 stack thread. OOH323 DISABLED\n"); + ooH323EpDestroy(); + return 1; + } + /* And start the monitor for the first time */ + restart_monitor(); + } + + return 0; +} + + +static void *do_monitor(void *data) +{ + int res; + int reloading; + struct ooh323_pvt *h323 = NULL; + time_t t; + + for (;;) { + struct ooh323_pvt *h323_next; + /* Check for a reload request */ + ast_mutex_lock(&h323_reload_lock); + reloading = h323_reloading; + h323_reloading = 0; + ast_mutex_unlock(&h323_reload_lock); + if (reloading) { + ast_verb(1, "Reloading H.323\n"); + ooh323_do_reload(); + } + /* Check for interfaces needing to be killed */ + ast_mutex_lock(&iflock); + time(&t); + h323 = iflist; + while (h323) { + h323_next = h323->next; + + /* TODO: Need to add rtptimeout keepalive support */ + if (ast_test_flag(h323, H323_NEEDDESTROY)) { + ooh323_destroy (h323); + } + h323 = h323_next; + } + ast_mutex_unlock(&iflock); + pthread_testcancel(); + /* Wait for sched or io */ + res = ast_sched_wait(sched); + if ((res < 0) || (res > 1000)) { + res = 1000; + } + res = ast_io_wait(io, res); + pthread_testcancel(); + ast_mutex_lock(&monlock); + if (res >= 0) { + ast_sched_runq(sched); + } + ast_mutex_unlock(&monlock); + } + /* Never reached */ + return NULL; +} + +int restart_monitor(void) +{ + pthread_attr_t attr; + + /* If we're supposed to be stopped -- stay stopped */ + if (monitor_thread == AST_PTHREADT_STOP) + return 0; + if (ast_mutex_lock(&monlock)) { + ast_log(LOG_WARNING, "Unable to lock monitor\n"); + return -1; + } + if (monitor_thread == pthread_self()) { + ast_mutex_unlock(&monlock); + ast_log(LOG_WARNING, "Cannot kill myself\n"); + return -1; + } + if (monitor_thread != AST_PTHREADT_NULL) { + /* Wake up the thread */ + pthread_kill(monitor_thread, SIGURG); + } else { + pthread_attr_init(&attr); + pthread_attr_setdetachstate(&attr, PTHREAD_CREATE_DETACHED); + /* Start a new monitor */ + if (ast_pthread_create(&monitor_thread, &attr, do_monitor, NULL) < 0) { + ast_mutex_unlock(&monlock); + ast_log(LOG_ERROR, "Unable to start monitor thread.\n"); + return -1; + } + } + ast_mutex_unlock(&monlock); + return 0; +} + + + +int ooh323_destroy(struct ooh323_pvt *p) +{ + /* NOTE: Assumes iflock already acquired */ + struct ooh323_pvt *prev = NULL, *cur = NULL; + + + if (gH323Debug) { + ast_verbose("--- ooh323_destroy \n"); + + if (p) + ast_verbose(" Destroying %s\n", p->username); + } + + cur = iflist; + while (cur) { + if (cur == p) { break; } + prev = cur; + cur = cur->next; + } + + if (cur) { + ast_mutex_lock(&cur->lock); + if (prev) + prev->next = cur->next; + else + iflist = cur->next; + + if (cur->callToken) { + free(cur->callToken); + cur->callToken = 0; + } + + if (cur->username) { + free(cur->username); + cur->username = 0; + } + + if (cur->host) { + free(cur->host); + cur->host = 0; + } + + if (cur->callerid_name) { + free(cur->callerid_name); + cur->callerid_name = 0; + } + + if (cur->callerid_num) { + free(cur->callerid_num); + cur->callerid_num = 0; + } + + + if (cur->rtp) { + ast_rtp_destroy(cur->rtp); + cur->rtp = 0; + } + + /* Unlink us from the owner if we have one */ + if (cur->owner) { + ast_channel_lock(cur->owner); + ast_debug(1, "Detaching from %s\n", cur->owner->name); + cur->owner->tech_pvt = NULL; + ast_channel_unlock(cur->owner); + cur->owner = NULL; + } + + if (cur->vad) { + ast_dsp_free(cur->vad); + cur->vad = NULL; + } + ast_mutex_unlock(&cur->lock); + ast_mutex_destroy(&cur->lock); + + free(cur); + } + + if (gH323Debug) + ast_verbose("+++ ooh323_destroy\n"); + + return 0; +} + +int delete_peers() +{ + struct ooh323_peer *cur = NULL, *prev = NULL; + ast_mutex_lock(&peerl.lock); + cur = peerl.peers; + while (cur) { + prev = cur; + cur = cur->next; + + ast_mutex_destroy(&prev->lock); + if (prev->h323id) + free(prev->h323id); + if (prev->email) + free(prev->email); + if (prev->url) + free(prev->url); + if (prev->e164) + free(prev->e164); + free(prev); + + if (cur == peerl.peers) { + break; + } + } + peerl.peers = NULL; + ast_mutex_unlock(&peerl.lock); + return 0; +} + +int delete_users() +{ + struct ooh323_user *cur = NULL, *prev = NULL; + ast_mutex_lock(&userl.lock); + cur = userl.users; + while (cur) { + prev = cur; + cur = cur->next; + ast_mutex_destroy(&prev->lock); + free(prev); + if (cur == userl.users) { + break; + } + } + userl.users = NULL; + ast_mutex_unlock(&userl.lock); + return 0; +} + +static int unload_module(void) +{ + struct ooh323_pvt *p; + struct ooAliases *cur = NULL, *prev = NULL; + + if (gH323Debug) { + ast_verbose("--- ooh323 unload_module \n"); + } + /* First, take us out of the channel loop */ + ast_cli_unregister_multiple(cli_ooh323, sizeof(cli_ooh323) / sizeof(struct ast_cli_entry)); + ast_rtp_proto_unregister(&ooh323_rtp); + ast_channel_unregister(&ooh323_tech); + +#if 0 + ast_unregister_atexit(&ast_ooh323c_exit); +#endif + + if (gH323Debug) { + ast_verbose(" unload_module - hanging up all interfaces\n"); + } + if (!ast_mutex_lock(&iflock)) { + /* Hangup all interfaces if they have an owner */ + p = iflist; + while (p) { + if (p->owner) { + ast_softhangup(p->owner, AST_SOFTHANGUP_APPUNLOAD); + } + p = p->next; + } + iflist = NULL; + ast_mutex_unlock(&iflock); + } else { + ast_log(LOG_WARNING, "Unable to lock the interface list\n"); + return -1; + } + + + if (gH323Debug) { + ast_verbose(" unload_module - stopping monitor thread\n"); + } + if (monitor_thread != AST_PTHREADT_NULL) { + if (!ast_mutex_lock(&monlock)) { + if (monitor_thread && (monitor_thread != AST_PTHREADT_STOP)) { + pthread_cancel(monitor_thread); + pthread_kill(monitor_thread, SIGURG); + pthread_join(monitor_thread, NULL); + } + monitor_thread = AST_PTHREADT_STOP; + ast_mutex_unlock(&monlock); + } else { + ast_log(LOG_WARNING, "Unable to lock the monitor\n"); + return -1; + } + } + + + if (gH323Debug) { + ast_verbose(" unload_module - stopping stack thread\n"); + } + ooh323c_stop_stack_thread(); + + + if (gH323Debug) { + ast_verbose(" unload_module - freeing up memory used by interfaces\n"); + } + if (!ast_mutex_lock(&iflock)) { + struct ooh323_pvt *pl; + + /* Destroy all the interfaces and free their memory */ + p = iflist; + while (p) { + pl = p; + p = p->next; + /* Free associated memory */ + ooh323_destroy(pl); + } + iflist = NULL; + ast_mutex_unlock(&iflock); + } else { + ast_log(LOG_WARNING, "Unable to lock the interface list\n"); + return -1; + } + + + if (gH323Debug) { + ast_verbose(" unload_module - deleting users\n"); + } + delete_users(); + + + if (gH323Debug) { + ast_verbose(" unload_module - deleting peers\n"); + } + delete_peers(); + + + if (gH323Debug) { + ast_verbose(" unload_module - Freeing up alias list\n"); + } + cur = gAliasList; + while (cur) { + prev = cur; + cur = cur->next; + free(prev->value); + free(prev); + } + gAliasList = NULL; + + + if (gH323Debug) { + ast_verbose(" unload_module- destroying OOH323 endpoint \n"); + } + ooH323EpDestroy(); + + if (gH323Debug) { + ast_verbose("+++ ooh323 unload_module \n"); + } + + return 0; +} + + + +static enum ast_rtp_get_result ooh323_get_rtp_peer(struct ast_channel *chan, struct ast_rtp **rtp) +{ + struct ooh323_pvt *p = NULL; + enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL; + + if (!(p = (struct ooh323_pvt *) chan->tech_pvt)) + return AST_RTP_GET_FAILED; + + *rtp = p->rtp; + + if (!(p->rtp)) { + return AST_RTP_GET_FAILED; + } + res = AST_RTP_TRY_NATIVE; + + return res; +} + +static enum ast_rtp_get_result ooh323_get_vrtp_peer(struct ast_channel *chan, struct ast_rtp **rtp) +{ + struct ooh323_pvt *p = NULL; + enum ast_rtp_get_result res = AST_RTP_TRY_PARTIAL; + + if (!(p = (struct ooh323_pvt *) chan->tech_pvt)) + return AST_RTP_GET_FAILED; + + *rtp = p->vrtp; + + if (!(p->rtp)) { + return AST_RTP_GET_FAILED; + } + res = AST_RTP_TRY_NATIVE; + + return res; +} + + +int ooh323_update_capPrefsOrderForCall + (ooCallData *call, struct ast_codec_pref *prefs) +{ + int i = 0; + int codec = ast_codec_pref_index(prefs, i); + + ooResetCapPrefs(call); + while (codec) { + ooAppendCapToCapPrefs(call, ooh323_convertAsteriskCapToH323Cap(codec)); + codec = ast_codec_pref_index(prefs, ++i); + } + + return 0; +} + + +int ooh323_convertAsteriskCapToH323Cap(int cap) +{ + char formats[512]; + switch (cap) { + case AST_FORMAT_ULAW: + return OO_G711ULAW64K; + case AST_FORMAT_ALAW: + return OO_G711ALAW64K; + case AST_FORMAT_GSM: + return OO_GSMFULLRATE; + case AST_FORMAT_G729A: + return OO_G729A; + case AST_FORMAT_G723_1: + return OO_G7231; + case AST_FORMAT_H263: + return OO_H263VIDEO; + default: + ast_log(LOG_NOTICE, "Don't know how to deal with mode %s\n", + ast_getformatname_multiple(formats, sizeof(formats), cap)); + return -1; + } +} + +static int ooh323_set_rtp_peer(struct ast_channel *chan, struct ast_rtp *rtp, + struct ast_rtp *vrtp, struct ast_rtp *trtp, int codecs, int nat_active) +{ + /* XXX Deal with Video */ + struct ooh323_pvt *p; + struct sockaddr_in them; + struct sockaddr_in us; + int mode; + + if (gH323Debug) + ast_verbose("--- ooh323_set_peer - %s\n", chan->name); + + if (!rtp) { + return 0; + } + + mode = ooh323_convertAsteriskCapToH323Cap(chan->writeformat); + p = (struct ooh323_pvt *) chan->tech_pvt; + if (!p) { + ast_log(LOG_ERROR, "No Private Structure, this is bad\n"); + return -1; + } + ast_rtp_get_peer(rtp, &them); + ast_rtp_get_us(rtp, &us); + return 0; +} + + + + +int configure_local_rtp(struct ooh323_pvt *p, ooCallData *call) +{ + struct sockaddr_in us; + ooMediaInfo mediaInfo; + int x, format = 0; + + if (gH323Debug) + ast_verbose("--- configure_local_rtp\n"); + + if (p->rtp) { + ast_rtp_codec_setpref(p->rtp, &p->prefs); + } + + /* figure out our local RTP port and tell the H.323 stack about it*/ + ast_rtp_get_us(p->rtp, &us); + + ast_copy_string(mediaInfo.lMediaIP, ast_inet_ntoa(us.sin_addr), sizeof(mediaInfo.lMediaIP)); + mediaInfo.lMediaPort = ntohs(us.sin_port); + mediaInfo.lMediaCntrlPort = mediaInfo.lMediaPort +1; + for (x = 0; 0 != (format = ast_codec_pref_index(&p->prefs, x)); x++) { + strcpy(mediaInfo.dir, "transmit"); + mediaInfo.cap = ooh323_convertAsteriskCapToH323Cap(format); + ooAddMediaInfo(call, mediaInfo); + strcpy(mediaInfo.dir, "receive"); + ooAddMediaInfo(call, mediaInfo); + if (mediaInfo.cap == OO_G729A) { + strcpy(mediaInfo.dir, "transmit"); + mediaInfo.cap = OO_G729; + ooAddMediaInfo(call, mediaInfo); + strcpy(mediaInfo.dir, "receive"); + ooAddMediaInfo(call, mediaInfo); + } + } + + if (gH323Debug) + ast_verbose("+++ configure_local_rtp\n"); + + return 1; +} + +void setup_rtp_connection(ooCallData *call, const char *remoteIp, + int remotePort) +{ + struct ooh323_pvt *p = NULL; + struct sockaddr_in them; + + if (gH323Debug) + ast_verbose("--- setup_rtp_connection\n"); + + /* Find the call or allocate a private structure if call not found */ + p = find_call(call); + + if (!p) { + ast_log(LOG_ERROR, "Something is wrong: rtp\n"); + return; + } + + them.sin_family = AF_INET; + them.sin_addr.s_addr = inet_addr(remoteIp); /* only works for IPv4 */ + them.sin_port = htons(remotePort); + ast_rtp_set_peer(p->rtp, &them); + + if (gH323Debug) { + ast_verbose("+++ setup_rtp_connection\n"); + } + + return; +} + +void close_rtp_connection(ooCallData *call) +{ + struct ooh323_pvt *p = NULL; + + if (gH323Debug) { + ast_verbose("--- close_rtp_connection\n"); + } + + p = find_call(call); + if (!p) { + ast_log(LOG_ERROR, "Couldn't find matching call to close rtp connection\n"); + return; + } + ast_mutex_lock(&p->lock); + if (p->rtp) { + ast_rtp_stop(p->rtp); + } + ast_mutex_unlock(&p->lock); + + if (gH323Debug) { + ast_verbose("+++ close_rtp_connection\n"); + } + + return; +} + + +int update_our_aliases(ooCallData *call, struct ooh323_pvt *p) +{ + int updated = -1; + ooAliases *psAlias = NULL; + + if (!call->ourAliases) + return updated; + for (psAlias = call->ourAliases; psAlias; psAlias = psAlias->next) { + if (psAlias->type == T_H225AliasAddress_h323_ID) { + ast_copy_string(p->callee_h323id, psAlias->value, sizeof(p->callee_h323id)); + updated = 1; + } + if (psAlias->type == T_H225AliasAddress_dialedDigits) { + ast_copy_string(p->callee_dialedDigits, psAlias->value, sizeof(p->callee_dialedDigits)); + updated = 1; + } + if (psAlias->type == T_H225AliasAddress_url_ID) { + ast_copy_string(p->callee_url, psAlias->value, sizeof(p->callee_url)); + updated = 1; + } + if (psAlias->type == T_H225AliasAddress_email_ID) { + ast_copy_string(p->callee_email, psAlias->value, sizeof(p->callee_email)); + updated = 1; + } + } + return updated; +} + +struct ast_frame *ooh323_rtp_read(struct ast_channel *ast, struct ooh323_pvt *p) +{ + /* Retrieve audio/etc from channel. Assumes p->lock is already held. */ + struct ast_frame *f; + static struct ast_frame null_frame = { AST_FRAME_NULL, }; + switch (ast->fdno) { + case 0: + f = ast_rtp_read(p->rtp); /* RTP Audio */ + break; + case 1: + f = ast_rtcp_read(p->rtp); /* RTCP Control Channel */ + break; + case 2: + f = ast_rtp_read(p->vrtp); /* RTP Video */ + break; + case 3: + f = ast_rtcp_read(p->vrtp); /* RTCP Control Channel for video */ + break; + default: + f = &null_frame; + } + /* Don't send RFC2833 if we're not supposed to */ + if (f && (f->frametype == AST_FRAME_DTMF) && !(p->dtmfmode & H323_DTMF_RFC2833)) { + return &null_frame; + } + if (p->owner) { + /* We already hold the channel lock */ + if (f->frametype == AST_FRAME_VOICE) { + if (f->subclass != p->owner->nativeformats) { + ast_debug(1, "Oooh, format changed to %d\n", f->subclass); + p->owner->nativeformats = f->subclass; + ast_set_read_format(p->owner, p->owner->readformat); + ast_set_write_format(p->owner, p->owner->writeformat); + } + if ((p->dtmfmode & H323_DTMF_INBAND) && p->vad) { + f = ast_dsp_process(p->owner, p->vad, f); + if (f && (f->frametype == AST_FRAME_DTMF)) { + ast_debug(1, "* Detected inband DTMF '%c'\n", f->subclass); + } + } + } + } + return f; +} + + +int ooh323_convert_hangupcause_asteriskToH323(int cause) +{ + switch (cause) { + case AST_CAUSE_CALL_REJECTED: + return OO_REASON_REMOTE_REJECTED; + case AST_CAUSE_UNALLOCATED: + return OO_REASON_NOUSER; + case AST_CAUSE_BUSY: + return OO_REASON_REMOTE_BUSY; + case AST_CAUSE_BEARERCAPABILITY_NOTAVAIL: + return OO_REASON_NOCOMMON_CAPABILITIES; + case AST_CAUSE_CONGESTION: + return OO_REASON_REMOTE_BUSY; + case AST_CAUSE_NO_ANSWER: + return OO_REASON_REMOTE_NOANSWER; + case AST_CAUSE_NORMAL: + return OO_REASON_REMOTE_CLEARED; + case AST_CAUSE_FAILURE: + default: + return OO_REASON_UNKNOWN; + } + + return 0; +} + +int ooh323_convert_hangupcause_h323ToAsterisk(int cause) +{ + switch (cause) { + case OO_REASON_REMOTE_REJECTED: + return AST_CAUSE_CALL_REJECTED; + case OO_REASON_NOUSER: + return AST_CAUSE_UNALLOCATED; + case OO_REASON_REMOTE_BUSY: + case OO_REASON_LOCAL_BUSY: + return AST_CAUSE_BUSY; + case OO_REASON_NOCOMMON_CAPABILITIES: /* No codecs approved */ + return AST_CAUSE_BEARERCAPABILITY_NOTAVAIL; + case OO_REASON_REMOTE_CONGESTED: + case OO_REASON_LOCAL_CONGESTED: + return AST_CAUSE_CONGESTION; + case OO_REASON_REMOTE_NOANSWER: + return AST_CAUSE_NO_ANSWER; + case OO_REASON_UNKNOWN: + case OO_REASON_INVALIDMESSAGE: + case OO_REASON_TRANSPORTFAILURE: + return AST_CAUSE_FAILURE; + case OO_REASON_REMOTE_CLEARED: + return AST_CAUSE_NORMAL; + default: + return AST_CAUSE_NORMAL; + } + /* Never reached */ + return 0; +} + +#if 0 +void ast_ooh323c_exit() +{ + ooGkClientDestroy(); +} +#endif + +AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "Objective Systems H323 Channel"); diff --git a/addons/chan_ooh323.h b/addons/chan_ooh323.h new file mode 100644 index 000000000..bce62bd11 --- /dev/null +++ b/addons/chan_ooh323.h @@ -0,0 +1,113 @@ +/* + * 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. + * + *****************************************************************************/ +#ifndef _OO_CHAN_H323_H_ +#define _OO_CHAN_H323_H_ + +#include +#undef PACKAGE_NAME +#undef PACKAGE_TARNAME +#undef PACKAGE_VERSION +#undef PACKAGE_STRING +#undef PACKAGE_BUGREPORT + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include "ootypes.h" +#include "ooCapability.h" +#include "oochannels.h" +#include "ooh323ep.h" +#include "ooh323cDriver.h" +#include "ooCalls.h" +#include "ooq931.h" +#include "ooStackCmds.h" +#include "ooCapability.h" +#include "ooGkClient.h" + + +struct ooh323_pvt; +struct ooh323_user; +struct ooh323_peer; +/* Helper functions */ +struct ooh323_user *find_user(const char * name, const char *ip); +struct ooh323_peer *find_peer(const char * name, int port); +void ooh323_delete_peer(struct ooh323_peer *peer); + +int delete_users(void); +int delete_peers(void); + +int ooh323_destroy(struct ooh323_pvt *p); +int reload_config(int reload); +int restart_monitor(void); + +int configure_local_rtp(struct ooh323_pvt *p, ooCallData* call); +void setup_rtp_connection(ooCallData *call, const char *remoteIp, + int remotePort); +void close_rtp_connection(ooCallData *call); +struct ast_frame *ooh323_rtp_read + (struct ast_channel *ast, struct ooh323_pvt *p); + +void ooh323_set_write_format(ooCallData *call, int fmt); +void ooh323_set_read_format(ooCallData *call, int fmt); + +int ooh323_update_capPrefsOrderForCall + (ooCallData *call, struct ast_codec_pref *prefs); + +int ooh323_convertAsteriskCapToH323Cap(int cap); + +int ooh323_convert_hangupcause_asteriskToH323(int cause); +int ooh323_convert_hangupcause_h323ToAsterisk(int cause); +int update_our_aliases(ooCallData *call, struct ooh323_pvt *p); + +/* h323 msg callbacks */ +int ooh323_onReceivedSetup(ooCallData *call, Q931Message *pmsg); +int ooh323_onReceivedDigit(OOH323CallData *call, const char* digit); +#endif diff --git a/addons/format_mp3.c b/addons/format_mp3.c new file mode 100644 index 000000000..2c27243e2 --- /dev/null +++ b/addons/format_mp3.c @@ -0,0 +1,336 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Anthony Minessale + * + * Derived from other asterisk sound formats by + * Mark Spencer + * + * Thanks to mpglib from http://www.mpg123.org/ + * and Chris Stenton [jacs@gnome.co.uk] + * for coding the ability to play stereo and non-8khz files + + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! + * \file + * \brief MP3 Format Handler + * \ingroup formats + */ + +/*** MODULEINFO + no + ***/ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include "mp3/mpg123.h" +#include "mp3/mpglib.h" + +#include "asterisk/module.h" +#include "asterisk/mod_format.h" +#include "asterisk/logger.h" + +#define MP3_BUFLEN 320 +#define MP3_SCACHE 16384 +#define MP3_DCACHE 8192 + +struct mp3_private { + char waste[AST_FRIENDLY_OFFSET]; /* Buffer for sending frames, etc */ + char empty; /* Empty character */ + int lasttimeout; + int maxlen; + struct timeval last; + struct mpstr mp; + char sbuf[MP3_SCACHE]; + char dbuf[MP3_DCACHE]; + int buflen; + int sbuflen; + int dbuflen; + int dbufoffset; + int sbufoffset; + int lastseek; + int offset; + long seek; +}; + +static const char name[] = "mp3"; + +#define BLOCKSIZE 160 +#define OUTSCALE 4096 + +#define GAIN -4 /* 2^GAIN is the multiple to increase the volume by */ + +#if __BYTE_ORDER == __LITTLE_ENDIAN +#define htoll(b) (b) +#define htols(b) (b) +#define ltohl(b) (b) +#define ltohs(b) (b) +#else +#if __BYTE_ORDER == __BIG_ENDIAN +#define htoll(b) \ + (((((b) ) & 0xFF) << 24) | \ + ((((b) >> 8) & 0xFF) << 16) | \ + ((((b) >> 16) & 0xFF) << 8) | \ + ((((b) >> 24) & 0xFF) )) +#define htols(b) \ + (((((b) ) & 0xFF) << 8) | \ + ((((b) >> 8) & 0xFF) )) +#define ltohl(b) htoll(b) +#define ltohs(b) htols(b) +#else +#error "Endianess not defined" +#endif +#endif + + +static int mp3_open(struct ast_filestream *s) +{ + struct mp3_private *p = s->_private; + + InitMP3(&p->mp, OUTSCALE); + p->dbuflen = 0; + s->fr.data.ptr = s->buf; + s->fr.frametype = AST_FRAME_VOICE; + s->fr.subclass = AST_FORMAT_SLINEAR; + /* datalen will vary for each frame */ + s->fr.src = name; + s->fr.mallocd = 0; + p->offset = 0; + return 0; +} + + +static void mp3_close(struct ast_filestream *s) +{ + struct mp3_private *p = s->_private; + + ExitMP3(&p->mp); + return; +} + +static int mp3_squeue(struct ast_filestream *s) +{ + struct mp3_private *p = s->_private; + int res=0; + + p->lastseek = ftell(s->f); + p->sbuflen = fread(p->sbuf, 1, MP3_SCACHE, s->f); + if(p->sbuflen < 0) { + ast_log(LOG_WARNING, "Short read (%d) (%s)!\n", p->sbuflen, strerror(errno)); + return -1; + } + res = decodeMP3(&p->mp,p->sbuf,p->sbuflen,p->dbuf,MP3_DCACHE,&p->dbuflen); + if(res != MP3_OK) + return -1; + p->sbuflen -= p->dbuflen; + p->dbufoffset = 0; + return 0; +} + +static int mp3_dqueue(struct ast_filestream *s) +{ + struct mp3_private *p = s->_private; + int res=0; + + if((res = decodeMP3(&p->mp,NULL,0,p->dbuf,MP3_DCACHE,&p->dbuflen)) == MP3_OK) { + p->sbuflen -= p->dbuflen; + p->dbufoffset = 0; + } + return res; +} + +static int mp3_queue(struct ast_filestream *s) +{ + struct mp3_private *p = s->_private; + int res = 0, bytes = 0; + + if(p->seek) { + ExitMP3(&p->mp); + InitMP3(&p->mp, OUTSCALE); + fseek(s->f, 0, SEEK_SET); + p->sbuflen = p->dbuflen = p->offset = 0; + while(p->offset < p->seek) { + if(mp3_squeue(s)) + return -1; + while(p->offset < p->seek && ((res = mp3_dqueue(s))) == MP3_OK) { + for(bytes = 0 ; bytes < p->dbuflen ; bytes++) { + p->dbufoffset++; + p->offset++; + if(p->offset >= p->seek) + break; + } + } + if(res == MP3_ERR) + return -1; + } + + p->seek = 0; + return 0; + } + if(p->dbuflen == 0) { + if(p->sbuflen) { + res = mp3_dqueue(s); + if(res == MP3_ERR) + return -1; + } + if(! p->sbuflen || res != MP3_OK) { + if(mp3_squeue(s)) + return -1; + } + + } + + return 0; +} + +static struct ast_frame *mp3_read(struct ast_filestream *s, int *whennext) +{ + + struct mp3_private *p = s->_private; + int delay =0; + int save=0; + + /* Send a frame from the file to the appropriate channel */ + + if(mp3_queue(s)) + return NULL; + + if(p->dbuflen) { + for(p->buflen=0; p->buflen < MP3_BUFLEN && p->buflen < p->dbuflen; p->buflen++) { + s->buf[p->buflen] = p->dbuf[p->buflen+p->dbufoffset]; + p->sbufoffset++; + } + p->dbufoffset += p->buflen; + p->dbuflen -= p->buflen; + + if(p->buflen < MP3_BUFLEN) { + if(mp3_queue(s)) + return NULL; + + for(save = p->buflen; p->buflen < MP3_BUFLEN; p->buflen++) { + s->buf[p->buflen] = p->dbuf[(p->buflen-save)+p->dbufoffset]; + p->sbufoffset++; + } + p->dbufoffset += (MP3_BUFLEN - save); + p->dbuflen -= (MP3_BUFLEN - save); + + } + + } + + p->offset += p->buflen; + delay = p->buflen/2; + s->fr.frametype = AST_FRAME_VOICE; + s->fr.subclass = AST_FORMAT_SLINEAR; + s->fr.offset = AST_FRIENDLY_OFFSET; + s->fr.datalen = p->buflen; + s->fr.data.ptr = s->buf; + s->fr.mallocd = 0; + s->fr.samples = delay; + *whennext = delay; + return &s->fr; +} + + +static int mp3_write(struct ast_filestream *fs, struct ast_frame *f) +{ + ast_log(LOG_ERROR,"I Can't write MP3 only read them.\n"); + return -1; + +} + + +static int mp3_seek(struct ast_filestream *s, off_t sample_offset, int whence) +{ + struct mp3_private *p = s->_private; + off_t min,max,cur; + long offset=0,samples; + samples = sample_offset * 2; + + min = 0; + fseek(s->f, 0, SEEK_END); + max = ftell(s->f) * 100; + cur = p->offset; + + if (whence == SEEK_SET) + offset = samples + min; + else if (whence == SEEK_CUR || whence == SEEK_FORCECUR) + offset = samples + cur; + else if (whence == SEEK_END) + offset = max - samples; + if (whence != SEEK_FORCECUR) { + offset = (offset > max)?max:offset; + } + + p->seek = offset; + return p->seek; + +} + +static int mp3_rewrite(struct ast_filestream *s, const char *comment) +{ + ast_log(LOG_ERROR,"I Can't write MP3 only read them.\n"); + return -1; +} + +static int mp3_trunc(struct ast_filestream *s) +{ + + ast_log(LOG_ERROR,"I Can't write MP3 only read them.\n"); + return -1; +} + +static off_t mp3_tell(struct ast_filestream *s) +{ + struct mp3_private *p = s->_private; + + return p->offset/2; +} + +static char *mp3_getcomment(struct ast_filestream *s) +{ + return NULL; +} + +static const struct ast_format mp3_f = { + .name = "mp3", + .exts = "mp3", + .format = AST_FORMAT_SLINEAR, + .open = mp3_open, + .write = mp3_write, + .rewrite = mp3_rewrite, + .seek = mp3_seek, + .trunc = mp3_trunc, + .tell = mp3_tell, + .read = mp3_read, + .close = mp3_close, + .getcomment = mp3_getcomment, + .buf_size = MP3_BUFLEN + AST_FRIENDLY_OFFSET, + .desc_size = sizeof(struct mp3_private), +}; + + +static int load_module(void) +{ + InitMP3Constants(); + return ast_format_register(&mp3_f); +} + +static int unload_module(void) +{ + return ast_format_unregister(name); +} + +AST_MODULE_INFO_STANDARD(ASTERISK_GPL_KEY, "MP3 format [Any rate but 8000hz mono is optimal]"); diff --git a/addons/mp3/MPGLIB_README b/addons/mp3/MPGLIB_README new file mode 100644 index 000000000..3c5f33749 --- /dev/null +++ b/addons/mp3/MPGLIB_README @@ -0,0 +1,39 @@ +MP3 library +----------- +Version 0.2 + +This decoder is a 'light' version (thrown out all unnecessay parts) +from the mpg123 package. I made this for a company. + +Currently only Layer3 is enabled to save some space. Layer1,2 isn't +tested at all. The interface will not change significantly. +A backport to the mpg123 package is planed. + +comiled and tested only on Solaris 2.6 +main.c contains a simple demo application for library. + +COPYING: you may use this source under GPL terms! + +PLEASE NOTE: This software may contain patented alogrithm (at least + patented in some countries). It may be not allowed to sell/use products + based on this source code in these countries. Check this out first! + +COPYRIGHT of MP3 music: + Please note, that the duplicating of copyrighted music without explicit + permission violates the rights of the owner. + +SENDING PATCHES: + Maybe I change the copyright policy (ie some kind of more free BSD licencse). + Please consider this when sending patches/changes. + I also want to have the freedom to sell the code to companies that + can not use the code under GPL. So, if you send me significant patches, + I need your explicit permission to do this. Of course, there will also + be the GPLed open source version of the 100% same code. + For the case you cannot accept this: the code is GPL, it's your freedom + to distribute your changes again under GPL. + +FEEDBACK: + I'm interessted to here from you, when you use this package as part + of another project. + + diff --git a/addons/mp3/MPGLIB_TODO b/addons/mp3/MPGLIB_TODO new file mode 100644 index 000000000..403711010 --- /dev/null +++ b/addons/mp3/MPGLIB_TODO @@ -0,0 +1,2 @@ + +apply 'VBR' bugfix diff --git a/addons/mp3/Makefile b/addons/mp3/Makefile new file mode 100644 index 000000000..7cd0b58d1 --- /dev/null +++ b/addons/mp3/Makefile @@ -0,0 +1,24 @@ +MP3OBJS=common.o dct64_i386.o decode_ntom.o layer3.o tabinit.o interface.o + +ifeq ($(OSARCH),FreeBSD) +OSVERSION=$(shell make -V OSVERSION -f /usr/share/mk/bsd.port.subdir.mk) +CFLAGS+=$(if $(OSVERSION)<500016,-D_THREAD_SAFE) +LIBS+=$(if $(OSVERSION)<502102,-lc_r,-pthread) +INCLUDE+=-I/usr/local/include +CFLAGS+=$(shell if [ -d /usr/local/include/spandsp ]; then echo "-I/usr/local/include/spandsp"; fi) +endif # FreeBSD + +ifeq ($(OSARCH),NetBSD) +CFLAGS+=-pthread +INCLUDE+=-I/usr/local/include +endif + +ifeq ($(OSARCH),OpenBSD) +CFLAGS+=-pthread +endif + +all: $(MP3OBJS) + +clean: + rm -f *.o *.so *~ + rm -f .*.o.d diff --git a/addons/mp3/README b/addons/mp3/README new file mode 100644 index 000000000..9263da487 --- /dev/null +++ b/addons/mp3/README @@ -0,0 +1,24 @@ +This is a module for asterisk to play mp3 natively. +They *SHOULD* be already at 8khz and *SHOULD* be mono. +otherwise they will be consuming CPU alot more than need be. + +Convert them to 8k mono like this: +lame -q -p --mp3input -a --preset 8 in.mp3 8kout.mp3 + +just run +# make clean install +to install + +or +# make clean autoload +to install and autoload at the same time + + +Comments or improvements +Anthony Minessale + +Donations Welcomed at paypal:jillkm3@yahoo.com + + + + diff --git a/addons/mp3/common.c b/addons/mp3/common.c new file mode 100644 index 000000000..d8db2a3d2 --- /dev/null +++ b/addons/mp3/common.c @@ -0,0 +1,267 @@ +#include +#include + +#include +#include +#include + +#include +#include +#include + +#include "mpg123.h" +#include "mpglib.h" + +struct parameter param = { 1 , 1 , 0 , 0 }; + +int tabsel_123[2][3][16] = { + { {0,32,64,96,128,160,192,224,256,288,320,352,384,416,448,}, + {0,32,48,56, 64, 80, 96,112,128,160,192,224,256,320,384,}, + {0,32,40,48, 56, 64, 80, 96,112,128,160,192,224,256,320,} }, + + { {0,32,48,56,64,80,96,112,128,144,160,176,192,224,256,}, + {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,}, + {0,8,16,24,32,40,48,56,64,80,96,112,128,144,160,} } +}; + +long freqs[9] = { 44100, 48000, 32000, + 22050, 24000, 16000 , + 11025 , 12000 , 8000 }; + + +#if 0 +static void get_II_stuff(struct frame *fr) +{ + static int translate[3][2][16] = + { { { 0,2,2,2,2,2,2,0,0,0,1,1,1,1,1,0 } , + { 0,2,2,0,0,0,1,1,1,1,1,1,1,1,1,0 } } , + { { 0,2,2,2,2,2,2,0,0,0,0,0,0,0,0,0 } , + { 0,2,2,0,0,0,0,0,0,0,0,0,0,0,0,0 } } , + { { 0,3,3,3,3,3,3,0,0,0,1,1,1,1,1,0 } , + { 0,3,3,0,0,0,1,1,1,1,1,1,1,1,1,0 } } }; + + int table,sblim; + static struct al_table *tables[5] = + { alloc_0, alloc_1, alloc_2, alloc_3 , alloc_4 }; + static int sblims[5] = { 27 , 30 , 8, 12 , 30 }; + + if(fr->lsf) + table = 4; + else + table = translate[fr->sampling_frequency][2-fr->stereo][fr->bitrate_index]; + sblim = sblims[table]; + + fr->alloc = tables[table]; + fr->II_sblimit = sblim; +} +#endif + +#define HDRCMPMASK 0xfffffd00 + +#if 0 +int head_check(unsigned long head) +{ + if( (head & 0xffe00000) != 0xffe00000) + return FALSE; + if(!((head>>17)&3)) + return FALSE; + if( ((head>>12)&0xf) == 0xf) + return FALSE; + if( ((head>>10)&0x3) == 0x3 ) + return FALSE; + return TRUE; +} +#endif + + +/* + * the code a header and write the information + * into the frame structure + */ +int decode_header(struct frame *fr,unsigned long newhead) +{ + if( newhead & (1<<20) ) { + fr->lsf = (newhead & (1<<19)) ? 0x0 : 0x1; + fr->mpeg25 = 0; + } + else { + fr->lsf = 1; + fr->mpeg25 = 1; + } + + fr->lay = 4-((newhead>>17)&3); + if( ((newhead>>10)&0x3) == 0x3) { + ast_log(LOG_WARNING,"Stream error\n"); + return (0); + } + if(fr->mpeg25) { + fr->sampling_frequency = 6 + ((newhead>>10)&0x3); + } + else + fr->sampling_frequency = ((newhead>>10)&0x3) + (fr->lsf*3); + fr->error_protection = ((newhead>>16)&0x1)^0x1; + + if(fr->mpeg25) /* allow Bitrate change for 2.5 ... */ + fr->bitrate_index = ((newhead>>12)&0xf); + + fr->bitrate_index = ((newhead>>12)&0xf); + fr->padding = ((newhead>>9)&0x1); + fr->extension = ((newhead>>8)&0x1); + fr->mode = ((newhead>>6)&0x3); + fr->mode_ext = ((newhead>>4)&0x3); + fr->copyright = ((newhead>>3)&0x1); + fr->original = ((newhead>>2)&0x1); + fr->emphasis = newhead & 0x3; + + fr->stereo = (fr->mode == MPG_MD_MONO) ? 1 : 2; + + if(!fr->bitrate_index) + { + ast_log(LOG_WARNING,"Free format not supported.\n"); + return (0); + } + + switch(fr->lay) + { + case 1: +#if 0 + fr->do_layer = do_layer1; + fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? + (fr->mode_ext<<2)+4 : 32; + fr->framesize = (long) tabsel_123[fr->lsf][0][fr->bitrate_index] * 12000; + fr->framesize /= freqs[fr->sampling_frequency]; + fr->framesize = ((fr->framesize+fr->padding)<<2)-4; +#else + ast_log(LOG_WARNING,"Layer 1 not supported!\n"); +#endif + break; + case 2: +#if 0 + fr->do_layer = do_layer2; + get_II_stuff(fr); + fr->jsbound = (fr->mode == MPG_MD_JOINT_STEREO) ? + (fr->mode_ext<<2)+4 : fr->II_sblimit; + fr->framesize = (long) tabsel_123[fr->lsf][1][fr->bitrate_index] * 144000; + fr->framesize /= freqs[fr->sampling_frequency]; + fr->framesize += fr->padding - 4; +#else + ast_log(LOG_WARNING,"Layer 2 not supported!\n"); +#endif + break; + case 3: +#if 0 + fr->do_layer = do_layer3; + if(fr->lsf) + ssize = (fr->stereo == 1) ? 9 : 17; + else + ssize = (fr->stereo == 1) ? 17 : 32; +#endif + +#if 0 + if(fr->error_protection) + ssize += 2; +#endif + fr->framesize = (long) tabsel_123[fr->lsf][2][fr->bitrate_index] * 144000; + fr->framesize /= freqs[fr->sampling_frequency]<<(fr->lsf); + fr->framesize = fr->framesize + fr->padding - 4; + break; + default: + ast_log(LOG_WARNING,"Sorry, unknown layer type.\n"); + return (0); + } + return 1; +} + +#if 0 +void print_header(struct frame *fr) +{ + static char *modes[4] = { "Stereo", "Joint-Stereo", "Dual-Channel", "Single-Channel" }; + static char *layers[4] = { "Unknown" , "I", "II", "III" }; + + ast_log(LOG_WARNING,"MPEG %s, Layer: %s, Freq: %ld, mode: %s, modext: %d, BPF : %d\n", + fr->mpeg25 ? "2.5" : (fr->lsf ? "2.0" : "1.0"), + layers[fr->lay],freqs[fr->sampling_frequency], + modes[fr->mode],fr->mode_ext,fr->framesize+4); + ast_log(LOG_WARNING,"Channels: %d, copyright: %s, original: %s, CRC: %s, emphasis: %d.\n", + fr->stereo,fr->copyright?"Yes":"No", + fr->original?"Yes":"No",fr->error_protection?"Yes":"No", + fr->emphasis); + ast_log(LOG_WARNING,"Bitrate: %d Kbits/s, Extension value: %d\n", + tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index],fr->extension); +} + +void print_header_compact(struct frame *fr) +{ + static char *modes[4] = { "stereo", "joint-stereo", "dual-channel", "mono" }; + static char *layers[4] = { "Unknown" , "I", "II", "III" }; + + ast_log(LOG_WARNING,"MPEG %s layer %s, %d kbit/s, %ld Hz %s\n", + fr->mpeg25 ? "2.5" : (fr->lsf ? "2.0" : "1.0"), + layers[fr->lay], + tabsel_123[fr->lsf][fr->lay-1][fr->bitrate_index], + freqs[fr->sampling_frequency], modes[fr->mode]); +} + +#endif + +unsigned int getbits(struct mpstr *mp, int number_of_bits) +{ + unsigned long rval; + + if(!number_of_bits) + return 0; + + { + rval = (mp->worksample).wordpointer[0]; + rval <<= 8; + rval |= (mp->worksample).wordpointer[1]; + rval <<= 8; + rval |= (mp->worksample).wordpointer[2]; + rval <<= (mp->worksample).bitindex; + rval &= 0xffffff; + + (mp->worksample).bitindex += number_of_bits; + + rval >>= (24-number_of_bits); + + (mp->worksample).wordpointer += ((mp->worksample).bitindex>>3); + (mp->worksample).bitindex &= 7; + } + return rval; +} + +unsigned int getbits_fast(struct mpstr *mp, int number_of_bits) +{ + unsigned long rval; + + { + rval = (mp->worksample).wordpointer[0]; + rval <<= 8; + rval |= (mp->worksample).wordpointer[1]; + rval <<= (mp->worksample).bitindex; + rval &= 0xffff; + (mp->worksample).bitindex += number_of_bits; + + rval >>= (16-number_of_bits); + + (mp->worksample).wordpointer += ((mp->worksample).bitindex>>3); + (mp->worksample).bitindex &= 7; + } + return rval; +} + +unsigned int get1bit(struct mpstr *mp) +{ + unsigned char rval; + + rval = *((mp->worksample).wordpointer) << (mp->worksample).bitindex; + + (mp->worksample).bitindex++; + (mp->worksample).wordpointer += ((mp->worksample).bitindex>>3); + (mp->worksample).bitindex &= 7; + + return rval>>7; +} + + + diff --git a/addons/mp3/dct64_i386.c b/addons/mp3/dct64_i386.c new file mode 100644 index 000000000..c6b5d886c --- /dev/null +++ b/addons/mp3/dct64_i386.c @@ -0,0 +1,335 @@ + +/* + * Discrete Cosine Tansform (DCT) for subband synthesis + * optimized for machines with no auto-increment. + * The performance is highly compiler dependend. Maybe + * the dct64.c version for 'normal' processor may be faster + * even for Intel processors. + */ + +#include "mpg123.h" + +/* + * the call via dct64 is a trick to force GCC to use + * (new) registers for the b1,b2 pointer to the bufs[xx] field + */ +void dct64(real *a,real *b,real *c); + +static void dct64_1(real *out0,real *out1,real *b1,real *b2,real *samples) +{ + { + register real *costab = pnts[0]; + + b1[0x00] = samples[0x00] + samples[0x1F]; + b1[0x01] = samples[0x01] + samples[0x1E]; + b1[0x1F] = (samples[0x00] - samples[0x1F]) * costab[0x0]; + b1[0x1E] = (samples[0x01] - samples[0x1E]) * costab[0x1]; + + b1[0x02] = samples[0x02] + samples[0x1D]; + b1[0x03] = samples[0x03] + samples[0x1C]; + b1[0x1D] = (samples[0x02] - samples[0x1D]) * costab[0x2]; + b1[0x1C] = (samples[0x03] - samples[0x1C]) * costab[0x3]; + + b1[0x04] = samples[0x04] + samples[0x1B]; + b1[0x05] = samples[0x05] + samples[0x1A]; + b1[0x1B] = (samples[0x04] - samples[0x1B]) * costab[0x4]; + b1[0x1A] = (samples[0x05] - samples[0x1A]) * costab[0x5]; + + b1[0x06] = samples[0x06] + samples[0x19]; + b1[0x07] = samples[0x07] + samples[0x18]; + b1[0x19] = (samples[0x06] - samples[0x19]) * costab[0x6]; + b1[0x18] = (samples[0x07] - samples[0x18]) * costab[0x7]; + + b1[0x08] = samples[0x08] + samples[0x17]; + b1[0x09] = samples[0x09] + samples[0x16]; + b1[0x17] = (samples[0x08] - samples[0x17]) * costab[0x8]; + b1[0x16] = (samples[0x09] - samples[0x16]) * costab[0x9]; + + b1[0x0A] = samples[0x0A] + samples[0x15]; + b1[0x0B] = samples[0x0B] + samples[0x14]; + b1[0x15] = (samples[0x0A] - samples[0x15]) * costab[0xA]; + b1[0x14] = (samples[0x0B] - samples[0x14]) * costab[0xB]; + + b1[0x0C] = samples[0x0C] + samples[0x13]; + b1[0x0D] = samples[0x0D] + samples[0x12]; + b1[0x13] = (samples[0x0C] - samples[0x13]) * costab[0xC]; + b1[0x12] = (samples[0x0D] - samples[0x12]) * costab[0xD]; + + b1[0x0E] = samples[0x0E] + samples[0x11]; + b1[0x0F] = samples[0x0F] + samples[0x10]; + b1[0x11] = (samples[0x0E] - samples[0x11]) * costab[0xE]; + b1[0x10] = (samples[0x0F] - samples[0x10]) * costab[0xF]; + + } + + + { + register real *costab = pnts[1]; + + b2[0x00] = b1[0x00] + b1[0x0F]; + b2[0x01] = b1[0x01] + b1[0x0E]; + b2[0x0F] = (b1[0x00] - b1[0x0F]) * costab[0]; + b2[0x0E] = (b1[0x01] - b1[0x0E]) * costab[1]; + + b2[0x02] = b1[0x02] + b1[0x0D]; + b2[0x03] = b1[0x03] + b1[0x0C]; + b2[0x0D] = (b1[0x02] - b1[0x0D]) * costab[2]; + b2[0x0C] = (b1[0x03] - b1[0x0C]) * costab[3]; + + b2[0x04] = b1[0x04] + b1[0x0B]; + b2[0x05] = b1[0x05] + b1[0x0A]; + b2[0x0B] = (b1[0x04] - b1[0x0B]) * costab[4]; + b2[0x0A] = (b1[0x05] - b1[0x0A]) * costab[5]; + + b2[0x06] = b1[0x06] + b1[0x09]; + b2[0x07] = b1[0x07] + b1[0x08]; + b2[0x09] = (b1[0x06] - b1[0x09]) * costab[6]; + b2[0x08] = (b1[0x07] - b1[0x08]) * costab[7]; + + /* */ + + b2[0x10] = b1[0x10] + b1[0x1F]; + b2[0x11] = b1[0x11] + b1[0x1E]; + b2[0x1F] = (b1[0x1F] - b1[0x10]) * costab[0]; + b2[0x1E] = (b1[0x1E] - b1[0x11]) * costab[1]; + + b2[0x12] = b1[0x12] + b1[0x1D]; + b2[0x13] = b1[0x13] + b1[0x1C]; + b2[0x1D] = (b1[0x1D] - b1[0x12]) * costab[2]; + b2[0x1C] = (b1[0x1C] - b1[0x13]) * costab[3]; + + b2[0x14] = b1[0x14] + b1[0x1B]; + b2[0x15] = b1[0x15] + b1[0x1A]; + b2[0x1B] = (b1[0x1B] - b1[0x14]) * costab[4]; + b2[0x1A] = (b1[0x1A] - b1[0x15]) * costab[5]; + + b2[0x16] = b1[0x16] + b1[0x19]; + b2[0x17] = b1[0x17] + b1[0x18]; + b2[0x19] = (b1[0x19] - b1[0x16]) * costab[6]; + b2[0x18] = (b1[0x18] - b1[0x17]) * costab[7]; + } + + { + register real *costab = pnts[2]; + + b1[0x00] = b2[0x00] + b2[0x07]; + b1[0x07] = (b2[0x00] - b2[0x07]) * costab[0]; + b1[0x01] = b2[0x01] + b2[0x06]; + b1[0x06] = (b2[0x01] - b2[0x06]) * costab[1]; + b1[0x02] = b2[0x02] + b2[0x05]; + b1[0x05] = (b2[0x02] - b2[0x05]) * costab[2]; + b1[0x03] = b2[0x03] + b2[0x04]; + b1[0x04] = (b2[0x03] - b2[0x04]) * costab[3]; + + b1[0x08] = b2[0x08] + b2[0x0F]; + b1[0x0F] = (b2[0x0F] - b2[0x08]) * costab[0]; + b1[0x09] = b2[0x09] + b2[0x0E]; + b1[0x0E] = (b2[0x0E] - b2[0x09]) * costab[1]; + b1[0x0A] = b2[0x0A] + b2[0x0D]; + b1[0x0D] = (b2[0x0D] - b2[0x0A]) * costab[2]; + b1[0x0B] = b2[0x0B] + b2[0x0C]; + b1[0x0C] = (b2[0x0C] - b2[0x0B]) * costab[3]; + + b1[0x10] = b2[0x10] + b2[0x17]; + b1[0x17] = (b2[0x10] - b2[0x17]) * costab[0]; + b1[0x11] = b2[0x11] + b2[0x16]; + b1[0x16] = (b2[0x11] - b2[0x16]) * costab[1]; + b1[0x12] = b2[0x12] + b2[0x15]; + b1[0x15] = (b2[0x12] - b2[0x15]) * costab[2]; + b1[0x13] = b2[0x13] + b2[0x14]; + b1[0x14] = (b2[0x13] - b2[0x14]) * costab[3]; + + b1[0x18] = b2[0x18] + b2[0x1F]; + b1[0x1F] = (b2[0x1F] - b2[0x18]) * costab[0]; + b1[0x19] = b2[0x19] + b2[0x1E]; + b1[0x1E] = (b2[0x1E] - b2[0x19]) * costab[1]; + b1[0x1A] = b2[0x1A] + b2[0x1D]; + b1[0x1D] = (b2[0x1D] - b2[0x1A]) * costab[2]; + b1[0x1B] = b2[0x1B] + b2[0x1C]; + b1[0x1C] = (b2[0x1C] - b2[0x1B]) * costab[3]; + } + + { + register real const cos0 = pnts[3][0]; + register real const cos1 = pnts[3][1]; + + b2[0x00] = b1[0x00] + b1[0x03]; + b2[0x03] = (b1[0x00] - b1[0x03]) * cos0; + b2[0x01] = b1[0x01] + b1[0x02]; + b2[0x02] = (b1[0x01] - b1[0x02]) * cos1; + + b2[0x04] = b1[0x04] + b1[0x07]; + b2[0x07] = (b1[0x07] - b1[0x04]) * cos0; + b2[0x05] = b1[0x05] + b1[0x06]; + b2[0x06] = (b1[0x06] - b1[0x05]) * cos1; + + b2[0x08] = b1[0x08] + b1[0x0B]; + b2[0x0B] = (b1[0x08] - b1[0x0B]) * cos0; + b2[0x09] = b1[0x09] + b1[0x0A]; + b2[0x0A] = (b1[0x09] - b1[0x0A]) * cos1; + + b2[0x0C] = b1[0x0C] + b1[0x0F]; + b2[0x0F] = (b1[0x0F] - b1[0x0C]) * cos0; + b2[0x0D] = b1[0x0D] + b1[0x0E]; + b2[0x0E] = (b1[0x0E] - b1[0x0D]) * cos1; + + b2[0x10] = b1[0x10] + b1[0x13]; + b2[0x13] = (b1[0x10] - b1[0x13]) * cos0; + b2[0x11] = b1[0x11] + b1[0x12]; + b2[0x12] = (b1[0x11] - b1[0x12]) * cos1; + + b2[0x14] = b1[0x14] + b1[0x17]; + b2[0x17] = (b1[0x17] - b1[0x14]) * cos0; + b2[0x15] = b1[0x15] + b1[0x16]; + b2[0x16] = (b1[0x16] - b1[0x15]) * cos1; + + b2[0x18] = b1[0x18] + b1[0x1B]; + b2[0x1B] = (b1[0x18] - b1[0x1B]) * cos0; + b2[0x19] = b1[0x19] + b1[0x1A]; + b2[0x1A] = (b1[0x19] - b1[0x1A]) * cos1; + + b2[0x1C] = b1[0x1C] + b1[0x1F]; + b2[0x1F] = (b1[0x1F] - b1[0x1C]) * cos0; + b2[0x1D] = b1[0x1D] + b1[0x1E]; + b2[0x1E] = (b1[0x1E] - b1[0x1D]) * cos1; + } + + { + register real const cos0 = pnts[4][0]; + + b1[0x00] = b2[0x00] + b2[0x01]; + b1[0x01] = (b2[0x00] - b2[0x01]) * cos0; + b1[0x02] = b2[0x02] + b2[0x03]; + b1[0x03] = (b2[0x03] - b2[0x02]) * cos0; + b1[0x02] += b1[0x03]; + + b1[0x04] = b2[0x04] + b2[0x05]; + b1[0x05] = (b2[0x04] - b2[0x05]) * cos0; + b1[0x06] = b2[0x06] + b2[0x07]; + b1[0x07] = (b2[0x07] - b2[0x06]) * cos0; + b1[0x06] += b1[0x07]; + b1[0x04] += b1[0x06]; + b1[0x06] += b1[0x05]; + b1[0x05] += b1[0x07]; + + b1[0x08] = b2[0x08] + b2[0x09]; + b1[0x09] = (b2[0x08] - b2[0x09]) * cos0; + b1[0x0A] = b2[0x0A] + b2[0x0B]; + b1[0x0B] = (b2[0x0B] - b2[0x0A]) * cos0; + b1[0x0A] += b1[0x0B]; + + b1[0x0C] = b2[0x0C] + b2[0x0D]; + b1[0x0D] = (b2[0x0C] - b2[0x0D]) * cos0; + b1[0x0E] = b2[0x0E] + b2[0x0F]; + b1[0x0F] = (b2[0x0F] - b2[0x0E]) * cos0; + b1[0x0E] += b1[0x0F]; + b1[0x0C] += b1[0x0E]; + b1[0x0E] += b1[0x0D]; + b1[0x0D] += b1[0x0F]; + + b1[0x10] = b2[0x10] + b2[0x11]; + b1[0x11] = (b2[0x10] - b2[0x11]) * cos0; + b1[0x12] = b2[0x12] + b2[0x13]; + b1[0x13] = (b2[0x13] - b2[0x12]) * cos0; + b1[0x12] += b1[0x13]; + + b1[0x14] = b2[0x14] + b2[0x15]; + b1[0x15] = (b2[0x14] - b2[0x15]) * cos0; + b1[0x16] = b2[0x16] + b2[0x17]; + b1[0x17] = (b2[0x17] - b2[0x16]) * cos0; + b1[0x16] += b1[0x17]; + b1[0x14] += b1[0x16]; + b1[0x16] += b1[0x15]; + b1[0x15] += b1[0x17]; + + b1[0x18] = b2[0x18] + b2[0x19]; + b1[0x19] = (b2[0x18] - b2[0x19]) * cos0; + b1[0x1A] = b2[0x1A] + b2[0x1B]; + b1[0x1B] = (b2[0x1B] - b2[0x1A]) * cos0; + b1[0x1A] += b1[0x1B]; + + b1[0x1C] = b2[0x1C] + b2[0x1D]; + b1[0x1D] = (b2[0x1C] - b2[0x1D]) * cos0; + b1[0x1E] = b2[0x1E] + b2[0x1F]; + b1[0x1F] = (b2[0x1F] - b2[0x1E]) * cos0; + b1[0x1E] += b1[0x1F]; + b1[0x1C] += b1[0x1E]; + b1[0x1E] += b1[0x1D]; + b1[0x1D] += b1[0x1F]; + } + + out0[0x10*16] = b1[0x00]; + out0[0x10*12] = b1[0x04]; + out0[0x10* 8] = b1[0x02]; + out0[0x10* 4] = b1[0x06]; + out0[0x10* 0] = b1[0x01]; + out1[0x10* 0] = b1[0x01]; + out1[0x10* 4] = b1[0x05]; + out1[0x10* 8] = b1[0x03]; + out1[0x10*12] = b1[0x07]; + +#if 1 + out0[0x10*14] = b1[0x08] + b1[0x0C]; + out0[0x10*10] = b1[0x0C] + b1[0x0a]; + out0[0x10* 6] = b1[0x0A] + b1[0x0E]; + out0[0x10* 2] = b1[0x0E] + b1[0x09]; + out1[0x10* 2] = b1[0x09] + b1[0x0D]; + out1[0x10* 6] = b1[0x0D] + b1[0x0B]; + out1[0x10*10] = b1[0x0B] + b1[0x0F]; + out1[0x10*14] = b1[0x0F]; +#else + b1[0x08] += b1[0x0C]; + out0[0x10*14] = b1[0x08]; + b1[0x0C] += b1[0x0a]; + out0[0x10*10] = b1[0x0C]; + b1[0x0A] += b1[0x0E]; + out0[0x10* 6] = b1[0x0A]; + b1[0x0E] += b1[0x09]; + out0[0x10* 2] = b1[0x0E]; + b1[0x09] += b1[0x0D]; + out1[0x10* 2] = b1[0x09]; + b1[0x0D] += b1[0x0B]; + out1[0x10* 6] = b1[0x0D]; + b1[0x0B] += b1[0x0F]; + out1[0x10*10] = b1[0x0B]; + out1[0x10*14] = b1[0x0F]; +#endif + + { + real tmp; + tmp = b1[0x18] + b1[0x1C]; + out0[0x10*15] = tmp + b1[0x10]; + out0[0x10*13] = tmp + b1[0x14]; + tmp = b1[0x1C] + b1[0x1A]; + out0[0x10*11] = tmp + b1[0x14]; + out0[0x10* 9] = tmp + b1[0x12]; + tmp = b1[0x1A] + b1[0x1E]; + out0[0x10* 7] = tmp + b1[0x12]; + out0[0x10* 5] = tmp + b1[0x16]; + tmp = b1[0x1E] + b1[0x19]; + out0[0x10* 3] = tmp + b1[0x16]; + out0[0x10* 1] = tmp + b1[0x11]; + tmp = b1[0x19] + b1[0x1D]; + out1[0x10* 1] = tmp + b1[0x11]; + out1[0x10* 3] = tmp + b1[0x15]; + tmp = b1[0x1D] + b1[0x1B]; + out1[0x10* 5] = tmp + b1[0x15]; + out1[0x10* 7] = tmp + b1[0x13]; + tmp = b1[0x1B] + b1[0x1F]; + out1[0x10* 9] = tmp + b1[0x13]; + out1[0x10*11] = tmp + b1[0x17]; + out1[0x10*13] = b1[0x17] + b1[0x1F]; + out1[0x10*15] = b1[0x1F]; + } +} + +/* + * the call via dct64 is a trick to force GCC to use + * (new) registers for the b1,b2 pointer to the bufs[xx] field + */ +void dct64(real *a,real *b,real *c) +{ + real bufs[0x40]; + dct64_1(a,b,bufs,bufs+0x20,c); +} + diff --git a/addons/mp3/decode_i386.c b/addons/mp3/decode_i386.c new file mode 100644 index 000000000..83e054422 --- /dev/null +++ b/addons/mp3/decode_i386.c @@ -0,0 +1,153 @@ +/* + * Mpeg Layer-1,2,3 audio decoder + * ------------------------------ + * copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved. + * See also 'README' + * + * slighlty optimized for machines without autoincrement/decrement. + * The performance is highly compiler dependend. Maybe + * the decode.c version for 'normal' processor may be faster + * even for Intel processors. + */ + +#include +#include +#include + + +#include "mpglib.h" + + + + /* old WRITE_SAMPLE */ +#define WRITE_SAMPLE(samples,sum,clip) \ + if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \ + else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \ + else { *(samples) = sum; } + +int synth_1to1_mono(struct mpstr *mp,real *bandPtr,unsigned char *samples,int *pnt) +{ + short samples_tmp[64]; + short *tmp1 = samples_tmp; + int i,ret; + int pnt1 = 0; + + ret = synth_1to1(mp,bandPtr,0,(unsigned char *) samples_tmp,&pnt1); + samples += *pnt; + + for(i=0;i<32;i++) { + *( (short *) samples) = *tmp1; + samples += 2; + tmp1 += 2; + } + *pnt += 64; + + return ret; +} + + +int synth_1to1(struct mpstr *mp, real *bandPtr,int channel,unsigned char *out,int *pnt) +{ + static const int step = 2; + int bo; + short *samples = (short *) (out + *pnt); + + real *b0,(*buf)[0x110]; + int clip = 0; + int bo1; + + bo = mp->synth_bo; + + if(!channel) { + bo--; + bo &= 0xf; + buf = mp->synth_buffs[0]; + } + else { + samples++; + buf = mp->synth_buffs[1]; + } + + if(bo & 0x1) { + b0 = buf[0]; + bo1 = bo; + dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr); + } + else { + b0 = buf[1]; + bo1 = bo+1; + dct64(buf[0]+bo,buf[1]+bo+1,bandPtr); + } + + mp->synth_bo = bo; + + { + register int j; + real *window = decwin + 16 - bo1; + + for (j=16;j;j--,b0+=0x10,window+=0x20,samples+=step) + { + real sum; + sum = window[0x0] * b0[0x0]; + sum -= window[0x1] * b0[0x1]; + sum += window[0x2] * b0[0x2]; + sum -= window[0x3] * b0[0x3]; + sum += window[0x4] * b0[0x4]; + sum -= window[0x5] * b0[0x5]; + sum += window[0x6] * b0[0x6]; + sum -= window[0x7] * b0[0x7]; + sum += window[0x8] * b0[0x8]; + sum -= window[0x9] * b0[0x9]; + sum += window[0xA] * b0[0xA]; + sum -= window[0xB] * b0[0xB]; + sum += window[0xC] * b0[0xC]; + sum -= window[0xD] * b0[0xD]; + sum += window[0xE] * b0[0xE]; + sum -= window[0xF] * b0[0xF]; + + WRITE_SAMPLE(samples,sum,clip); + } + + { + real sum; + sum = window[0x0] * b0[0x0]; + sum += window[0x2] * b0[0x2]; + sum += window[0x4] * b0[0x4]; + sum += window[0x6] * b0[0x6]; + sum += window[0x8] * b0[0x8]; + sum += window[0xA] * b0[0xA]; + sum += window[0xC] * b0[0xC]; + sum += window[0xE] * b0[0xE]; + WRITE_SAMPLE(samples,sum,clip); + b0-=0x10,window-=0x20,samples+=step; + } + window += bo1<<1; + + for (j=15;j;j--,b0-=0x10,window-=0x20,samples+=step) + { + real sum; + sum = -window[-0x1] * b0[0x0]; + sum -= window[-0x2] * b0[0x1]; + sum -= window[-0x3] * b0[0x2]; + sum -= window[-0x4] * b0[0x3]; + sum -= window[-0x5] * b0[0x4]; + sum -= window[-0x6] * b0[0x5]; + sum -= window[-0x7] * b0[0x6]; + sum -= window[-0x8] * b0[0x7]; + sum -= window[-0x9] * b0[0x8]; + sum -= window[-0xA] * b0[0x9]; + sum -= window[-0xB] * b0[0xA]; + sum -= window[-0xC] * b0[0xB]; + sum -= window[-0xD] * b0[0xC]; + sum -= window[-0xE] * b0[0xD]; + sum -= window[-0xF] * b0[0xE]; + sum -= window[-0x0] * b0[0xF]; + + WRITE_SAMPLE(samples,sum,clip); + } + } + *pnt += 128; + + return clip; +} + diff --git a/addons/mp3/decode_ntom.c b/addons/mp3/decode_ntom.c new file mode 100644 index 000000000..b231f439f --- /dev/null +++ b/addons/mp3/decode_ntom.c @@ -0,0 +1,219 @@ +/* + * Mpeg Layer-1,2,3 audio decoder + * ------------------------------ + * copyright (c) 1995,1996,1997 by Michael Hipp, All rights reserved. + * See also 'README' + * + * N->M down/up sampling. Not optimized for speed. + */ + +#include +#include +#include +#include +#include + +#include "mpg123.h" +#include "mpglib.h" + +#define WRITE_SAMPLE(samples,sum,clip) \ + if( (sum) > 32767.0) { *(samples) = 0x7fff; (clip)++; } \ + else if( (sum) < -32768.0) { *(samples) = -0x8000; (clip)++; } \ + else { *(samples) = sum; } + +#define NTOM_MUL (32768) +static unsigned long ntom_val[2] = { NTOM_MUL>>1,NTOM_MUL>>1 }; +static unsigned long ntom_step = NTOM_MUL; + + +int synth_ntom_set_step(long m,long n) +{ + if(param.verbose > 1) + ast_log(LOG_WARNING,"Init rate converter: %ld->%ld\n",m,n); + + if(n >= 96000 || m >= 96000 || m == 0 || n == 0) { + ast_log(LOG_WARNING,"NtoM converter: illegal rates\n"); + return (1); + } + + n *= NTOM_MUL; + ntom_step = n / m; + + if(ntom_step > 8*NTOM_MUL) { + ast_log(LOG_WARNING,"max. 1:8 conversion allowed!\n"); + return (1); + } + + ntom_val[0] = ntom_val[1] = NTOM_MUL>>1; + + return (0); + +} + + +int synth_ntom_mono (struct mpstr *mp, real *bandPtr,unsigned char *samples,int *pnt) +{ + short samples_tmp[8*64]; + short *tmp1 = samples_tmp; + int i,ret; + int pnt1 = 0; + + ret = synth_ntom(mp, bandPtr,0,(unsigned char *) samples_tmp,&pnt1); + samples += *pnt; + + for(i=0;i<(pnt1>>2);i++) { + *( (short *)samples) = *tmp1; + samples += 2; + tmp1 += 2; + } + *pnt += pnt1 >> 1; + + return ret; +} + + + +int synth_ntom(struct mpstr *mp, real *bandPtr,int channel,unsigned char *out,int *pnt) +{ + static const int step = 2; + int bo; + short *samples = (short *) (out + *pnt); + + real *b0,(*buf)[0x110]; + int clip = 0; + int bo1; + int ntom; + + bo = mp->synth_bo; + + if(!channel) { + bo--; + bo &= 0xf; + buf = mp->synth_buffs[0]; + ntom = ntom_val[1] = ntom_val[0]; + } + else { + samples++; + out += 2; /* to compute the right *pnt value */ + buf = mp->synth_buffs[1]; + ntom = ntom_val[1]; + } + + if(bo & 0x1) { + b0 = buf[0]; + bo1 = bo; + dct64(buf[1]+((bo+1)&0xf),buf[0]+bo,bandPtr); + } + else { + b0 = buf[1]; + bo1 = bo+1; + dct64(buf[0]+bo,buf[1]+bo+1,bandPtr); + } + + mp->synth_bo = bo; + + { + register int j; + real *window = (mp->decwin) + 16 - bo1; + + for (j=16;j;j--,window+=0x10) + { + real sum; + + ntom += ntom_step; + if(ntom < NTOM_MUL) { + window += 16; + b0 += 16; + continue; + } + + sum = *window++ * *b0++; + sum -= *window++ * *b0++; + sum += *window++ * *b0++; + sum -= *window++ * *b0++; + sum += *window++ * *b0++; + sum -= *window++ * *b0++; + sum += *window++ * *b0++; + sum -= *window++ * *b0++; + sum += *window++ * *b0++; + sum -= *window++ * *b0++; + sum += *window++ * *b0++; + sum -= *window++ * *b0++; + sum += *window++ * *b0++; + sum -= *window++ * *b0++; + sum += *window++ * *b0++; + sum -= *window++ * *b0++; + + while(ntom >= NTOM_MUL) { + WRITE_SAMPLE(samples,sum,clip); + samples += step; + ntom -= NTOM_MUL; + } + } + + ntom += ntom_step; + if(ntom >= NTOM_MUL) + { + real sum; + sum = window[0x0] * b0[0x0]; + sum += window[0x2] * b0[0x2]; + sum += window[0x4] * b0[0x4]; + sum += window[0x6] * b0[0x6]; + sum += window[0x8] * b0[0x8]; + sum += window[0xA] * b0[0xA]; + sum += window[0xC] * b0[0xC]; + sum += window[0xE] * b0[0xE]; + + while(ntom >= NTOM_MUL) { + WRITE_SAMPLE(samples,sum,clip); + samples += step; + ntom -= NTOM_MUL; + } + } + + b0-=0x10,window-=0x20; + window += bo1<<1; + + for (j=15;j;j--,b0-=0x20,window-=0x10) + { + real sum; + + ntom += ntom_step; + if(ntom < NTOM_MUL) { + window -= 16; + b0 += 16; + continue; + } + + sum = -*(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + sum -= *(--window) * *b0++; + + while(ntom >= NTOM_MUL) { + WRITE_SAMPLE(samples,sum,clip); + samples += step; + ntom -= NTOM_MUL; + } + } + } + + ntom_val[channel] = ntom; + *pnt = ((unsigned char *) samples - out); + + return clip; +} + + diff --git a/addons/mp3/huffman.h b/addons/mp3/huffman.h new file mode 100644 index 000000000..7fec0d589 --- /dev/null +++ b/addons/mp3/huffman.h @@ -0,0 +1,332 @@ +/* + * huffman tables ... recalcualted to work with my optimzed + * decoder scheme (MH) + * + * probably we could save a few bytes of memory, because the + * smaller tables are often the part of a bigger table + */ + +struct newhuff +{ + unsigned int linbits; + short *table; +}; + +static short tab0[] = +{ + 0 +}; + +static short tab1[] = +{ + -5, -3, -1, 17, 1, 16, 0 +}; + +static short tab2[] = +{ + -15, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 17, -1, 1, + 16, 0 +}; + +static short tab3[] = +{ + -13, -11, -9, -5, -3, -1, 34, 2, 18, -1, 33, 32, 16, 17, -1, + 1, 0 +}; + +static short tab5[] = +{ + -29, -25, -23, -15, -7, -5, -3, -1, 51, 35, 50, 49, -3, -1, 19, + 3, -1, 48, 34, -3, -1, 18, 33, -1, 2, 32, 17, -1, 1, 16, + 0 +}; + +static short tab6[] = +{ + -25, -19, -13, -9, -5, -3, -1, 51, 3, 35, -1, 50, 48, -1, 19, + 49, -3, -1, 34, 2, 18, -3, -1, 33, 32, 1, -1, 17, -1, 16, + 0 +}; + +static short tab7[] = +{ + -69, -65, -57, -39, -29, -17, -11, -7, -3, -1, 85, 69, -1, 84, 83, + -1, 53, 68, -3, -1, 37, 82, 21, -5, -1, 81, -1, 5, 52, -1, + 80, -1, 67, 51, -5, -3, -1, 36, 66, 20, -1, 65, 64, -11, -7, + -3, -1, 4, 35, -1, 50, 3, -1, 19, 49, -3, -1, 48, 34, 18, + -5, -1, 33, -1, 2, 32, 17, -1, 1, 16, 0 +}; + +static short tab8[] = +{ + -65, -63, -59, -45, -31, -19, -13, -7, -5, -3, -1, 85, 84, 69, 83, + -3, -1, 53, 68, 37, -3, -1, 82, 5, 21, -5, -1, 81, -1, 52, + 67, -3, -1, 80, 51, 36, -5, -3, -1, 66, 20, 65, -3, -1, 4, + 64, -1, 35, 50, -9, -7, -3, -1, 19, 49, -1, 3, 48, 34, -1, + 2, 32, -1, 18, 33, 17, -3, -1, 1, 16, 0 +}; + +static short tab9[] = +{ + -63, -53, -41, -29, -19, -11, -5, -3, -1, 85, 69, 53, -1, 83, -1, + 84, 5, -3, -1, 68, 37, -1, 82, 21, -3, -1, 81, 52, -1, 67, + -1, 80, 4, -7, -3, -1, 36, 66, -1, 51, 64, -1, 20, 65, -5, + -3, -1, 35, 50, 19, -1, 49, -1, 3, 48, -5, -3, -1, 34, 2, + 18, -1, 33, 32, -3, -1, 17, 1, -1, 16, 0 +}; + +static short tab10[] = +{ +-125,-121,-111, -83, -55, -35, -21, -13, -7, -3, -1, 119, 103, -1, 118, + 87, -3, -1, 117, 102, 71, -3, -1, 116, 86, -1, 101, 55, -9, -3, + -1, 115, 70, -3, -1, 85, 84, 99, -1, 39, 114, -11, -5, -3, -1, + 100, 7, 112, -1, 98, -1, 69, 53, -5, -1, 6, -1, 83, 68, 23, + -17, -5, -1, 113, -1, 54, 38, -5, -3, -1, 37, 82, 21, -1, 81, + -1, 52, 67, -3, -1, 22, 97, -1, 96, -1, 5, 80, -19, -11, -7, + -3, -1, 36, 66, -1, 51, 4, -1, 20, 65, -3, -1, 64, 35, -1, + 50, 3, -3, -1, 19, 49, -1, 48, 34, -7, -3, -1, 18, 33, -1, + 2, 32, 17, -1, 1, 16, 0 +}; + +static short tab11[] = +{ +-121,-113, -89, -59, -43, -27, -17, -7, -3, -1, 119, 103, -1, 118, 117, + -3, -1, 102, 71, -1, 116, -1, 87, 85, -5, -3, -1, 86, 101, 55, + -1, 115, 70, -9, -7, -3, -1, 69, 84, -1, 53, 83, 39, -1, 114, + -1, 100, 7, -5, -1, 113, -1, 23, 112, -3, -1, 54, 99, -1, 96, + -1, 68, 37, -13, -7, -5, -3, -1, 82, 5, 21, 98, -3, -1, 38, + 6, 22, -5, -1, 97, -1, 81, 52, -5, -1, 80, -1, 67, 51, -1, + 36, 66, -15, -11, -7, -3, -1, 20, 65, -1, 4, 64, -1, 35, 50, + -1, 19, 49, -5, -3, -1, 3, 48, 34, 33, -5, -1, 18, -1, 2, + 32, 17, -3, -1, 1, 16, 0 +}; + +static short tab12[] = +{ +-115, -99, -73, -45, -27, -17, -9, -5, -3, -1, 119, 103, 118, -1, 87, + 117, -3, -1, 102, 71, -1, 116, 101, -3, -1, 86, 55, -3, -1, 115, + 85, 39, -7, -3, -1, 114, 70, -1, 100, 23, -5, -1, 113, -1, 7, + 112, -1, 54, 99, -13, -9, -3, -1, 69, 84, -1, 68, -1, 6, 5, + -1, 38, 98, -5, -1, 97, -1, 22, 96, -3, -1, 53, 83, -1, 37, + 82, -17, -7, -3, -1, 21, 81, -1, 52, 67, -5, -3, -1, 80, 4, + 36, -1, 66, 20, -3, -1, 51, 65, -1, 35, 50, -11, -7, -5, -3, + -1, 64, 3, 48, 19, -1, 49, 34, -1, 18, 33, -7, -5, -3, -1, + 2, 32, 0, 17, -1, 1, 16 +}; + +static short tab13[] = +{ +-509,-503,-475,-405,-333,-265,-205,-153,-115, -83, -53, -35, -21, -13, -9, + -7, -5, -3, -1, 254, 252, 253, 237, 255, -1, 239, 223, -3, -1, 238, + 207, -1, 222, 191, -9, -3, -1, 251, 206, -1, 220, -1, 175, 233, -1, + 236, 221, -9, -5, -3, -1, 250, 205, 190, -1, 235, 159, -3, -1, 249, + 234, -1, 189, 219, -17, -9, -3, -1, 143, 248, -1, 204, -1, 174, 158, + -5, -1, 142, -1, 127, 126, 247, -5, -1, 218, -1, 173, 188, -3, -1, + 203, 246, 111, -15, -7, -3, -1, 232, 95, -1, 157, 217, -3, -1, 245, + 231, -1, 172, 187, -9, -3, -1, 79, 244, -3, -1, 202, 230, 243, -1, + 63, -1, 141, 216, -21, -9, -3, -1, 47, 242, -3, -1, 110, 156, 15, + -5, -3, -1, 201, 94, 171, -3, -1, 125, 215, 78, -11, -5, -3, -1, + 200, 214, 62, -1, 185, -1, 155, 170, -1, 31, 241, -23, -13, -5, -1, + 240, -1, 186, 229, -3, -1, 228, 140, -1, 109, 227, -5, -1, 226, -1, + 46, 14, -1, 30, 225, -15, -7, -3, -1, 224, 93, -1, 213, 124, -3, + -1, 199, 77, -1, 139, 184, -7, -3, -1, 212, 154, -1, 169, 108, -1, + 198, 61, -37, -21, -9, -5, -3, -1, 211, 123, 45, -1, 210, 29, -5, + -1, 183, -1, 92, 197, -3, -1, 153, 122, 195, -7, -5, -3, -1, 167, + 151, 75, 209, -3, -1, 13, 208, -1, 138, 168, -11, -7, -3, -1, 76, + 196, -1, 107, 182, -1, 60, 44, -3, -1, 194, 91, -3, -1, 181, 137, + 28, -43, -23, -11, -5, -1, 193, -1, 152, 12, -1, 192, -1, 180, 106, + -5, -3, -1, 166, 121, 59, -1, 179, -1, 136, 90, -11, -5, -1, 43, + -1, 165, 105, -1, 164, -1, 120, 135, -5, -1, 148, -1, 119, 118, 178, + -11, -3, -1, 27, 177, -3, -1, 11, 176, -1, 150, 74, -7, -3, -1, + 58, 163, -1, 89, 149, -1, 42, 162, -47, -23, -9, -3, -1, 26, 161, + -3, -1, 10, 104, 160, -5, -3, -1, 134, 73, 147, -3, -1, 57, 88, + -1, 133, 103, -9, -3, -1, 41, 146, -3, -1, 87, 117, 56, -5, -1, + 131, -1, 102, 71, -3, -1, 116, 86, -1, 101, 115, -11, -3, -1, 25, + 145, -3, -1, 9, 144, -1, 72, 132, -7, -5, -1, 114, -1, 70, 100, + 40, -1, 130, 24, -41, -27, -11, -5, -3, -1, 55, 39, 23, -1, 113, + -1, 85, 7, -7, -3, -1, 112, 54, -1, 99, 69, -3, -1, 84, 38, + -1, 98, 53, -5, -1, 129, -1, 8, 128, -3, -1, 22, 97, -1, 6, + 96, -13, -9, -5, -3, -1, 83, 68, 37, -1, 82, 5, -1, 21, 81, + -7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20, -19, -11, + -5, -1, 65, -1, 4, 64, -3, -1, 35, 50, 19, -3, -1, 49, 3, + -1, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16, + 0 +}; + +static short tab15[] = +{ +-495,-445,-355,-263,-183,-115, -77, -43, -27, -13, -7, -3, -1, 255, 239, + -1, 254, 223, -1, 238, -1, 253, 207, -7, -3, -1, 252, 222, -1, 237, + 191, -1, 251, -1, 206, 236, -7, -3, -1, 221, 175, -1, 250, 190, -3, + -1, 235, 205, -1, 220, 159, -15, -7, -3, -1, 249, 234, -1, 189, 219, + -3, -1, 143, 248, -1, 204, 158, -7, -3, -1, 233, 127, -1, 247, 173, + -3, -1, 218, 188, -1, 111, -1, 174, 15, -19, -11, -3, -1, 203, 246, + -3, -1, 142, 232, -1, 95, 157, -3, -1, 245, 126, -1, 231, 172, -9, + -3, -1, 202, 187, -3, -1, 217, 141, 79, -3, -1, 244, 63, -1, 243, + 216, -33, -17, -9, -3, -1, 230, 47, -1, 242, -1, 110, 240, -3, -1, + 31, 241, -1, 156, 201, -7, -3, -1, 94, 171, -1, 186, 229, -3, -1, + 125, 215, -1, 78, 228, -15, -7, -3, -1, 140, 200, -1, 62, 109, -3, + -1, 214, 227, -1, 155, 185, -7, -3, -1, 46, 170, -1, 226, 30, -5, + -1, 225, -1, 14, 224, -1, 93, 213, -45, -25, -13, -7, -3, -1, 124, + 199, -1, 77, 139, -1, 212, -1, 184, 154, -7, -3, -1, 169, 108, -1, + 198, 61, -1, 211, 210, -9, -5, -3, -1, 45, 13, 29, -1, 123, 183, + -5, -1, 209, -1, 92, 208, -1, 197, 138, -17, -7, -3, -1, 168, 76, + -1, 196, 107, -5, -1, 182, -1, 153, 12, -1, 60, 195, -9, -3, -1, + 122, 167, -1, 166, -1, 192, 11, -1, 194, -1, 44, 91, -55, -29, -15, + -7, -3, -1, 181, 28, -1, 137, 152, -3, -1, 193, 75, -1, 180, 106, + -5, -3, -1, 59, 121, 179, -3, -1, 151, 136, -1, 43, 90, -11, -5, + -1, 178, -1, 165, 27, -1, 177, -1, 176, 105, -7, -3, -1, 150, 74, + -1, 164, 120, -3, -1, 135, 58, 163, -17, -7, -3, -1, 89, 149, -1, + 42, 162, -3, -1, 26, 161, -3, -1, 10, 160, 104, -7, -3, -1, 134, + 73, -1, 148, 57, -5, -1, 147, -1, 119, 9, -1, 88, 133, -53, -29, + -13, -7, -3, -1, 41, 103, -1, 118, 146, -1, 145, -1, 25, 144, -7, + -3, -1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 71, -7, + -3, -1, 40, 130, -1, 24, 129, -7, -3, -1, 116, 8, -1, 128, 86, + -3, -1, 101, 55, -1, 115, 70, -17, -7, -3, -1, 39, 114, -1, 100, + 23, -3, -1, 85, 113, -3, -1, 7, 112, 54, -7, -3, -1, 99, 69, + -1, 84, 38, -3, -1, 98, 22, -3, -1, 6, 96, 53, -33, -19, -9, + -5, -1, 97, -1, 83, 68, -1, 37, 82, -3, -1, 21, 81, -3, -1, + 5, 80, 52, -7, -3, -1, 67, 36, -1, 66, 51, -1, 65, -1, 20, + 4, -9, -3, -1, 35, 50, -3, -1, 64, 3, 19, -3, -1, 49, 48, + 34, -9, -7, -3, -1, 18, 33, -1, 2, 32, 17, -3, -1, 1, 16, + 0 +}; + +static short tab16[] = +{ +-509,-503,-461,-323,-103, -37, -27, -15, -7, -3, -1, 239, 254, -1, 223, + 253, -3, -1, 207, 252, -1, 191, 251, -5, -1, 175, -1, 250, 159, -3, + -1, 249, 248, 143, -7, -3, -1, 127, 247, -1, 111, 246, 255, -9, -5, + -3, -1, 95, 245, 79, -1, 244, 243, -53, -1, 240, -1, 63, -29, -19, + -13, -7, -5, -1, 206, -1, 236, 221, 222, -1, 233, -1, 234, 217, -1, + 238, -1, 237, 235, -3, -1, 190, 205, -3, -1, 220, 219, 174, -11, -5, + -1, 204, -1, 173, 218, -3, -1, 126, 172, 202, -5, -3, -1, 201, 125, + 94, 189, 242, -93, -5, -3, -1, 47, 15, 31, -1, 241, -49, -25, -13, + -5, -1, 158, -1, 188, 203, -3, -1, 142, 232, -1, 157, 231, -7, -3, + -1, 187, 141, -1, 216, 110, -1, 230, 156, -13, -7, -3, -1, 171, 186, + -1, 229, 215, -1, 78, -1, 228, 140, -3, -1, 200, 62, -1, 109, -1, + 214, 155, -19, -11, -5, -3, -1, 185, 170, 225, -1, 212, -1, 184, 169, + -5, -1, 123, -1, 183, 208, 227, -7, -3, -1, 14, 224, -1, 93, 213, + -3, -1, 124, 199, -1, 77, 139, -75, -45, -27, -13, -7, -3, -1, 154, + 108, -1, 198, 61, -3, -1, 92, 197, 13, -7, -3, -1, 138, 168, -1, + 153, 76, -3, -1, 182, 122, 60, -11, -5, -3, -1, 91, 137, 28, -1, + 192, -1, 152, 121, -1, 226, -1, 46, 30, -15, -7, -3, -1, 211, 45, + -1, 210, 209, -5, -1, 59, -1, 151, 136, 29, -7, -3, -1, 196, 107, + -1, 195, 167, -1, 44, -1, 194, 181, -23, -13, -7, -3, -1, 193, 12, + -1, 75, 180, -3, -1, 106, 166, 179, -5, -3, -1, 90, 165, 43, -1, + 178, 27, -13, -5, -1, 177, -1, 11, 176, -3, -1, 105, 150, -1, 74, + 164, -5, -3, -1, 120, 135, 163, -3, -1, 58, 89, 42, -97, -57, -33, + -19, -11, -5, -3, -1, 149, 104, 161, -3, -1, 134, 119, 148, -5, -3, + -1, 73, 87, 103, 162, -5, -1, 26, -1, 10, 160, -3, -1, 57, 147, + -1, 88, 133, -9, -3, -1, 41, 146, -3, -1, 118, 9, 25, -5, -1, + 145, -1, 144, 72, -3, -1, 132, 117, -1, 56, 131, -21, -11, -5, -3, + -1, 102, 40, 130, -3, -1, 71, 116, 24, -3, -1, 129, 128, -3, -1, + 8, 86, 55, -9, -5, -1, 115, -1, 101, 70, -1, 39, 114, -5, -3, + -1, 100, 85, 7, 23, -23, -13, -5, -1, 113, -1, 112, 54, -3, -1, + 99, 69, -1, 84, 38, -3, -1, 98, 22, -1, 97, -1, 6, 96, -9, + -5, -1, 83, -1, 53, 68, -1, 37, 82, -1, 81, -1, 21, 5, -33, + -23, -13, -7, -3, -1, 52, 67, -1, 80, 36, -3, -1, 66, 51, 20, + -5, -1, 65, -1, 4, 64, -1, 35, 50, -3, -1, 19, 49, -3, -1, + 3, 48, 34, -3, -1, 18, 33, -1, 2, 32, -3, -1, 17, 1, 16, + 0 +}; + +static short tab24[] = +{ +-451,-117, -43, -25, -15, -7, -3, -1, 239, 254, -1, 223, 253, -3, -1, + 207, 252, -1, 191, 251, -5, -1, 250, -1, 175, 159, -1, 249, 248, -9, + -5, -3, -1, 143, 127, 247, -1, 111, 246, -3, -1, 95, 245, -1, 79, + 244, -71, -7, -3, -1, 63, 243, -1, 47, 242, -5, -1, 241, -1, 31, + 240, -25, -9, -1, 15, -3, -1, 238, 222, -1, 237, 206, -7, -3, -1, + 236, 221, -1, 190, 235, -3, -1, 205, 220, -1, 174, 234, -15, -7, -3, + -1, 189, 219, -1, 204, 158, -3, -1, 233, 173, -1, 218, 188, -7, -3, + -1, 203, 142, -1, 232, 157, -3, -1, 217, 126, -1, 231, 172, 255,-235, +-143, -77, -45, -25, -15, -7, -3, -1, 202, 187, -1, 141, 216, -5, -3, + -1, 14, 224, 13, 230, -5, -3, -1, 110, 156, 201, -1, 94, 186, -9, + -5, -1, 229, -1, 171, 125, -1, 215, 228, -3, -1, 140, 200, -3, -1, + 78, 46, 62, -15, -7, -3, -1, 109, 214, -1, 227, 155, -3, -1, 185, + 170, -1, 226, 30, -7, -3, -1, 225, 93, -1, 213, 124, -3, -1, 199, + 77, -1, 139, 184, -31, -15, -7, -3, -1, 212, 154, -1, 169, 108, -3, + -1, 198, 61, -1, 211, 45, -7, -3, -1, 210, 29, -1, 123, 183, -3, + -1, 209, 92, -1, 197, 138, -17, -7, -3, -1, 168, 153, -1, 76, 196, + -3, -1, 107, 182, -3, -1, 208, 12, 60, -7, -3, -1, 195, 122, -1, + 167, 44, -3, -1, 194, 91, -1, 181, 28, -57, -35, -19, -7, -3, -1, + 137, 152, -1, 193, 75, -5, -3, -1, 192, 11, 59, -3, -1, 176, 10, + 26, -5, -1, 180, -1, 106, 166, -3, -1, 121, 151, -3, -1, 160, 9, + 144, -9, -3, -1, 179, 136, -3, -1, 43, 90, 178, -7, -3, -1, 165, + 27, -1, 177, 105, -1, 150, 164, -17, -9, -5, -3, -1, 74, 120, 135, + -1, 58, 163, -3, -1, 89, 149, -1, 42, 162, -7, -3, -1, 161, 104, + -1, 134, 119, -3, -1, 73, 148, -1, 57, 147, -63, -31, -15, -7, -3, + -1, 88, 133, -1, 41, 103, -3, -1, 118, 146, -1, 25, 145, -7, -3, + -1, 72, 132, -1, 87, 117, -3, -1, 56, 131, -1, 102, 40, -17, -7, + -3, -1, 130, 24, -1, 71, 116, -5, -1, 129, -1, 8, 128, -1, 86, + 101, -7, -5, -1, 23, -1, 7, 112, 115, -3, -1, 55, 39, 114, -15, + -7, -3, -1, 70, 100, -1, 85, 113, -3, -1, 54, 99, -1, 69, 84, + -7, -3, -1, 38, 98, -1, 22, 97, -5, -3, -1, 6, 96, 53, -1, + 83, 68, -51, -37, -23, -15, -9, -3, -1, 37, 82, -1, 21, -1, 5, + 80, -1, 81, -1, 52, 67, -3, -1, 36, 66, -1, 51, 20, -9, -5, + -1, 65, -1, 4, 64, -1, 35, 50, -1, 19, 49, -7, -5, -3, -1, + 3, 48, 34, 18, -1, 33, -1, 2, 32, -3, -1, 17, 1, -1, 16, + 0 +}; + +static short tab_c0[] = +{ + -29, -21, -13, -7, -3, -1, 11, 15, -1, 13, 14, -3, -1, 7, 5, + 9, -3, -1, 6, 3, -1, 10, 12, -3, -1, 2, 1, -1, 4, 8, + 0 +}; + +static short tab_c1[] = +{ + -15, -7, -3, -1, 15, 14, -1, 13, 12, -3, -1, 11, 10, -1, 9, + 8, -7, -3, -1, 7, 6, -1, 5, 4, -3, -1, 3, 2, -1, 1, + 0 +}; + + + +static struct newhuff ht[] = +{ + { /* 0 */ 0 , tab0 } , + { /* 2 */ 0 , tab1 } , + { /* 3 */ 0 , tab2 } , + { /* 3 */ 0 , tab3 } , + { /* 0 */ 0 , tab0 } , + { /* 4 */ 0 , tab5 } , + { /* 4 */ 0 , tab6 } , + { /* 6 */ 0 , tab7 } , + { /* 6 */ 0 , tab8 } , + { /* 6 */ 0 , tab9 } , + { /* 8 */ 0 , tab10 } , + { /* 8 */ 0 , tab11 } , + { /* 8 */ 0 , tab12 } , + { /* 16 */ 0 , tab13 } , + { /* 0 */ 0 , tab0 } , + { /* 16 */ 0 , tab15 } , + + { /* 16 */ 1 , tab16 } , + { /* 16 */ 2 , tab16 } , + { /* 16 */ 3 , tab16 } , + { /* 16 */ 4 , tab16 } , + { /* 16 */ 6 , tab16 } , + { /* 16 */ 8 , tab16 } , + { /* 16 */ 10, tab16 } , + { /* 16 */ 13, tab16 } , + { /* 16 */ 4 , tab24 } , + { /* 16 */ 5 , tab24 } , + { /* 16 */ 6 , tab24 } , + { /* 16 */ 7 , tab24 } , + { /* 16 */ 8 , tab24 } , + { /* 16 */ 9 , tab24 } , + { /* 16 */ 11, tab24 } , + { /* 16 */ 13, tab24 } +}; + +static struct newhuff htc[] = +{ + { /* 1 , 1 , */ 0 , tab_c0 } , + { /* 1 , 1 , */ 0 , tab_c1 } +}; + + diff --git a/addons/mp3/interface.c b/addons/mp3/interface.c new file mode 100644 index 000000000..9ced53342 --- /dev/null +++ b/addons/mp3/interface.c @@ -0,0 +1,323 @@ +#include +#include + +#include +#include + +#include "mpg123.h" +#include "mpglib.h" + + +void InitMP3Constants(void) +{ + init_layer3_const(); + make_decode_tables_const(); + +} + + +BOOL InitMP3(struct mpstr *mp, long outscale) +{ + /* quiet 4096 med 8192 */ + + memset(mp,0,sizeof(struct mpstr)); + + mp->framesize = 0; + mp->fsizeold = -1; + mp->bsize = 0; + mp->head = mp->tail = NULL; + mp->fr.single = 3; /* force mono */ + mp->bsnum = 0; + mp->synth_bo = 1; + mp->outsamplerate = 8000; + + make_decode_tables_scale(mp, outscale); + + init_layer3_sample_limits(mp, SBLIMIT); + + return !0; +} + +void ExitMP3(struct mpstr *mp) +{ + struct buf *b,*bn; + + b = mp->tail; + while(b) { + free(b->pnt); + bn = b->next; + free(b); + b = bn; + } +} + +static struct buf *addbuf(struct mpstr *mp,char *buf,int size) +{ + struct buf *nbuf; + + nbuf = malloc( sizeof(struct buf) ); + if(!nbuf) { + ast_log(LOG_WARNING,"Out of memory!\n"); + return NULL; + } + nbuf->pnt = malloc(size); + if(!nbuf->pnt) { + free(nbuf); + return NULL; + } + nbuf->size = size; + memcpy(nbuf->pnt,buf,size); + nbuf->next = NULL; + nbuf->prev = mp->head; + nbuf->pos = 0; + + if(!mp->tail) { + mp->tail = nbuf; + } + else { + mp->head->next = nbuf; + } + + mp->head = nbuf; + mp->bsize += size; + + return nbuf; +} + +static void remove_buf(struct mpstr *mp) +{ + struct buf *buf = mp->tail; + + mp->tail = buf->next; + if(mp->tail) + mp->tail->prev = NULL; + else { + mp->tail = mp->head = NULL; + } + + free(buf->pnt); + free(buf); + +} + +static int read_buf_byte(int *error, struct mpstr *mp) +{ + unsigned int b;int pos; + + pos = mp->tail->pos; + while(pos >= mp->tail->size) { + remove_buf(mp); + pos = mp->tail->pos; + if(!mp->tail) { + /* We may pick up this error a few times*/ + /* But things have gone pear shaped */ + ast_log(LOG_WARNING,"Fatal Buffer error!\n"); + *error = 1; + return (0); + } + } + + b = mp->tail->pnt[pos]; + mp->bsize--; + mp->tail->pos++; + + + return b; +} + +static int read_head(struct mpstr *mp) +{ + unsigned long head; + int error=0; + + + head = read_buf_byte(&error, mp); + head <<= 8; + head |= read_buf_byte(&error, mp); + head <<= 8; + head |= read_buf_byte(&error, mp); + head <<= 8; + head |= read_buf_byte(&error, mp); + + mp->header = head; + + if(error){ + return (1); + }else + return (0); + +} + +static int head_check(unsigned long head) +{ + if( (head & 0xffe00000) != 0xffe00000) + return FALSE; + if(!((head>>17)&3)) + return FALSE; + if( ((head>>12)&0xf) == 0xf || ((head>>12)&0xf) == 0) + return FALSE; + if( ((head>>10)&0x3) == 0x3 ) + return FALSE; + if ((head & 0xffff0000) == 0xfffe0000) + return FALSE; + + return TRUE; +} + +static int head_shift(struct mpstr *mp) +{ + unsigned long head; + int error = 0; + + head = mp->header; + + head <<= 8; + head |= read_buf_byte(&error, mp); + + mp->header = head; + + if (error){ + return (1); + }else + return (0); + +} + + +int decodeMP3(struct mpstr *mp,char *in,int isize,char *out, + int osize,int *done) +{ + int len; + long n,m; + int down_sample_sblimit; + + if(osize < 4608) { + ast_log(LOG_WARNING,"To less out space\n"); + return MP3_ERR; + } + + if(in) { + if(addbuf(mp,in,isize) == NULL) { + return MP3_ERR; + } + } + + /* First decode header */ + if(mp->framesize == 0) { + if(mp->bsize < 4) { + return MP3_NEED_MORE; + } + if (read_head(mp)) + return MP3_ERR; + + if(!head_check(mp->header) ) { + int i; + + ast_log(LOG_WARNING,"Junk at the beginning of frame %08lx\n",mp->header); + + /* step in byte steps through next 64K */ + for(i=0;i<65536;i++) { + if(!mp->bsize) + return MP3_NEED_MORE; + + if(head_shift(mp)) + return MP3_ERR; + + if(head_check(mp->header)) + break; + } + if(i == 65536) { + ast_log(LOG_WARNING,"Giving up searching valid MPEG header\n"); + return MP3_ERR; + } + } + + decode_header(&mp->fr,mp->header); + mp->framesize = mp->fr.framesize; + + if (!mp->initmp3){ + mp->initmp3 = 1; + + n = freqs[mp->fr.sampling_frequency]; + if (mp->outsamplerate) { + m = mp->outsamplerate; + } + else { + m =n; + } + + if (synth_ntom_set_step(n,m)) + return MP3_ERR; + + + if(n>m) { + down_sample_sblimit = SBLIMIT * m; + down_sample_sblimit /= n; + } + else { + down_sample_sblimit = SBLIMIT; + } + + init_layer3_sample_limits(mp, down_sample_sblimit); + + } + } + + + if(mp->fr.framesize > mp->bsize) + return MP3_NEED_MORE; + + (mp->worksample).wordpointer = mp->bsspace[mp->bsnum] + 512; + mp->bsnum = (mp->bsnum + 1) & 0x1; + (mp->worksample).bitindex = 0; + + len = 0; + while(len < mp->framesize) { + int nlen; + int blen = mp->tail->size - mp->tail->pos; + if( (mp->framesize - len) <= blen) { + nlen = mp->framesize-len; + } + else { + nlen = blen; + } + memcpy((mp->worksample).wordpointer+len,mp->tail->pnt+mp->tail->pos,nlen); + len += nlen; + mp->tail->pos += nlen; + mp->bsize -= nlen; + if(mp->tail->pos == mp->tail->size) { + remove_buf(mp); + } + } + + *done = 0; + if(mp->fr.error_protection) + getbits(mp, 16); + + if (do_layer3(mp,(unsigned char *) out,done)) + return MP3_ERR; + + mp->fsizeold = mp->framesize; + mp->framesize = 0; + + return MP3_OK; +} + +int set_pointer(struct mpstr *mp, long backstep) +{ + unsigned char *bsbufold; + if(mp->fsizeold < 0 && backstep > 0) { + ast_log(LOG_WARNING,"Can't step back %ld!\n",backstep); + return MP3_ERR; + } + bsbufold = mp->bsspace[mp->bsnum] + 512; + (mp->worksample).wordpointer -= backstep; + if (backstep) + memcpy((mp->worksample).wordpointer,bsbufold+mp->fsizeold-backstep,backstep); + (mp->worksample).bitindex = 0; + return MP3_OK; +} + + + + diff --git a/addons/mp3/layer3.c b/addons/mp3/layer3.c new file mode 100644 index 000000000..793c99633 --- /dev/null +++ b/addons/mp3/layer3.c @@ -0,0 +1,2029 @@ +/* + * Mpeg Layer-3 audio decoder + * -------------------------- + * copyright (c) 1995,1996,1997 by Michael Hipp. + * All rights reserved. See also 'README' + */ + +#include +#include +#include +#include "mpg123.h" +#include "mpglib.h" +#include "huffman.h" + +#define MPEG1 + +/* These should all be constants setup once using init_layer3_const */ +static real ispow[8207]; +static real aa_ca[8],aa_cs[8]; +static real COS1[12][6]; +static real win[4][36]; +static real win1[4][36]; +static real gainpow2[256+118+4]; +static real COS9[9]; +static real COS6_1,COS6_2; +static real tfcos36[9]; +static real tfcos12[3]; + +struct bandInfoStruct { + short longIdx[23]; + short longDiff[22]; + short shortIdx[14]; + short shortDiff[13]; +}; + + +struct bandInfoStruct bandInfo[9] = { + +/* MPEG 1.0 */ + { {0,4,8,12,16,20,24,30,36,44,52,62,74, 90,110,134,162,196,238,288,342,418,576}, + {4,4,4,4,4,4,6,6,8, 8,10,12,16,20,24,28,34,42,50,54, 76,158}, + {0,4*3,8*3,12*3,16*3,22*3,30*3,40*3,52*3,66*3, 84*3,106*3,136*3,192*3}, + {4,4,4,4,6,8,10,12,14,18,22,30,56} } , + + { {0,4,8,12,16,20,24,30,36,42,50,60,72, 88,106,128,156,190,230,276,330,384,576}, + {4,4,4,4,4,4,6,6,6, 8,10,12,16,18,22,28,34,40,46,54, 54,192}, + {0,4*3,8*3,12*3,16*3,22*3,28*3,38*3,50*3,64*3, 80*3,100*3,126*3,192*3}, + {4,4,4,4,6,6,10,12,14,16,20,26,66} } , + + { {0,4,8,12,16,20,24,30,36,44,54,66,82,102,126,156,194,240,296,364,448,550,576} , + {4,4,4,4,4,4,6,6,8,10,12,16,20,24,30,38,46,56,68,84,102, 26} , + {0,4*3,8*3,12*3,16*3,22*3,30*3,42*3,58*3,78*3,104*3,138*3,180*3,192*3} , + {4,4,4,4,6,8,12,16,20,26,34,42,12} } , + +/* MPEG 2.0 */ + { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576}, + {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 } , + {0,4*3,8*3,12*3,18*3,24*3,32*3,42*3,56*3,74*3,100*3,132*3,174*3,192*3} , + {4,4,4,6,6,8,10,14,18,26,32,42,18 } } , + + { {0,6,12,18,24,30,36,44,54,66,80,96,114,136,162,194,232,278,330,394,464,540,576}, + {6,6,6,6,6,6,8,10,12,14,16,18,22,26,32,38,46,52,64,70,76,36 } , + {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,136*3,180*3,192*3} , + {4,4,4,6,8,10,12,14,18,24,32,44,12 } } , + + { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576}, + {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54 }, + {0,4*3,8*3,12*3,18*3,26*3,36*3,48*3,62*3,80*3,104*3,134*3,174*3,192*3}, + {4,4,4,6,8,10,12,14,18,24,30,40,18 } } , +/* MPEG 2.5 */ + { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} , + {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54}, + {0,12,24,36,54,78,108,144,186,240,312,402,522,576}, + {4,4,4,6,8,10,12,14,18,24,30,40,18} }, + { {0,6,12,18,24,30,36,44,54,66,80,96,116,140,168,200,238,284,336,396,464,522,576} , + {6,6,6,6,6,6,8,10,12,14,16,20,24,28,32,38,46,52,60,68,58,54}, + {0,12,24,36,54,78,108,144,186,240,312,402,522,576}, + {4,4,4,6,8,10,12,14,18,24,30,40,18} }, + { {0,12,24,36,48,60,72,88,108,132,160,192,232,280,336,400,476,566,568,570,572,574,576}, + {12,12,12,12,12,12,16,20,24,28,32,40,48,56,64,76,90,2,2,2,2,2}, + {0, 24, 48, 72,108,156,216,288,372,480,486,492,498,576}, + {8,8,8,12,16,20,24,28,36,2,2,2,26} } , +}; + +static int mapbuf0[9][152]; +static int mapbuf1[9][156]; +static int mapbuf2[9][44]; +static int *map[9][3]; +static int *mapend[9][3]; + +static unsigned int n_slen2[512]; /* MPEG 2.0 slen for 'normal' mode */ +static unsigned int i_slen2[256]; /* MPEG 2.0 slen for intensity stereo */ + +static real tan1_1[16],tan2_1[16],tan1_2[16],tan2_2[16]; +static real pow1_1[2][16],pow2_1[2][16],pow1_2[2][16],pow2_2[2][16]; + +/* + * init constant tables for layer-3 + */ +void init_layer3_const(void) +{ + int i,j,k,l; + + for(i=-256;i<118+4;i++) + gainpow2[i+256] = pow((double)2.0,-0.25 * (double) (i+210) ); + + for(i=0;i<8207;i++) + ispow[i] = pow((double)i,(double)4.0/3.0); + + for (i=0;i<8;i++) + { + static double Ci[8]={-0.6,-0.535,-0.33,-0.185,-0.095,-0.041,-0.0142,-0.0037}; + double sq=sqrt(1.0+Ci[i]*Ci[i]); + aa_cs[i] = 1.0/sq; + aa_ca[i] = Ci[i]/sq; + } + + for(i=0;i<18;i++) + { + win[0][i] = win[1][i] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+0) +1) ) / cos ( M_PI * (double) (2*(i+0) +19) / 72.0 ); + win[0][i+18] = win[3][i+18] = 0.5 * sin( M_PI / 72.0 * (double) (2*(i+18)+1) ) / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 ); + } + for(i=0;i<6;i++) + { + win[1][i+18] = 0.5 / cos ( M_PI * (double) (2*(i+18)+19) / 72.0 ); + win[3][i+12] = 0.5 / cos ( M_PI * (double) (2*(i+12)+19) / 72.0 ); + win[1][i+24] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+13) ) / cos ( M_PI * (double) (2*(i+24)+19) / 72.0 ); + win[1][i+30] = win[3][i] = 0.0; + win[3][i+6 ] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*(i+6 )+19) / 72.0 ); + } + + for(i=0;i<9;i++) + COS9[i] = cos( M_PI / 18.0 * (double) i); + + for(i=0;i<9;i++) + tfcos36[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 36.0 ); + for(i=0;i<3;i++) + tfcos12[i] = 0.5 / cos ( M_PI * (double) (i*2+1) / 12.0 ); + + COS6_1 = cos( M_PI / 6.0 * (double) 1); + COS6_2 = cos( M_PI / 6.0 * (double) 2); + + for(i=0;i<12;i++) + { + win[2][i] = 0.5 * sin( M_PI / 24.0 * (double) (2*i+1) ) / cos ( M_PI * (double) (2*i+7) / 24.0 ); + for(j=0;j<6;j++) + COS1[i][j] = cos( M_PI / 24.0 * (double) ((2*i+7)*(2*j+1)) ); + } + + for(j=0;j<4;j++) { + static int len[4] = { 36,36,12,36 }; + for(i=0;i 0) { + if( i & 1 ) + p1 = pow(base,(i+1.0)*0.5); + else + p2 = pow(base,i*0.5); + } + pow1_1[j][i] = p1; + pow2_1[j][i] = p2; + pow1_2[j][i] = M_SQRT2 * p1; + pow2_2[j][i] = M_SQRT2 * p2; + } + } + + for(j=0;j<9;j++) + { + struct bandInfoStruct *bi = &bandInfo[j]; + int *mp; + int cb,lwin; + short *bdf; + + mp = map[j][0] = mapbuf0[j]; + bdf = bi->longDiff; + for(i=0,cb = 0; cb < 8 ; cb++,i+=*bdf++) { + *mp++ = (*bdf) >> 1; + *mp++ = i; + *mp++ = 3; + *mp++ = cb; + } + bdf = bi->shortDiff+3; + for(cb=3;cb<13;cb++) { + int l = (*bdf++) >> 1; + for(lwin=0;lwin<3;lwin++) { + *mp++ = l; + *mp++ = i + lwin; + *mp++ = lwin; + *mp++ = cb; + } + i += 6*l; + } + mapend[j][0] = mp; + + mp = map[j][1] = mapbuf1[j]; + bdf = bi->shortDiff+0; + for(i=0,cb=0;cb<13;cb++) { + int l = (*bdf++) >> 1; + for(lwin=0;lwin<3;lwin++) { + *mp++ = l; + *mp++ = i + lwin; + *mp++ = lwin; + *mp++ = cb; + } + i += 6*l; + } + mapend[j][1] = mp; + + mp = map[j][2] = mapbuf2[j]; + bdf = bi->longDiff; + for(cb = 0; cb < 22 ; cb++) { + *mp++ = (*bdf++) >> 1; + *mp++ = cb; + } + mapend[j][2] = mp; + + } + + for(i=0;i<5;i++) { + for(j=0;j<6;j++) { + for(k=0;k<6;k++) { + int n = k + j * 6 + i * 36; + i_slen2[n] = i|(j<<3)|(k<<6)|(3<<12); + } + } + } + for(i=0;i<4;i++) { + for(j=0;j<4;j++) { + for(k=0;k<4;k++) { + int n = k + j * 4 + i * 16; + i_slen2[n+180] = i|(j<<3)|(k<<6)|(4<<12); + } + } + } + for(i=0;i<4;i++) { + for(j=0;j<3;j++) { + int n = j + i * 3; + i_slen2[n+244] = i|(j<<3) | (5<<12); + n_slen2[n+500] = i|(j<<3) | (2<<12) | (1<<15); + } + } + + for(i=0;i<5;i++) { + for(j=0;j<5;j++) { + for(k=0;k<4;k++) { + for(l=0;l<4;l++) { + int n = l + k * 4 + j * 16 + i * 80; + n_slen2[n] = i|(j<<3)|(k<<6)|(l<<9)|(0<<12); + } + } + } + } + for(i=0;i<5;i++) { + for(j=0;j<5;j++) { + for(k=0;k<4;k++) { + int n = k + j * 4 + i * 20; + n_slen2[n+400] = i|(j<<3)|(k<<6)|(1<<12); + } + } + } +} + +/* MP3 file specific rates */ +void init_layer3_sample_limits(struct mpstr *mp, int down_sample_sblimit) +{ + int i,j; + for(j=0;j<9;j++) { + for(i=0;i<23;i++) { + (mp->longLimit)[j][i] = (bandInfo[j].longIdx[i] - 1 + 8) / 18 + 1; + if((mp->longLimit)[j][i] > (down_sample_sblimit) ) + (mp->longLimit)[j][i] = down_sample_sblimit; + } + for(i=0;i<14;i++) { + (mp->shortLimit)[j][i] = (bandInfo[j].shortIdx[i] - 1) / 18 + 1; + if((mp->shortLimit)[j][i] > (down_sample_sblimit) ) + (mp->shortLimit)[j][i] = down_sample_sblimit; + } + } +} + + + +/* + * read additional side information + */ +#ifdef MPEG1 +static int III_get_side_info_1(struct mpstr *mp, struct III_sideinfo *si,int stereo, + int ms_stereo,long sfreq,int single) +{ + int ch, gr; + int powdiff = (single == 3) ? 4 : 0; + + si->main_data_begin = getbits(mp, 9); + if (stereo == 1) + si->private_bits = getbits_fast(mp, 5); + else + si->private_bits = getbits_fast(mp, 3); + + for (ch=0; chch[ch].gr[0].scfsi = -1; + si->ch[ch].gr[1].scfsi = getbits_fast(mp, 4); + } + + for (gr=0; gr<2; gr++) + { + for (ch=0; chch[ch].gr[gr]); + + gr_info->part2_3_length = getbits(mp, 12); + gr_info->big_values = getbits_fast(mp, 9); + if(gr_info->big_values > 288) { + ast_log(LOG_WARNING,"big_values too large!\n"); + gr_info->big_values = 288; + } + gr_info->pow2gain = gainpow2+256 - getbits_fast(mp, 8) + powdiff; + if(ms_stereo) + gr_info->pow2gain += 2; + gr_info->scalefac_compress = getbits_fast(mp, 4); +/* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */ + if(get1bit(mp)) + { + int i; + gr_info->block_type = getbits_fast(mp, 2); + gr_info->mixed_block_flag = get1bit(mp); + gr_info->table_select[0] = getbits_fast(mp, 5); + gr_info->table_select[1] = getbits_fast(mp, 5); + /* + * table_select[2] not needed, because there is no region2, + * but to satisfy some verifications tools we set it either. + */ + gr_info->table_select[2] = 0; + for(i=0;i<3;i++) + gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(mp, 3)<<3); + + if(gr_info->block_type == 0) { + ast_log(LOG_WARNING,"Blocktype == 0 and window-switching == 1 not allowed.\n"); + return (1); + } + /* region_count/start parameters are implicit in this case. */ + gr_info->region1start = 36>>1; + gr_info->region2start = 576>>1; + } + else + { + int i,r0c,r1c; + for (i=0; i<3; i++) + gr_info->table_select[i] = getbits_fast(mp, 5); + r0c = getbits_fast(mp, 4); + r1c = getbits_fast(mp, 3); + gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ; + gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1; + gr_info->block_type = 0; + gr_info->mixed_block_flag = 0; + } + gr_info->preflag = get1bit(mp); + gr_info->scalefac_scale = get1bit(mp); + gr_info->count1table_select = get1bit(mp); + } + } + return (0); + +} +#endif + +/* + * Side Info for MPEG 2.0 / LSF + */ +static int III_get_side_info_2(struct mpstr *mp, struct III_sideinfo *si,int stereo, + int ms_stereo,long sfreq,int single) +{ + int ch; + int powdiff = (single == 3) ? 4 : 0; + + si->main_data_begin = getbits(mp, 8); + if (stereo == 1) + si->private_bits = get1bit(mp); + else + si->private_bits = getbits_fast(mp, 2); + + for (ch=0; chch[ch].gr[0]); + + gr_info->part2_3_length = getbits(mp, 12); + gr_info->big_values = getbits_fast(mp, 9); + if(gr_info->big_values > 288) { + ast_log(LOG_WARNING,"big_values too large!\n"); + gr_info->big_values = 288; + } + gr_info->pow2gain = gainpow2+256 - getbits_fast(mp, 8) + powdiff; + if(ms_stereo) + gr_info->pow2gain += 2; + gr_info->scalefac_compress = getbits(mp, 9); +/* window-switching flag == 1 for block_Type != 0 .. and block-type == 0 -> win-sw-flag = 0 */ + if(get1bit(mp)) + { + int i; + gr_info->block_type = getbits_fast(mp, 2); + gr_info->mixed_block_flag = get1bit(mp); + gr_info->table_select[0] = getbits_fast(mp, 5); + gr_info->table_select[1] = getbits_fast(mp, 5); + /* + * table_select[2] not needed, because there is no region2, + * but to satisfy some verifications tools we set it either. + */ + gr_info->table_select[2] = 0; + for(i=0;i<3;i++) + gr_info->full_gain[i] = gr_info->pow2gain + (getbits_fast(mp, 3)<<3); + + if(gr_info->block_type == 0) { + ast_log(LOG_WARNING,"Blocktype == 0 and window-switching == 1 not allowed.\n"); + return (1); + } + /* region_count/start parameters are implicit in this case. */ +/* check this again! */ + if(gr_info->block_type == 2) + gr_info->region1start = 36>>1; + else if(sfreq == 8) +/* check this for 2.5 and sfreq=8 */ + gr_info->region1start = 108>>1; + else + gr_info->region1start = 54>>1; + gr_info->region2start = 576>>1; + } + else + { + int i,r0c,r1c; + for (i=0; i<3; i++) + gr_info->table_select[i] = getbits_fast(mp, 5); + r0c = getbits_fast(mp, 4); + r1c = getbits_fast(mp, 3); + gr_info->region1start = bandInfo[sfreq].longIdx[r0c+1] >> 1 ; + gr_info->region2start = bandInfo[sfreq].longIdx[r0c+1+r1c+1] >> 1; + gr_info->block_type = 0; + gr_info->mixed_block_flag = 0; + } + gr_info->scalefac_scale = get1bit(mp); + gr_info->count1table_select = get1bit(mp); + } + return (0); +} + +/* + * read scalefactors + */ +#ifdef MPEG1 +static int III_get_scale_factors_1(struct mpstr *mp, int *scf,struct gr_info_s *gr_info) +{ + static unsigned char slen[2][16] = { + {0, 0, 0, 0, 3, 1, 1, 1, 2, 2, 2, 3, 3, 3, 4, 4}, + {0, 1, 2, 3, 0, 1, 2, 3, 1, 2, 3, 1, 2, 3, 2, 3} + }; + int numbits; + int num0 = slen[0][gr_info->scalefac_compress]; + int num1 = slen[1][gr_info->scalefac_compress]; + + if (gr_info->block_type == 2) + { + int i=18; + numbits = (num0 + num1) * 18; + + if (gr_info->mixed_block_flag) { + for (i=8;i;i--) + *scf++ = getbits_fast(mp, num0); + i = 9; + numbits -= num0; /* num0 * 17 + num1 * 18 */ + } + + for (;i;i--) + *scf++ = getbits_fast(mp, num0); + for (i = 18; i; i--) + *scf++ = getbits_fast(mp, num1); + *scf++ = 0; *scf++ = 0; *scf++ = 0; /* short[13][0..2] = 0 */ + } + else + { + int i; + int scfsi = gr_info->scfsi; + + if(scfsi < 0) { /* scfsi < 0 => granule == 0 */ + for(i=11;i;i--) + *scf++ = getbits_fast(mp, num0); + for(i=10;i;i--) + *scf++ = getbits_fast(mp, num1); + numbits = (num0 + num1) * 10 + num0; + } + else { + numbits = 0; + if(!(scfsi & 0x8)) { + for (i=6;i;i--) + *scf++ = getbits_fast(mp, num0); + numbits += num0 * 6; + } + else { + *scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */ + *scf++ = 0; *scf++ = 0; *scf++ = 0; + } + + if(!(scfsi & 0x4)) { + for (i=5;i;i--) + *scf++ = getbits_fast(mp, num0); + numbits += num0 * 5; + } + else { + *scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */ + *scf++ = 0; *scf++ = 0; + } + + if(!(scfsi & 0x2)) { + for(i=5;i;i--) + *scf++ = getbits_fast(mp, num1); + numbits += num1 * 5; + } + else { + *scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */ + *scf++ = 0; *scf++ = 0; + } + + if(!(scfsi & 0x1)) { + for (i=5;i;i--) + *scf++ = getbits_fast(mp, num1); + numbits += num1 * 5; + } + else { + *scf++ = 0; *scf++ = 0; *scf++ = 0; /* set to ZERO necessary? */ + *scf++ = 0; *scf++ = 0; + } + } + + *scf++ = 0; /* no l[21] in original sources */ + } + return numbits; +} +#endif + +static int III_get_scale_factors_2(struct mpstr *mp, int *scf,struct gr_info_s *gr_info,int i_stereo) +{ + unsigned char *pnt; + int i,j; + unsigned int slen; + int n = 0; + int numbits = 0; + + static unsigned char stab[3][6][4] = { + { { 6, 5, 5,5 } , { 6, 5, 7,3 } , { 11,10,0,0} , + { 7, 7, 7,0 } , { 6, 6, 6,3 } , { 8, 8,5,0} } , + { { 9, 9, 9,9 } , { 9, 9,12,6 } , { 18,18,0,0} , + {12,12,12,0 } , {12, 9, 9,6 } , { 15,12,9,0} } , + { { 6, 9, 9,9 } , { 6, 9,12,6 } , { 15,18,0,0} , + { 6,15,12,0 } , { 6,12, 9,6 } , { 6,18,9,0} } }; + + if(i_stereo) /* i_stereo AND second channel -> do_layer3() checks this */ + slen = i_slen2[gr_info->scalefac_compress>>1]; + else + slen = n_slen2[gr_info->scalefac_compress]; + + gr_info->preflag = (slen>>15) & 0x1; + + n = 0; + if( gr_info->block_type == 2 ) { + n++; + if(gr_info->mixed_block_flag) + n++; + } + + pnt = stab[n][(slen>>12)&0x7]; + + for(i=0;i<4;i++) { + int num = slen & 0x7; + slen >>= 3; + if(num) { + for(j=0;j<(int)(pnt[i]);j++) + *scf++ = getbits_fast(mp, num); + numbits += pnt[i] * num; + } + else { + for(j=0;j<(int)(pnt[i]);j++) + *scf++ = 0; + } + } + + n = (n << 1) + 1; + for(i=0;iscalefac_scale; + real *xrpnt = (real *) xr; + int l[3],l3; + int part2remain = gr_info->part2_3_length - part2bits; + int *me; + + { + int bv = gr_info->big_values; + int region1 = gr_info->region1start; + int region2 = gr_info->region2start; + + l3 = ((576>>1)-bv)>>1; +/* + * we may lose the 'odd' bit here !! + * check this later again + */ + if(bv <= region1) { + l[0] = bv; l[1] = 0; l[2] = 0; + } + else { + l[0] = region1; + if(bv <= region2) { + l[1] = bv - l[0]; l[2] = 0; + } + else { + l[1] = region2 - l[0]; l[2] = bv - region2; + } + } + } + + if(gr_info->block_type == 2) { + /* + * decoding with short or mixed mode BandIndex table + */ + int i,max[4]; + int step=0,lwin=0,cb=0; + register real v = 0.0; + register int *m,mc; + + if(gr_info->mixed_block_flag) { + max[3] = -1; + max[0] = max[1] = max[2] = 2; + m = map[sfreq][0]; + me = mapend[sfreq][0]; + } + else { + max[0] = max[1] = max[2] = max[3] = -1; + /* max[3] not really needed in this case */ + m = map[sfreq][1]; + me = mapend[sfreq][1]; + } + + mc = 0; + for(i=0;i<2;i++) { + int lp = l[i]; + struct newhuff *h = ht+gr_info->table_select[i]; + for(;lp;lp--,mc--) { + register int x,y; + if( (!mc) ) { + mc = *m++; + xrpnt = ((real *) xr) + (*m++); + lwin = *m++; + cb = *m++; + if(lwin == 3) { + v = gr_info->pow2gain[(*scf++) << shift]; + step = 1; + } + else { + v = gr_info->full_gain[lwin][(*scf++) << shift]; + step = 3; + } + } + { + register short *val = h->table; + while((y=*val++)<0) { + if (get1bit(mp)) + val -= y; + part2remain--; + } + x = y >> 4; + y &= 0xf; + } + if(x == 15) { + max[lwin] = cb; + part2remain -= h->linbits+1; + x += getbits(mp, h->linbits); + if(get1bit(mp)) + *xrpnt = -ispow[x] * v; + else + *xrpnt = ispow[x] * v; + } + else if(x) { + max[lwin] = cb; + if(get1bit(mp)) + *xrpnt = -ispow[x] * v; + else + *xrpnt = ispow[x] * v; + part2remain--; + } + else + *xrpnt = 0.0; + xrpnt += step; + if(y == 15) { + max[lwin] = cb; + part2remain -= h->linbits+1; + y += getbits(mp, h->linbits); + if(get1bit(mp)) + *xrpnt = -ispow[y] * v; + else + *xrpnt = ispow[y] * v; + } + else if(y) { + max[lwin] = cb; + if(get1bit(mp)) + *xrpnt = -ispow[y] * v; + else + *xrpnt = ispow[y] * v; + part2remain--; + } + else + *xrpnt = 0.0; + xrpnt += step; + } + } + for(;l3 && (part2remain > 0);l3--) { + struct newhuff *h = htc+gr_info->count1table_select; + register short *val = h->table,a; + + while((a=*val++)<0) { + part2remain--; + if(part2remain < 0) { + part2remain++; + a = 0; + break; + } + if (get1bit(mp)) + val -= a; + } + + for(i=0;i<4;i++) { + if(!(i & 1)) { + if(!mc) { + mc = *m++; + xrpnt = ((real *) xr) + (*m++); + lwin = *m++; + cb = *m++; + if(lwin == 3) { + v = gr_info->pow2gain[(*scf++) << shift]; + step = 1; + } + else { + v = gr_info->full_gain[lwin][(*scf++) << shift]; + step = 3; + } + } + mc--; + } + if( (a & (0x8>>i)) ) { + max[lwin] = cb; + part2remain--; + if(part2remain < 0) { + part2remain++; + break; + } + if(get1bit(mp)) + *xrpnt = -v; + else + *xrpnt = v; + } + else + *xrpnt = 0.0; + xrpnt += step; + } + } + + while( m < me ) { + if(!mc) { + mc = *m++; + xrpnt = ((real *) xr) + *m++; + if( (*m++) == 3) + step = 1; + else + step = 3; + m++; /* cb */ + } + mc--; + *xrpnt = 0.0; + xrpnt += step; + *xrpnt = 0.0; + xrpnt += step; +/* we could add a little opt. here: + * if we finished a band for window 3 or a long band + * further bands could copied in a simple loop without a + * special 'map' decoding + */ + } + + gr_info->maxband[0] = max[0]+1; + gr_info->maxband[1] = max[1]+1; + gr_info->maxband[2] = max[2]+1; + gr_info->maxbandl = max[3]+1; + + { + int rmax = max[0] > max[1] ? max[0] : max[1]; + rmax = (rmax > max[2] ? rmax : max[2]) + 1; + gr_info->maxb = rmax ? (mp->shortLimit)[sfreq][rmax] : (mp->longLimit)[sfreq][max[3]+1]; + } + + } + else { + /* + * decoding with 'long' BandIndex table (block_type != 2) + */ + int *pretab = gr_info->preflag ? pretab1 : pretab2; + int i,max = -1; + int cb = 0; + register int *m = map[sfreq][2]; + register real v = 0.0; + register int mc = 0; +#if 0 + me = mapend[sfreq][2]; +#endif + + /* + * long hash table values + */ + for(i=0;i<3;i++) { + int lp = l[i]; + struct newhuff *h = ht+gr_info->table_select[i]; + + for(;lp;lp--,mc--) { + int x,y; + + if(!mc) { + mc = *m++; + v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; + cb = *m++; + } + { + register short *val = h->table; + while((y=*val++)<0) { + if (get1bit(mp)) + val -= y; + part2remain--; + } + x = y >> 4; + y &= 0xf; + } + if (x == 15) { + max = cb; + part2remain -= h->linbits+1; + x += getbits(mp, h->linbits); + if(get1bit(mp)) + *xrpnt++ = -ispow[x] * v; + else + *xrpnt++ = ispow[x] * v; + } + else if(x) { + max = cb; + if(get1bit(mp)) + *xrpnt++ = -ispow[x] * v; + else + *xrpnt++ = ispow[x] * v; + part2remain--; + } + else + *xrpnt++ = 0.0; + + if (y == 15) { + max = cb; + part2remain -= h->linbits+1; + y += getbits(mp, h->linbits); + if(get1bit(mp)) + *xrpnt++ = -ispow[y] * v; + else + *xrpnt++ = ispow[y] * v; + } + else if(y) { + max = cb; + if(get1bit(mp)) + *xrpnt++ = -ispow[y] * v; + else + *xrpnt++ = ispow[y] * v; + part2remain--; + } + else + *xrpnt++ = 0.0; + } + } + + /* + * short (count1table) values + */ + for(;l3 && (part2remain > 0);l3--) { + struct newhuff *h = htc+gr_info->count1table_select; + register short *val = h->table,a; + + while((a=*val++)<0) { + part2remain--; + if(part2remain < 0) { + part2remain++; + a = 0; + break; + } + if (get1bit(mp)) + val -= a; + } + + for(i=0;i<4;i++) { + if(!(i & 1)) { + if(!mc) { + mc = *m++; + cb = *m++; + v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; + } + mc--; + } + if ( (a & (0x8>>i)) ) { + max = cb; + part2remain--; + if(part2remain < 0) { + part2remain++; + break; + } + if(get1bit(mp)) + *xrpnt++ = -v; + else + *xrpnt++ = v; + } + else + *xrpnt++ = 0.0; + } + } + + /* + * zero part + */ + for(i=(&xr[SBLIMIT][0]-xrpnt)>>1;i;i--) { + *xrpnt++ = 0.0; + *xrpnt++ = 0.0; + } + + gr_info->maxbandl = max+1; + gr_info->maxb = (mp->longLimit)[sfreq][gr_info->maxbandl]; + } + + while( part2remain > 16 ) { + getbits(mp, 16); /* Dismiss stuffing Bits */ + part2remain -= 16; + } + if(part2remain > 0) + getbits(mp, part2remain); + else if(part2remain < 0) { + ast_log(LOG_WARNING,"mpg123: Can't rewind stream by %d bits!\n",-part2remain); + return 1; /* -> error */ + } + return 0; +} + +#if 0 +static int III_dequantize_sample_ms(real xr[2][SBLIMIT][SSLIMIT],int *scf, + struct gr_info_s *gr_info,int sfreq,int part2bits) +{ + int shift = 1 + gr_info->scalefac_scale; + real *xrpnt = (real *) xr[1]; + real *xr0pnt = (real *) xr[0]; + int l[3],l3; + int part2remain = gr_info->part2_3_length - part2bits; + int *me; + + { + int bv = gr_info->big_values; + int region1 = gr_info->region1start; + int region2 = gr_info->region2start; + + l3 = ((576>>1)-bv)>>1; +/* + * we may lose the 'odd' bit here !! + * check this later gain + */ + if(bv <= region1) { + l[0] = bv; l[1] = 0; l[2] = 0; + } + else { + l[0] = region1; + if(bv <= region2) { + l[1] = bv - l[0]; l[2] = 0; + } + else { + l[1] = region2 - l[0]; l[2] = bv - region2; + } + } + } + + if(gr_info->block_type == 2) { + int i,max[4]; + int step=0,lwin=0,cb=0; + register real v = 0.0; + register int *m,mc = 0; + + if(gr_info->mixed_block_flag) { + max[3] = -1; + max[0] = max[1] = max[2] = 2; + m = map[sfreq][0]; + me = mapend[sfreq][0]; + } + else { + max[0] = max[1] = max[2] = max[3] = -1; + /* max[3] not really needed in this case */ + m = map[sfreq][1]; + me = mapend[sfreq][1]; + } + + for(i=0;i<2;i++) { + int lp = l[i]; + struct newhuff *h = ht+gr_info->table_select[i]; + for(;lp;lp--,mc--) { + int x,y; + + if(!mc) { + mc = *m++; + xrpnt = ((real *) xr[1]) + *m; + xr0pnt = ((real *) xr[0]) + *m++; + lwin = *m++; + cb = *m++; + if(lwin == 3) { + v = gr_info->pow2gain[(*scf++) << shift]; + step = 1; + } + else { + v = gr_info->full_gain[lwin][(*scf++) << shift]; + step = 3; + } + } + { + register short *val = h->table; + while((y=*val++)<0) { + if (get1bit(mp)) + val -= y; + part2remain--; + } + x = y >> 4; + y &= 0xf; + } + if(x == 15) { + max[lwin] = cb; + part2remain -= h->linbits+1; + x += getbits(mp, h->linbits); + if(get1bit(mp)) { + real a = ispow[x] * v; + *xrpnt = *xr0pnt + a; + *xr0pnt -= a; + } + else { + real a = ispow[x] * v; + *xrpnt = *xr0pnt - a; + *xr0pnt += a; + } + } + else if(x) { + max[lwin] = cb; + if(get1bit(mp)) { + real a = ispow[x] * v; + *xrpnt = *xr0pnt + a; + *xr0pnt -= a; + } + else { + real a = ispow[x] * v; + *xrpnt = *xr0pnt - a; + *xr0pnt += a; + } + part2remain--; + } + else + *xrpnt = *xr0pnt; + xrpnt += step; + xr0pnt += step; + + if(y == 15) { + max[lwin] = cb; + part2remain -= h->linbits+1; + y += getbits(mp, h->linbits); + if(get1bit(mp)) { + real a = ispow[y] * v; + *xrpnt = *xr0pnt + a; + *xr0pnt -= a; + } + else { + real a = ispow[y] * v; + *xrpnt = *xr0pnt - a; + *xr0pnt += a; + } + } + else if(y) { + max[lwin] = cb; + if(get1bit(mp)) { + real a = ispow[y] * v; + *xrpnt = *xr0pnt + a; + *xr0pnt -= a; + } + else { + real a = ispow[y] * v; + *xrpnt = *xr0pnt - a; + *xr0pnt += a; + } + part2remain--; + } + else + *xrpnt = *xr0pnt; + xrpnt += step; + xr0pnt += step; + } + } + + for(;l3 && (part2remain > 0);l3--) { + struct newhuff *h = htc+gr_info->count1table_select; + register short *val = h->table,a; + + while((a=*val++)<0) { + part2remain--; + if(part2remain < 0) { + part2remain++; + a = 0; + break; + } + if (get1bit(mp)) + val -= a; + } + + for(i=0;i<4;i++) { + if(!(i & 1)) { + if(!mc) { + mc = *m++; + xrpnt = ((real *) xr[1]) + *m; + xr0pnt = ((real *) xr[0]) + *m++; + lwin = *m++; + cb = *m++; + if(lwin == 3) { + v = gr_info->pow2gain[(*scf++) << shift]; + step = 1; + } + else { + v = gr_info->full_gain[lwin][(*scf++) << shift]; + step = 3; + } + } + mc--; + } + if( (a & (0x8>>i)) ) { + max[lwin] = cb; + part2remain--; + if(part2remain < 0) { + part2remain++; + break; + } + if(get1bit(mp)) { + *xrpnt = *xr0pnt + v; + *xr0pnt -= v; + } + else { + *xrpnt = *xr0pnt - v; + *xr0pnt += v; + } + } + else + *xrpnt = *xr0pnt; + xrpnt += step; + xr0pnt += step; + } + } + + while( m < me ) { + if(!mc) { + mc = *m++; + xrpnt = ((real *) xr[1]) + *m; + xr0pnt = ((real *) xr[0]) + *m++; + if(*m++ == 3) + step = 1; + else + step = 3; + m++; /* cb */ + } + mc--; + *xrpnt = *xr0pnt; + xrpnt += step; + xr0pnt += step; + *xrpnt = *xr0pnt; + xrpnt += step; + xr0pnt += step; +/* we could add a little opt. here: + * if we finished a band for window 3 or a long band + * further bands could copied in a simple loop without a + * special 'map' decoding + */ + } + + gr_info->maxband[0] = max[0]+1; + gr_info->maxband[1] = max[1]+1; + gr_info->maxband[2] = max[2]+1; + gr_info->maxbandl = max[3]+1; + + { + int rmax = max[0] > max[1] ? max[0] : max[1]; + rmax = (rmax > max[2] ? rmax : max[2]) + 1; + gr_info->maxb = rmax ? (mp->shortLimit)[sfreq][rmax] : (mp->longLimit)[sfreq][max[3]+1]; + } + } + else { + int *pretab = gr_info->preflag ? pretab1 : pretab2; + int i,max = -1; + int cb = 0; + register int mc=0,*m = map[sfreq][2]; + register real v = 0.0; +#if 0 + me = mapend[sfreq][2]; +#endif + + for(i=0;i<3;i++) { + int lp = l[i]; + struct newhuff *h = ht+gr_info->table_select[i]; + + for(;lp;lp--,mc--) { + int x,y; + if(!mc) { + mc = *m++; + cb = *m++; + v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; + } + { + register short *val = h->table; + while((y=*val++)<0) { + if (get1bit(mp)) + val -= y; + part2remain--; + } + x = y >> 4; + y &= 0xf; + } + if (x == 15) { + max = cb; + part2remain -= h->linbits+1; + x += getbits(mp, h->linbits); + if(get1bit(mp)) { + real a = ispow[x] * v; + *xrpnt++ = *xr0pnt + a; + *xr0pnt++ -= a; + } + else { + real a = ispow[x] * v; + *xrpnt++ = *xr0pnt - a; + *xr0pnt++ += a; + } + } + else if(x) { + max = cb; + if(get1bit(mp)) { + real a = ispow[x] * v; + *xrpnt++ = *xr0pnt + a; + *xr0pnt++ -= a; + } + else { + real a = ispow[x] * v; + *xrpnt++ = *xr0pnt - a; + *xr0pnt++ += a; + } + part2remain--; + } + else + *xrpnt++ = *xr0pnt++; + + if (y == 15) { + max = cb; + part2remain -= h->linbits+1; + y += getbits(mp, h->linbits); + if(get1bit(mp)) { + real a = ispow[y] * v; + *xrpnt++ = *xr0pnt + a; + *xr0pnt++ -= a; + } + else { + real a = ispow[y] * v; + *xrpnt++ = *xr0pnt - a; + *xr0pnt++ += a; + } + } + else if(y) { + max = cb; + if(get1bit(mp)) { + real a = ispow[y] * v; + *xrpnt++ = *xr0pnt + a; + *xr0pnt++ -= a; + } + else { + real a = ispow[y] * v; + *xrpnt++ = *xr0pnt - a; + *xr0pnt++ += a; + } + part2remain--; + } + else + *xrpnt++ = *xr0pnt++; + } + } + + for(;l3 && (part2remain > 0);l3--) { + struct newhuff *h = htc+gr_info->count1table_select; + register short *val = h->table,a; + + while((a=*val++)<0) { + part2remain--; + if(part2remain < 0) { + part2remain++; + a = 0; + break; + } + if (get1bit(mp)) + val -= a; + } + + for(i=0;i<4;i++) { + if(!(i & 1)) { + if(!mc) { + mc = *m++; + cb = *m++; + v = gr_info->pow2gain[((*scf++) + (*pretab++)) << shift]; + } + mc--; + } + if ( (a & (0x8>>i)) ) { + max = cb; + part2remain--; + if(part2remain <= 0) { + part2remain++; + break; + } + if(get1bit(mp)) { + *xrpnt++ = *xr0pnt + v; + *xr0pnt++ -= v; + } + else { + *xrpnt++ = *xr0pnt - v; + *xr0pnt++ += v; + } + } + else + *xrpnt++ = *xr0pnt++; + } + } + for(i=(&xr[1][SBLIMIT][0]-xrpnt)>>1;i;i--) { + *xrpnt++ = *xr0pnt++; + *xrpnt++ = *xr0pnt++; + } + + gr_info->maxbandl = max+1; + gr_info->maxb = longLimit[sfreq][gr_info->maxbandl]; + } + + while ( part2remain > 16 ) { + getbits(mp, 16); /* Dismiss stuffing Bits */ + part2remain -= 16; + } + if(part2remain > 0 ) + getbits(mp, part2remain); + else if(part2remain < 0) { + ast_log(LOG_WARNING,"mpg123_ms: Can't rewind stream by %d bits!\n",-part2remain); + return 1; /* -> error */ + } + return 0; +} +#endif + +/* + * III_stereo: calculate real channel values for Joint-I-Stereo-mode + */ +static void III_i_stereo(real xr_buf[2][SBLIMIT][SSLIMIT],int *scalefac, + struct gr_info_s *gr_info,int sfreq,int ms_stereo,int lsf) +{ + real (*xr)[SBLIMIT*SSLIMIT] = (real (*)[SBLIMIT*SSLIMIT] ) xr_buf; + struct bandInfoStruct *bi = &bandInfo[sfreq]; + real *tab1,*tab2; + + if(lsf) { + int p = gr_info->scalefac_compress & 0x1; + if(ms_stereo) { + tab1 = pow1_2[p]; tab2 = pow2_2[p]; + } + else { + tab1 = pow1_1[p]; tab2 = pow2_1[p]; + } + } + else { + if(ms_stereo) { + tab1 = tan1_2; tab2 = tan2_2; + } + else { + tab1 = tan1_1; tab2 = tan2_1; + } + } + + if (gr_info->block_type == 2) + { + int lwin,do_l = 0; + if( gr_info->mixed_block_flag ) + do_l = 1; + + for (lwin=0;lwin<3;lwin++) /* process each window */ + { + /* get first band with zero values */ + int is_p,sb,idx,sfb = gr_info->maxband[lwin]; /* sfb is minimal 3 for mixed mode */ + if(sfb > 3) + do_l = 0; + + for(;sfb<12;sfb++) + { + is_p = scalefac[sfb*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */ + if(is_p != 7) { + real t1,t2; + sb = bi->shortDiff[sfb]; + idx = bi->shortIdx[sfb] + lwin; + t1 = tab1[is_p]; t2 = tab2[is_p]; + for (; sb > 0; sb--,idx+=3) + { + real v = xr[0][idx]; + xr[0][idx] = v * t1; + xr[1][idx] = v * t2; + } + } + } + +#if 1 +/* in the original: copy 10 to 11 , here: copy 11 to 12 +maybe still wrong??? (copy 12 to 13?) */ + is_p = scalefac[11*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */ + sb = bi->shortDiff[12]; + idx = bi->shortIdx[12] + lwin; +#else + is_p = scalefac[10*3+lwin-gr_info->mixed_block_flag]; /* scale: 0-15 */ + sb = bi->shortDiff[11]; + idx = bi->shortIdx[11] + lwin; +#endif + if(is_p != 7) + { + real t1,t2; + t1 = tab1[is_p]; t2 = tab2[is_p]; + for ( ; sb > 0; sb--,idx+=3 ) + { + real v = xr[0][idx]; + xr[0][idx] = v * t1; + xr[1][idx] = v * t2; + } + } + } /* end for(lwin; .. ; . ) */ + + if (do_l) + { +/* also check l-part, if ALL bands in the three windows are 'empty' + * and mode = mixed_mode + */ + int sfb = gr_info->maxbandl; + int idx = bi->longIdx[sfb]; + + for ( ; sfb<8; sfb++ ) + { + int sb = bi->longDiff[sfb]; + int is_p = scalefac[sfb]; /* scale: 0-15 */ + if(is_p != 7) { + real t1,t2; + t1 = tab1[is_p]; t2 = tab2[is_p]; + for ( ; sb > 0; sb--,idx++) + { + real v = xr[0][idx]; + xr[0][idx] = v * t1; + xr[1][idx] = v * t2; + } + } + else + idx += sb; + } + } + } + else /* ((gr_info->block_type != 2)) */ + { + int sfb = gr_info->maxbandl; + int is_p,idx = bi->longIdx[sfb]; + for ( ; sfb<21; sfb++) + { + int sb = bi->longDiff[sfb]; + is_p = scalefac[sfb]; /* scale: 0-15 */ + if(is_p != 7) { + real t1,t2; + t1 = tab1[is_p]; t2 = tab2[is_p]; + for ( ; sb > 0; sb--,idx++) + { + real v = xr[0][idx]; + xr[0][idx] = v * t1; + xr[1][idx] = v * t2; + } + } + else + idx += sb; + } + + is_p = scalefac[20]; /* copy l-band 20 to l-band 21 */ + if(is_p != 7) + { + int sb; + real t1 = tab1[is_p],t2 = tab2[is_p]; + + for ( sb = bi->longDiff[21]; sb > 0; sb--,idx++ ) + { + real v = xr[0][idx]; + xr[0][idx] = v * t1; + xr[1][idx] = v * t2; + } + } + } /* ... */ +} + +static void III_antialias(real xr[SBLIMIT][SSLIMIT],struct gr_info_s *gr_info) +{ + int sblim; + + if(gr_info->block_type == 2) + { + if(!gr_info->mixed_block_flag) + return; + sblim = 1; + } + else { + sblim = gr_info->maxb-1; + } + + /* 31 alias-reduction operations between each pair of sub-bands */ + /* with 8 butterflies between each pair */ + + { + int sb; + real *xr1=(real *) xr[1]; + + for(sb=sblim;sb;sb--,xr1+=10) + { + int ss; + real *cs=aa_cs,*ca=aa_ca; + real *xr2 = xr1; + + for(ss=7;ss>=0;ss--) + { /* upper and lower butterfly inputs */ + register real bu = *--xr2,bd = *xr1; + *xr2 = (bu * (*cs) ) - (bd * (*ca) ); + *xr1++ = (bd * (*cs++) ) + (bu * (*ca++) ); + } + } + } +} + +/* + DCT insipired by Jeff Tsay's DCT from the maplay package + this is an optimized version with manual unroll. + + References: + [1] S. Winograd: "On Computing the Discrete Fourier Transform", + Mathematics of Computation, Volume 32, Number 141, January 1978, + Pages 175-199 +*/ + +static void dct36(real *inbuf,real *o1,real *o2,real *wintab,real *tsbuf) +{ + { + register real *in = inbuf; + + in[17]+=in[16]; in[16]+=in[15]; in[15]+=in[14]; + in[14]+=in[13]; in[13]+=in[12]; in[12]+=in[11]; + in[11]+=in[10]; in[10]+=in[9]; in[9] +=in[8]; + in[8] +=in[7]; in[7] +=in[6]; in[6] +=in[5]; + in[5] +=in[4]; in[4] +=in[3]; in[3] +=in[2]; + in[2] +=in[1]; in[1] +=in[0]; + + in[17]+=in[15]; in[15]+=in[13]; in[13]+=in[11]; in[11]+=in[9]; + in[9] +=in[7]; in[7] +=in[5]; in[5] +=in[3]; in[3] +=in[1]; + + + { + +#define MACRO0(v) { \ + real tmp; \ + out2[9+(v)] = (tmp = sum0 + sum1) * w[27+(v)]; \ + out2[8-(v)] = tmp * w[26-(v)]; } \ + sum0 -= sum1; \ + ts[SBLIMIT*(8-(v))] = out1[8-(v)] + sum0 * w[8-(v)]; \ + ts[SBLIMIT*(9+(v))] = out1[9+(v)] + sum0 * w[9+(v)]; +#define MACRO1(v) { \ + real sum0,sum1; \ + sum0 = tmp1a + tmp2a; \ + sum1 = (tmp1b + tmp2b) * tfcos36[(v)]; \ + MACRO0(v); } +#define MACRO2(v) { \ + real sum0,sum1; \ + sum0 = tmp2a - tmp1a; \ + sum1 = (tmp2b - tmp1b) * tfcos36[(v)]; \ + MACRO0(v); } + + register const real *c = COS9; + register real *out2 = o2; + register real *w = wintab; + register real *out1 = o1; + register real *ts = tsbuf; + + real ta33,ta66,tb33,tb66; + + ta33 = in[2*3+0] * c[3]; + ta66 = in[2*6+0] * c[6]; + tb33 = in[2*3+1] * c[3]; + tb66 = in[2*6+1] * c[6]; + + { + real tmp1a,tmp2a,tmp1b,tmp2b; + tmp1a = in[2*1+0] * c[1] + ta33 + in[2*5+0] * c[5] + in[2*7+0] * c[7]; + tmp1b = in[2*1+1] * c[1] + tb33 + in[2*5+1] * c[5] + in[2*7+1] * c[7]; + tmp2a = in[2*0+0] + in[2*2+0] * c[2] + in[2*4+0] * c[4] + ta66 + in[2*8+0] * c[8]; + tmp2b = in[2*0+1] + in[2*2+1] * c[2] + in[2*4+1] * c[4] + tb66 + in[2*8+1] * c[8]; + + MACRO1(0); + MACRO2(8); + } + + { + real tmp1a,tmp2a,tmp1b,tmp2b; + tmp1a = ( in[2*1+0] - in[2*5+0] - in[2*7+0] ) * c[3]; + tmp1b = ( in[2*1+1] - in[2*5+1] - in[2*7+1] ) * c[3]; + tmp2a = ( in[2*2+0] - in[2*4+0] - in[2*8+0] ) * c[6] - in[2*6+0] + in[2*0+0]; + tmp2b = ( in[2*2+1] - in[2*4+1] - in[2*8+1] ) * c[6] - in[2*6+1] + in[2*0+1]; + + MACRO1(1); + MACRO2(7); + } + + { + real tmp1a,tmp2a,tmp1b,tmp2b; + tmp1a = in[2*1+0] * c[5] - ta33 - in[2*5+0] * c[7] + in[2*7+0] * c[1]; + tmp1b = in[2*1+1] * c[5] - tb33 - in[2*5+1] * c[7] + in[2*7+1] * c[1]; + tmp2a = in[2*0+0] - in[2*2+0] * c[8] - in[2*4+0] * c[2] + ta66 + in[2*8+0] * c[4]; + tmp2b = in[2*0+1] - in[2*2+1] * c[8] - in[2*4+1] * c[2] + tb66 + in[2*8+1] * c[4]; + + MACRO1(2); + MACRO2(6); + } + + { + real tmp1a,tmp2a,tmp1b,tmp2b; + tmp1a = in[2*1+0] * c[7] - ta33 + in[2*5+0] * c[1] - in[2*7+0] * c[5]; + tmp1b = in[2*1+1] * c[7] - tb33 + in[2*5+1] * c[1] - in[2*7+1] * c[5]; + tmp2a = in[2*0+0] - in[2*2+0] * c[4] + in[2*4+0] * c[8] + ta66 - in[2*8+0] * c[2]; + tmp2b = in[2*0+1] - in[2*2+1] * c[4] + in[2*4+1] * c[8] + tb66 - in[2*8+1] * c[2]; + + MACRO1(3); + MACRO2(5); + } + + { + real sum0,sum1; + sum0 = in[2*0+0] - in[2*2+0] + in[2*4+0] - in[2*6+0] + in[2*8+0]; + sum1 = (in[2*0+1] - in[2*2+1] + in[2*4+1] - in[2*6+1] + in[2*8+1] ) * tfcos36[4]; + MACRO0(4); + } + } + + } +} + +/* + * new DCT12 + */ +static void dct12(real *in,real *rawout1,real *rawout2,register real *wi,register real *ts) +{ +#define DCT12_PART1 \ + in5 = in[5*3]; \ + in5 += (in4 = in[4*3]); \ + in4 += (in3 = in[3*3]); \ + in3 += (in2 = in[2*3]); \ + in2 += (in1 = in[1*3]); \ + in1 += (in0 = in[0*3]); \ + \ + in5 += in3; in3 += in1; \ + \ + in2 *= COS6_1; \ + in3 *= COS6_1; \ + +#define DCT12_PART2 \ + in0 += in4 * COS6_2; \ + \ + in4 = in0 + in2; \ + in0 -= in2; \ + \ + in1 += in5 * COS6_2; \ + \ + in5 = (in1 + in3) * tfcos12[0]; \ + in1 = (in1 - in3) * tfcos12[2]; \ + \ + in3 = in4 + in5; \ + in4 -= in5; \ + \ + in2 = in0 + in1; \ + in0 -= in1; + + + { + real in0,in1,in2,in3,in4,in5; + register real *out1 = rawout1; + ts[SBLIMIT*0] = out1[0]; ts[SBLIMIT*1] = out1[1]; ts[SBLIMIT*2] = out1[2]; + ts[SBLIMIT*3] = out1[3]; ts[SBLIMIT*4] = out1[4]; ts[SBLIMIT*5] = out1[5]; + + DCT12_PART1 + + { + real tmp0,tmp1 = (in0 - in4); + { + real tmp2 = (in1 - in5) * tfcos12[1]; + tmp0 = tmp1 + tmp2; + tmp1 -= tmp2; + } + ts[(17-1)*SBLIMIT] = out1[17-1] + tmp0 * wi[11-1]; + ts[(12+1)*SBLIMIT] = out1[12+1] + tmp0 * wi[6+1]; + ts[(6 +1)*SBLIMIT] = out1[6 +1] + tmp1 * wi[1]; + ts[(11-1)*SBLIMIT] = out1[11-1] + tmp1 * wi[5-1]; + } + + DCT12_PART2 + + ts[(17-0)*SBLIMIT] = out1[17-0] + in2 * wi[11-0]; + ts[(12+0)*SBLIMIT] = out1[12+0] + in2 * wi[6+0]; + ts[(12+2)*SBLIMIT] = out1[12+2] + in3 * wi[6+2]; + ts[(17-2)*SBLIMIT] = out1[17-2] + in3 * wi[11-2]; + + ts[(6+0)*SBLIMIT] = out1[6+0] + in0 * wi[0]; + ts[(11-0)*SBLIMIT] = out1[11-0] + in0 * wi[5-0]; + ts[(6+2)*SBLIMIT] = out1[6+2] + in4 * wi[2]; + ts[(11-2)*SBLIMIT] = out1[11-2] + in4 * wi[5-2]; + } + + in++; + + { + real in0,in1,in2,in3,in4,in5; + register real *out2 = rawout2; + + DCT12_PART1 + + { + real tmp0,tmp1 = (in0 - in4); + { + real tmp2 = (in1 - in5) * tfcos12[1]; + tmp0 = tmp1 + tmp2; + tmp1 -= tmp2; + } + out2[5-1] = tmp0 * wi[11-1]; + out2[0+1] = tmp0 * wi[6+1]; + ts[(12+1)*SBLIMIT] += tmp1 * wi[1]; + ts[(17-1)*SBLIMIT] += tmp1 * wi[5-1]; + } + + DCT12_PART2 + + out2[5-0] = in2 * wi[11-0]; + out2[0+0] = in2 * wi[6+0]; + out2[0+2] = in3 * wi[6+2]; + out2[5-2] = in3 * wi[11-2]; + + ts[(12+0)*SBLIMIT] += in0 * wi[0]; + ts[(17-0)*SBLIMIT] += in0 * wi[5-0]; + ts[(12+2)*SBLIMIT] += in4 * wi[2]; + ts[(17-2)*SBLIMIT] += in4 * wi[5-2]; + } + + in++; + + { + real in0,in1,in2,in3,in4,in5; + register real *out2 = rawout2; + out2[12]=out2[13]=out2[14]=out2[15]=out2[16]=out2[17]=0.0; + + DCT12_PART1 + + { + real tmp0,tmp1 = (in0 - in4); + { + real tmp2 = (in1 - in5) * tfcos12[1]; + tmp0 = tmp1 + tmp2; + tmp1 -= tmp2; + } + out2[11-1] = tmp0 * wi[11-1]; + out2[6 +1] = tmp0 * wi[6+1]; + out2[0+1] += tmp1 * wi[1]; + out2[5-1] += tmp1 * wi[5-1]; + } + + DCT12_PART2 + + out2[11-0] = in2 * wi[11-0]; + out2[6 +0] = in2 * wi[6+0]; + out2[6 +2] = in3 * wi[6+2]; + out2[11-2] = in3 * wi[11-2]; + + out2[0+0] += in0 * wi[0]; + out2[5-0] += in0 * wi[5-0]; + out2[0+2] += in4 * wi[2]; + out2[5-2] += in4 * wi[5-2]; + } +} + +/* + * III_hybrid + */ +static void III_hybrid(struct mpstr *mp, real fsIn[SBLIMIT][SSLIMIT],real tsOut[SSLIMIT][SBLIMIT], + int ch,struct gr_info_s *gr_info) +{ + real *tspnt = (real *) tsOut; + real (*block)[2][SBLIMIT*SSLIMIT] = mp->hybrid_block; + int *blc = mp->hybrid_blc; + real *rawout1,*rawout2; + int bt; + int sb = 0; + + { + int b = blc[ch]; + rawout1=block[b][ch]; + b=-b+1; + rawout2=block[b][ch]; + blc[ch] = b; + } + + + if(gr_info->mixed_block_flag) { + sb = 2; + dct36(fsIn[0],rawout1,rawout2,win[0],tspnt); + dct36(fsIn[1],rawout1+18,rawout2+18,win1[0],tspnt+1); + rawout1 += 36; rawout2 += 36; tspnt += 2; + } + + bt = gr_info->block_type; + if(bt == 2) { + for (; sbmaxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) { + dct12(fsIn[sb],rawout1,rawout2,win[2],tspnt); + dct12(fsIn[sb+1],rawout1+18,rawout2+18,win1[2],tspnt+1); + } + } + else { + for (; sbmaxb; sb+=2,tspnt+=2,rawout1+=36,rawout2+=36) { + dct36(fsIn[sb],rawout1,rawout2,win[bt],tspnt); + dct36(fsIn[sb+1],rawout1+18,rawout2+18,win1[bt],tspnt+1); + } + } + + for(;sbfr); + stereo = fr->stereo; + single = fr->single; + sfreq = fr->sampling_frequency; + + + + if(stereo == 1) { /* stream is mono */ + stereo1 = 1; + single = 0; + } + else if(single >= 0) /* stream is stereo, but force to mono */ + stereo1 = 1; + else + stereo1 = 2; + + if(fr->mode == MPG_MD_JOINT_STEREO) { + ms_stereo = fr->mode_ext & 0x2; + i_stereo = fr->mode_ext & 0x1; + } + else + ms_stereo = i_stereo = 0; + + if(fr->lsf) { + granules = 1; + if (III_get_side_info_2(mp, &sideinfo,stereo,ms_stereo,sfreq,single)) + return (MP3_ERR); + } + else { + granules = 2; +#ifdef MPEG1 + if ( III_get_side_info_1(mp, &sideinfo,stereo,ms_stereo,sfreq,single)) + return (MP3_ERR); + +#else + ast_log(LOG_WARNING,"Not supported\n"); +#endif + } + + if(set_pointer(mp, sideinfo.main_data_begin) == MP3_ERR) + return 0; + + for (gr=0;grlsf) + part2bits = III_get_scale_factors_2(mp, scalefacs,gr_info,0); + else { +#ifdef MPEG1 + part2bits = III_get_scale_factors_1(mp, scalefacs,gr_info); +#else + ast_log(LOG_WARNING,"Not supported\n"); +#endif + } + if(III_dequantize_sample(mp, hybridIn[0], scalefacs,gr_info,sfreq,part2bits)) + return (MP3_ERR); + } + if(stereo == 2) { + struct gr_info_s *gr_info = &(sideinfo.ch[1].gr[gr]); + long part2bits; + if(fr->lsf) + part2bits = III_get_scale_factors_2(mp, scalefacs,gr_info,i_stereo); + else { +#ifdef MPEG1 + part2bits = III_get_scale_factors_1(mp, scalefacs,gr_info); +#else + ast_log(LOG_WARNING,"Not supported\n"); +#endif + } + + if(III_dequantize_sample(mp, hybridIn[1],scalefacs,gr_info,sfreq,part2bits)) + return (MP3_ERR); + + if(ms_stereo) { + int i; + for(i=0;ilsf); + + if(ms_stereo || i_stereo || (single == 3) ) { + if(gr_info->maxb > sideinfo.ch[0].gr[gr].maxb) + sideinfo.ch[0].gr[gr].maxb = gr_info->maxb; + else + gr_info->maxb = sideinfo.ch[0].gr[gr].maxb; + } + + switch(single) { + case 3: + { + register int i; + register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1]; + for(i=0;imaxb;i++,in0++) + *in0 = (*in0 + *in1++); /* *0.5 done by pow-scale */ + } + break; + case 1: + { + register int i; + register real *in0 = (real *) hybridIn[0],*in1 = (real *) hybridIn[1]; + for(i=0;imaxb;i++) + *in0++ = *in1++; + } + break; + } + } + + for(ch=0;ch= 0) { + clip += synth_ntom_mono(mp,hybridOut[0][ss],pcm_sample,pcm_point); + } + else { + int p1 = *pcm_point; + clip += synth_ntom(mp,hybridOut[0][ss],0,pcm_sample,&p1); + clip += synth_ntom(mp,hybridOut[1][ss],1,pcm_sample,pcm_point); + } + } + } + + return 0; +} + + diff --git a/addons/mp3/mpg123.h b/addons/mp3/mpg123.h new file mode 100644 index 000000000..e607cc277 --- /dev/null +++ b/addons/mp3/mpg123.h @@ -0,0 +1,132 @@ +#include +#include +#include + +#ifndef WIN32 +#include +#include +#endif + +#include + +#ifdef _WIN32 +# undef WIN32 +# define WIN32 + +# define M_PI 3.14159265358979323846 +# define M_SQRT2 1.41421356237309504880 +# define REAL_IS_FLOAT +# define NEW_DCT9 + +# define random rand +# define srandom srand + +#endif + +#ifdef REAL_IS_FLOAT +# define real float +#elif defined(REAL_IS_LONG_DOUBLE) +# define real long double +#else +# define real double +#endif + +#ifdef __GNUC__ +#define INLINE inline +#else +#define INLINE +#endif + +/* AUDIOBUFSIZE = n*64 with n=1,2,3 ... */ +#define AUDIOBUFSIZE 16384 + +#define FALSE 0 +#define TRUE 1 + +#define SBLIMIT 32 +#define SSLIMIT 18 + +#define MPG_MD_STEREO 0 +#define MPG_MD_JOINT_STEREO 1 +#define MPG_MD_DUAL_CHANNEL 2 +#define MPG_MD_MONO 3 + +#define MAXFRAMESIZE 1792 + + +/* Pre Shift fo 16 to 8 bit converter table */ +#define AUSHIFT (3) + +struct frame { + int stereo; + int jsbound; + int single; + int lsf; + int mpeg25; + int header_change; + int lay; + int error_protection; + int bitrate_index; + int sampling_frequency; + int padding; + int extension; + int mode; + int mode_ext; + int copyright; + int original; + int emphasis; + int framesize; /* computed framesize */ +}; + +struct parameter { + int quiet; /* shut up! */ + int tryresync; /* resync stream after error */ + int verbose; /* verbose level */ + int checkrange; +}; + +extern int decode_header(struct frame *fr,unsigned long newhead); + + + +struct gr_info_s { + int scfsi; + unsigned part2_3_length; + unsigned big_values; + unsigned scalefac_compress; + unsigned block_type; + unsigned mixed_block_flag; + unsigned table_select[3]; + unsigned subblock_gain[3]; + unsigned maxband[3]; + unsigned maxbandl; + unsigned maxb; + unsigned region1start; + unsigned region2start; + unsigned preflag; + unsigned scalefac_scale; + unsigned count1table_select; + real *full_gain[3]; + real *pow2gain; +}; + +struct III_sideinfo +{ + unsigned main_data_begin; + unsigned private_bits; + struct { + struct gr_info_s gr[2]; + } ch[2]; +}; + +struct pcm_workingsample +{ + int bitindex; + unsigned char *wordpointer; +}; + + +extern long freqs[9]; +extern struct parameter param; +extern real *pnts[5]; + diff --git a/addons/mp3/mpglib.h b/addons/mp3/mpglib.h new file mode 100644 index 000000000..0613222e6 --- /dev/null +++ b/addons/mp3/mpglib.h @@ -0,0 +1,75 @@ + +struct buf { + unsigned char *pnt; + long size; + long pos; + struct buf *next; + struct buf *prev; +}; + +struct framebuf { + struct buf *buf; + long pos; + struct frame *next; + struct frame *prev; +}; + +struct mpstr { + struct buf *head,*tail; + int bsize; + int framesize; + int fsizeold; + struct frame fr; + unsigned char bsspace[2][MAXFRAMESIZE+512]; /* MAXFRAMESIZE */ + real hybrid_block[2][2][SBLIMIT*SSLIMIT]; + int hybrid_blc[2]; + unsigned long header; + int bsnum; + real synth_buffs[2][2][0x110]; + int synth_bo; + long outscale; /* volume control default value 32768 */ + long outsamplerate; /* raw output rate default same as mp3 sample rate*/ + struct pcm_workingsample worksample; /* keep the state of the working sample for threads */ + int initmp3; /* flag for first initialisation */ + int longLimit[9][23]; /*sample limits re setting volume */ + int shortLimit[9][14]; + real decwin[512+32]; /* scale table */ + + }; + +#define BOOL int + +#define MP3_ERR -1 +#define MP3_OK 0 +#define MP3_NEED_MORE 1 + + +void InitMP3Constants(void); +BOOL InitMP3(struct mpstr *mp, long outscale); +int decodeMP3(struct mpstr *mp,char *inmemory,int inmemsize, + char *outmemory,int outmemsize,int *done); +void ExitMP3(struct mpstr *mp); + +extern int synth_ntom_set_step(long,long); +extern int synth_ntom(struct mpstr *mp, real *bandPtr,int channel,unsigned char *out,int *pnt); +extern int synth_ntom_mono (struct mpstr *mp, real *bandPtr,unsigned char *samples,int *pnt); +extern int synth_ntom_8bit (real *,int,unsigned char *,int *); +extern int synth_ntom_mono2stereo (real *,unsigned char *,int *); +extern int synth_ntom_8bit_mono (real *,unsigned char *,int *); +extern int synth_ntom_8bit_mono2stereo (real *,unsigned char *,int *); + +extern void init_layer3_sample_limits(struct mpstr *mp, int down_sample_sblimit); +extern void init_layer3_const(void); +extern int do_layer3(struct mpstr *mp,unsigned char *,int *); + +extern void make_decode_tables_scale(struct mpstr *mp, long scaleval); +extern void make_decode_tables_const(void); +extern void make_conv16to8_table(int); + +extern void dct64(real *,real *,real *); + +extern unsigned int get1bit(struct mpstr *mp); +extern unsigned int getbits(struct mpstr *mp, int); +extern unsigned int getbits_fast(struct mpstr *mp, int); +extern int set_pointer(struct mpstr *mp, long backstep); + diff --git a/addons/mp3/tabinit.c b/addons/mp3/tabinit.c new file mode 100644 index 000000000..d3e49f500 --- /dev/null +++ b/addons/mp3/tabinit.c @@ -0,0 +1,81 @@ + +#include + +#include "mpg123.h" +#include "mpglib.h" + +static real cos64[16],cos32[8],cos16[4],cos8[2],cos4[1]; +real *pnts[] = { cos64,cos32,cos16,cos8,cos4 }; + +static long intwinbase[] = { + 0, -1, -1, -1, -1, -1, -1, -2, -2, -2, + -2, -3, -3, -4, -4, -5, -5, -6, -7, -7, + -8, -9, -10, -11, -13, -14, -16, -17, -19, -21, + -24, -26, -29, -31, -35, -38, -41, -45, -49, -53, + -58, -63, -68, -73, -79, -85, -91, -97, -104, -111, + -117, -125, -132, -139, -147, -154, -161, -169, -176, -183, + -190, -196, -202, -208, -213, -218, -222, -225, -227, -228, + -228, -227, -224, -221, -215, -208, -200, -189, -177, -163, + -146, -127, -106, -83, -57, -29, 2, 36, 72, 111, + 153, 197, 244, 294, 347, 401, 459, 519, 581, 645, + 711, 779, 848, 919, 991, 1064, 1137, 1210, 1283, 1356, + 1428, 1498, 1567, 1634, 1698, 1759, 1817, 1870, 1919, 1962, + 2001, 2032, 2057, 2075, 2085, 2087, 2080, 2063, 2037, 2000, + 1952, 1893, 1822, 1739, 1644, 1535, 1414, 1280, 1131, 970, + 794, 605, 402, 185, -45, -288, -545, -814, -1095, -1388, + -1692, -2006, -2330, -2663, -3004, -3351, -3705, -4063, -4425, -4788, + -5153, -5517, -5879, -6237, -6589, -6935, -7271, -7597, -7910, -8209, + -8491, -8755, -8998, -9219, -9416, -9585, -9727, -9838, -9916, -9959, + -9966, -9935, -9863, -9750, -9592, -9389, -9139, -8840, -8492, -8092, + -7640, -7134, -6574, -5959, -5288, -4561, -3776, -2935, -2037, -1082, + -70, 998, 2122, 3300, 4533, 5818, 7154, 8540, 9975, 11455, + 12980, 14548, 16155, 17799, 19478, 21189, 22929, 24694, 26482, 28289, + 30112, 31947, 33791, 35640, 37489, 39336, 41176, 43006, 44821, 46617, + 48390, 50137, 51853, 53534, 55178, 56778, 58333, 59838, 61289, 62684, + 64019, 65290, 66494, 67629, 68692, 69679, 70590, 71420, 72169, 72835, + 73415, 73908, 74313, 74630, 74856, 74992, 75038 }; + +void make_decode_tables_const(void) +{ + int i,k,kr,divv; + real *costab; + + for(i=0;i<5;i++) + { + kr=0x10>>i; divv=0x40>>i; + costab = pnts[i]; + for(k=0;kdecwin; + scaleval = -scaleval; + for(i=0,j=0;i<256;i++,j++,table+=32) + { + if(table < (mp->decwin)+512+16) + table[16] = table[0] = (double) intwinbase[j] / 65536.0 * (double) scaleval; + if(i % 32 == 31) + table -= 1023; + if(i % 64 == 63) + scaleval = - scaleval; + } + + for( /* i=256 */ ;i<512;i++,j--,table+=32) + { + if(table < (mp->decwin)+512+16) + table[16] = table[0] = (double) intwinbase[j] / 65536.0 * (double) scaleval; + if(i % 32 == 31) + table -= 1023; + if(i % 64 == 63) + scaleval = - scaleval; + } +} + + diff --git a/addons/ooh323c/COPYING b/addons/ooh323c/COPYING new file mode 100644 index 000000000..b8306825e --- /dev/null +++ b/addons/ooh323c/COPYING @@ -0,0 +1,341 @@ + GNU GENERAL PUBLIC LICENSE + Version 2, June 1991 + + Copyright (C) 1989, 1991 Free Software Foundation, Inc. + 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change free +software--to make sure the software is free for all its users. This +General Public License applies to most of the Free Software +Foundation's software and to any other program whose authors commit to +using it. (Some other Free Software Foundation software is covered by +the GNU Library General Public License instead.) You can apply it to +your programs, too. + + When we speak of free software, we are referring to freedom, not +price. Our General Public Licenses are designed to make sure that you +have the freedom to distribute copies of free software (and charge for +this service if you wish), that you receive source code or can get it +if you want it, that you can change the software or use pieces of it +in new free programs; and that you know you can do these things. + + To protect your rights, we need to make restrictions that forbid +anyone to deny you these rights or to ask you to surrender the rights. +These restrictions translate to certain responsibilities for you if you +distribute copies of the software, or if you modify it. + + For example, if you distribute copies of such a program, whether +gratis or for a fee, you must give the recipients all the rights that +you have. You must make sure that they, too, receive or can get the +source code. And you must show them these terms so they know their +rights. + + We protect your rights with two steps: (1) copyright the software, and +(2) offer you this license which gives you legal permission to copy, +distribute and/or modify the software. + + Also, for each author's protection and ours, we want to make certain +that everyone understands that there is no warranty for this free +software. If the software is modified by someone else and passed on, we +want its recipients to know that what they have is not the original, so +that any problems introduced by others will not reflect on the original +authors' reputations. + + Finally, any free program is threatened constantly by software +patents. We wish to avoid the danger that redistributors of a free +program will individually obtain patent licenses, in effect making the +program proprietary. To prevent this, we have made it clear that any +patent must be licensed for everyone's free use or not licensed at all. + + The precise terms and conditions for copying, distribution and +modification follow. + + GNU GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License applies to any program or other work which contains +a notice placed by the copyright holder saying it may be distributed +under the terms of this General Public License. The "Program", below, +refers to any such program or work, and a "work based on the Program" +means either the Program or any derivative work under copyright law: +that is to say, a work containing the Program or a portion of it, +either verbatim or with modifications and/or translated into another +language. (Hereinafter, translation is included without limitation in +the term "modification".) Each licensee is addressed as "you". + +Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running the Program is not restricted, and the output from the Program +is covered only if its contents constitute a work based on the +Program (independent of having been made by running the Program). +Whether that is true depends on what the Program does. + + 1. You may copy and distribute verbatim copies of the Program's +source code as you receive it, in any medium, provided that you +conspicuously and appropriately publish on each copy an appropriate +copyright notice and disclaimer of warranty; keep intact all the +notices that refer to this License and to the absence of any warranty; +and give any other recipients of the Program a copy of this License +along with the Program. + +You may charge a fee for the physical act of transferring a copy, and +you may at your option offer warranty protection in exchange for a fee. + + 2. You may modify your copy or copies of the Program or any portion +of it, thus forming a work based on the Program, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) You must cause the modified files to carry prominent notices + stating that you changed the files and the date of any change. + + b) You must cause any work that you distribute or publish, that in + whole or in part contains or is derived from the Program or any + part thereof, to be licensed as a whole at no charge to all third + parties under the terms of this License. + + c) If the modified program normally reads commands interactively + when run, you must cause it, when started running for such + interactive use in the most ordinary way, to print or display an + announcement including an appropriate copyright notice and a + notice that there is no warranty (or else, saying that you provide + a warranty) and that users may redistribute the program under + these conditions, and telling the user how to view a copy of this + License. (Exception: if the Program itself is interactive but + does not normally print such an announcement, your work based on + the Program is not required to print an announcement.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Program, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Program, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Program. + +In addition, mere aggregation of another work not based on the Program +with the Program (or with a work based on the Program) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may copy and distribute the Program (or a work based on it, +under Section 2) in object code or executable form under the terms of +Sections 1 and 2 above provided that you also do one of the following: + + a) Accompany it with the complete corresponding machine-readable + source code, which must be distributed under the terms of Sections + 1 and 2 above on a medium customarily used for software interchange; or, + + b) Accompany it with a written offer, valid for at least three + years, to give any third party, for a charge no more than your + cost of physically performing source distribution, a complete + machine-readable copy of the corresponding source code, to be + distributed under the terms of Sections 1 and 2 above on a medium + customarily used for software interchange; or, + + c) Accompany it with the information you received as to the offer + to distribute corresponding source code. (This alternative is + allowed only for noncommercial distribution and only if you + received the program in object code or executable form with such + an offer, in accord with Subsection b above.) + +The source code for a work means the preferred form of the work for +making modifications to it. For an executable work, complete source +code means all the source code for all modules it contains, plus any +associated interface definition files, plus the scripts used to +control compilation and installation of the executable. However, as a +special exception, the source code distributed need not include +anything that is normally distributed (in either source or binary +form) with the major components (compiler, kernel, and so on) of the +operating system on which the executable runs, unless that component +itself accompanies the executable. + +If distribution of executable or object code is made by offering +access to copy from a designated place, then offering equivalent +access to copy the source code from the same place counts as +distribution of the source code, even though third parties are not +compelled to copy the source along with the object code. + + 4. You may not copy, modify, sublicense, or distribute the Program +except as expressly provided under this License. Any attempt +otherwise to copy, modify, sublicense or distribute the Program is +void, and will automatically terminate your rights under this License. +However, parties who have received copies, or rights, from you under +this License will not have their licenses terminated so long as such +parties remain in full compliance. + + 5. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Program or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Program (or any work based on the +Program), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Program or works based on it. + + 6. Each time you redistribute the Program (or any work based on the +Program), the recipient automatically receives a license from the +original licensor to copy, distribute or modify the Program subject to +these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties to +this License. + + 7. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Program at all. For example, if a patent +license would not permit royalty-free redistribution of the Program by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Program. + +If any portion of this section is held invalid or unenforceable under +any particular circumstance, the balance of the section is intended to +apply and the section as a whole is intended to apply in other +circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system, which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 8. If the distribution and/or use of the Program is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Program under this License +may add an explicit geographical distribution limitation excluding +those countries, so that distribution is permitted only in or among +countries not thus excluded. In such case, this License incorporates +the limitation as if written in the body of this License. + + 9. The Free Software Foundation may publish revised and/or new versions +of the General Public License from time to time. Such new versions will +be similar in spirit to the present version, but may differ in detail to +address new problems or concerns. + +Each version is given a distinguishing version number. If the Program +specifies a version number of this License which applies to it and "any +later version", you have the option of following the terms and conditions +either of that version or of any later version published by the Free +Software Foundation. If the Program does not specify a version number of +this License, you may choose any version ever published by the Free Software +Foundation. + + 10. If you wish to incorporate parts of the Program into other free +programs whose distribution conditions are different, write to the author +to ask for permission. For software which is copyrighted by the Free +Software Foundation, write to the Free Software Foundation; we sometimes +make exceptions for this. Our decision will be guided by the two goals +of preserving the free status of all derivatives of our free software and +of promoting the sharing and reuse of software generally. + + NO WARRANTY + + 11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, THERE IS NO WARRANTY +FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. EXCEPT WHEN +OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY OF ANY KIND, EITHER EXPRESSED +OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS +TO THE QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE +PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, +REPAIR OR CORRECTION. + + 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING +WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR +REDISTRIBUTE THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, +INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING +OUT OF THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED +TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY +YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER +PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Programs + + If you develop a new program, and you want it to be of the greatest +possible use to the public, the best way to achieve this is to make it +free software which everyone can redistribute and change under these terms. + + To do so, attach the following notices to the program. It is safest +to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least +the "copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This program is free software; you can redistribute it and/or modify + it under the terms of the GNU General Public License as published by + the Free Software Foundation; either version 2 of the License, or + (at your option) any later version. + + This program is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + GNU General Public License for more details. + + You should have received a copy of the GNU General Public License + along with this program; if not, write to the Free Software + Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + + +Also add information on how to contact you by electronic and paper mail. + +If the program is interactive, make it output a short notice like this +when it starts in an interactive mode: + + Gnomovision version 69, Copyright (C) year name of author + Gnomovision comes with ABSOLUTELY NO WARRANTY; for details type `show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type `show c' for details. + +The hypothetical commands `show w' and `show c' should show the appropriate +parts of the General Public License. Of course, the commands you use may +be called something other than `show w' and `show c'; they could even be +mouse-clicks or menu items--whatever suits your program. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the program, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the program + `Gnomovision' (which makes passes at compilers) written by James Hacker. + + , 1 April 1989 + Ty Coon, President of Vice + +This General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may +consider it more useful to permit linking proprietary applications with the +library. If this is what you want to do, use the GNU Library General +Public License instead of this License. + diff --git a/addons/ooh323c/README b/addons/ooh323c/README new file mode 100644 index 000000000..e1a5b20e4 --- /dev/null +++ b/addons/ooh323c/README @@ -0,0 +1,95 @@ +Copyright (C) 2004-2005 by Objective Systems, Inc. + +Objective Open H.323 README + +Introduction +Objective Open H.323 stack is a simple H.323 implementation in C. This +package contains the core stack code. For complete H.323 stack package with +examples or for more information visit www.obj-sys.com/open + The ASN.1 messaging code was developed using the Objective Systems ASN1C +compiler to implement the core H.323 specifications (H.225, H.235, +and H.245). Additional code was then developed which makes use of +the compiler generated code for presenting a comparatively high level +stack API. + +Features + +Features supported in this package include the following: + +* H.225/Q.931 - the following message types are supported (including + support for FastStart and H.245 tunneling): + - Setup + - Connect + - Call Proceeding + - Alerting + - Facility + - ReleaseComplete + +* H.225/RAS - the following message types are supported + - GateKeeperRequest / Response + - RegistrationRequest / Response + - AdmissionRequest / Response + - DisengageRequest / Response + +* H.245 - the following message types are supported + - MasterSlaveDetermination + - MasterSlaveDeterminationAck + - MasterSlaveDeterminationReject + - MasterSlaveDeterminationRelease + - TerminalCapabilitySet + - TerminalCapabilitySetReject + - TerminalCapabilitySetRelease + - TerminalCapabilitySetAck + - OpenLogicalChannel + - OpenLogicalChannelAck + - OpenLogicalChannelReject + - CloseLogicalChannel + - CloseLogicalChannelAck + - RequestChannelClose + - RequestChannelCloseAck + - RequestChannelCloseReject + - RequestChannelCloseRelease + + +To run the stack test application chansetup + chansetup - This is a sample program developed for testing multiple calls. + This program allows stack testing by placing multiple calls. The number of + calls, duration of each call and interval between successive calls are + configurable. + +1. Two instances of this program have to be run. Can be run on same machine or + different machines. + +2. First change to chansetup directory. + + cd tests/chansetup + +2. For running listener instance, + + ./h323peer [--use-ip ip] [--use-port port] + + where local ip address and port can be specified for listening to incoming + calls. By default, application determines ip address and uses default H323 + port number 1720. + +3. For running calling instance + + ./h323peer [--use-ip ip] -n -duration + -interval destination + + where all times are in seconds. Interval of 0 means next call will be placed + after current call finishes. "destination" is the dotted ip address of the + endpoint running listener instance. + + NOTE: More sample programs are available in the original ooh323c package + which can be downloaded from www.obj-sys.com/open + +Reporting Problems: + +Report problems you encounter by sending E-mail to support@obj-sys.com. + +If you have any further questions or comments on what you would like to +see in the product or what is difficult to use or understand, please +communicate them to us. Your feedback is important to us. Please let us +know how it works out for you - either good or bad. + diff --git a/addons/ooh323c/src/Makefile.in b/addons/ooh323c/src/Makefile.in new file mode 100644 index 000000000..d3a96024b --- /dev/null +++ b/addons/ooh323c/src/Makefile.in @@ -0,0 +1,564 @@ +# Makefile.in generated by automake 1.6.3 from Makefile.am. +# @configure_input@ + +# Copyright 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002 +# Free Software Foundation, Inc. +# This Makefile.in is free software; the Free Software Foundation +# gives unlimited permission to copy and/or distribute it, +# with or without modifications, as long as this notice is preserved. + +# This program is distributed in the hope that it will be useful, +# but WITHOUT ANY WARRANTY, to the extent permitted by law; without +# even the implied warranty of MERCHANTABILITY or FITNESS FOR A +# PARTICULAR PURPOSE. + +@SET_MAKE@ +SHELL = @SHELL@ + +srcdir = @srcdir@ +top_srcdir = @top_srcdir@ +VPATH = @srcdir@ +prefix = @prefix@ +exec_prefix = @exec_prefix@ + +bindir = @bindir@ +sbindir = @sbindir@ +libexecdir = @libexecdir@ +datadir = @datadir@ +sysconfdir = @sysconfdir@ +sharedstatedir = @sharedstatedir@ +localstatedir = @localstatedir@ +libdir = @libdir@ +infodir = @infodir@ +mandir = @mandir@ +includedir = @includedir@ +oldincludedir = /usr/include +pkgdatadir = $(datadir)/@PACKAGE@ +pkglibdir = $(libdir)/@PACKAGE@ +pkgincludedir = $(includedir)/@PACKAGE@ +top_builddir = ../.. + +ACLOCAL = @ACLOCAL@ +AUTOCONF = @AUTOCONF@ +AUTOMAKE = @AUTOMAKE@ +AUTOHEADER = @AUTOHEADER@ + +am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd +INSTALL = @INSTALL@ +INSTALL_PROGRAM = @INSTALL_PROGRAM@ +INSTALL_DATA = @INSTALL_DATA@ +install_sh_DATA = $(install_sh) -c -m 644 +install_sh_PROGRAM = $(install_sh) -c +install_sh_SCRIPT = $(install_sh) -c +INSTALL_SCRIPT = @INSTALL_SCRIPT@ +INSTALL_HEADER = $(INSTALL_DATA) +transform = @program_transform_name@ +NORMAL_INSTALL = : +PRE_INSTALL = : +POST_INSTALL = : +NORMAL_UNINSTALL = : +PRE_UNINSTALL = : +POST_UNINSTALL = : +host_alias = @host_alias@ +host_triplet = @host@ + +EXEEXT = @EXEEXT@ +OBJEXT = @OBJEXT@ +PATH_SEPARATOR = @PATH_SEPARATOR@ +AMTAR = @AMTAR@ +AS = @AS@ +AWK = @AWK@ +CC = @CC@ +DEPDIR = @DEPDIR@ +DLLTOOL = @DLLTOOL@ +ECHO = @ECHO@ +INSTALLPREFIX = @INSTALLPREFIX@ +INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@ +LIBTOOL = @LIBTOOL@ +LN_S = @LN_S@ +OBJDUMP = @OBJDUMP@ +OOH323CDRIVERDIR = @OOH323CDRIVERDIR@ +OOH323CFLAGS = @OOH323CFLAGS@ +PACKAGE = @PACKAGE@ +RANLIB = @RANLIB@ +STRIP = @STRIP@ +VERSION = @VERSION@ +am__include = @am__include@ +am__quote = @am__quote@ +install_sh = @install_sh@ +AUTOMAKE_OPTIONS = gnu +CFLAGS = @OOH323CFLAGS@ + +noinst_LIBRARIES = libooh323c.a + +libooh323c_a_SOURCES = ooLogChan.h ooLogChan.c ooUtils.c ooUtils.h ooGkClient.h ooGkClient.c context.c ooCommon.h ooDateTime.h ooDateTime.c decode.c dlist.c encode.c errmgmt.c memheap.c memheap.h ooasn1.h ootrace.h ootrace.c oochannels.c oochannels.h ooh245.c ooh245.h oohdr.h ooper.h ooports.c ooports.h ooq931.c ooq931.h ooCapability.c ooCapability.h ooSocket.c ooSocket.h ootypes.h perutil.c eventHandler.c eventHandler.h ooCalls.c ooCalls.h ooStackCmds.c ooStackCmds.h ooh323.c ooh323.h ooh323ep.c ooh323ep.h printHandler.c printHandler.h rtctype.c rtctype.h ooTimer.c ooTimer.h h323/H235-SECURITY-MESSAGESDec.c h323/H235-SECURITY-MESSAGESEnc.c h323/H235-SECURITY-MESSAGES.h h323/H323-MESSAGES.c h323/H323-MESSAGESDec.c h323/H323-MESSAGESEnc.c h323/H323-MESSAGES.h h323/MULTIMEDIA-SYSTEM-CONTROL.c h323/MULTIMEDIA-SYSTEM-CONTROLDec.c h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c h323/MULTIMEDIA-SYSTEM-CONTROL.h + +INCLUDES = -Ih323 + + +#include_HEADERS = ooUtils.h memheap.h ooCommon.h ooDateTime.h ooGkClient.h ooasn1.h oochannels.h ootrace.h ooh245.h ooports.h ooq931.h oohdr.h ooper.h ooSocket.h ooTimer.h ootypes.h eventHandler.h ooCapability.h ooCalls.h ooStackCmds.h ooh323.h ooh323ep.h printHandler.h rtctype.h h323/H235-SECURITY-MESSAGES.h h323/H323-MESSAGES.h h323/MULTIMEDIA-SYSTEM-CONTROL.h +EXTRA_DIST = oostk.dsp +subdir = ooh323c/src +mkinstalldirs = $(SHELL) $(top_srcdir)/config/mkinstalldirs +CONFIG_HEADER = $(top_builddir)/config.h +CONFIG_CLEAN_FILES = +LIBRARIES = $(noinst_LIBRARIES) + +libooh323c_a_AR = $(AR) cru +libooh323c_a_LIBADD = +am_libooh323c_a_OBJECTS = ooLogChan.$(OBJEXT) ooUtils.$(OBJEXT) \ + ooGkClient.$(OBJEXT) context.$(OBJEXT) ooDateTime.$(OBJEXT) \ + decode.$(OBJEXT) dlist.$(OBJEXT) encode.$(OBJEXT) \ + errmgmt.$(OBJEXT) memheap.$(OBJEXT) ootrace.$(OBJEXT) \ + oochannels.$(OBJEXT) ooh245.$(OBJEXT) ooports.$(OBJEXT) \ + ooq931.$(OBJEXT) ooCapability.$(OBJEXT) ooSocket.$(OBJEXT) \ + perutil.$(OBJEXT) eventHandler.$(OBJEXT) ooCalls.$(OBJEXT) \ + ooStackCmds.$(OBJEXT) ooh323.$(OBJEXT) ooh323ep.$(OBJEXT) \ + printHandler.$(OBJEXT) rtctype.$(OBJEXT) ooTimer.$(OBJEXT) \ + H235-SECURITY-MESSAGESDec.$(OBJEXT) \ + H235-SECURITY-MESSAGESEnc.$(OBJEXT) H323-MESSAGES.$(OBJEXT) \ + H323-MESSAGESDec.$(OBJEXT) H323-MESSAGESEnc.$(OBJEXT) \ + MULTIMEDIA-SYSTEM-CONTROL.$(OBJEXT) \ + MULTIMEDIA-SYSTEM-CONTROLDec.$(OBJEXT) \ + MULTIMEDIA-SYSTEM-CONTROLEnc.$(OBJEXT) +libooh323c_a_OBJECTS = $(am_libooh323c_a_OBJECTS) + +DEFS = @DEFS@ +DEFAULT_INCLUDES = -I. -I$(srcdir) -I$(top_builddir) +CPPFLAGS = @CPPFLAGS@ +LDFLAGS = @LDFLAGS@ +LIBS = @LIBS@ +depcomp = $(SHELL) $(top_srcdir)/config/depcomp +am__depfiles_maybe = depfiles +@AMDEP_TRUE@DEP_FILES = ./$(DEPDIR)/H235-SECURITY-MESSAGESDec.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/H323-MESSAGES.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/H323-MESSAGESDec.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/H323-MESSAGESEnc.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/context.Po ./$(DEPDIR)/decode.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/dlist.Po ./$(DEPDIR)/encode.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/errmgmt.Po ./$(DEPDIR)/eventHandler.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/memheap.Po ./$(DEPDIR)/ooCalls.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/ooCapability.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/ooDateTime.Po ./$(DEPDIR)/ooGkClient.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/ooLogChan.Po ./$(DEPDIR)/ooSocket.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/ooStackCmds.Po ./$(DEPDIR)/ooTimer.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/ooUtils.Po ./$(DEPDIR)/oochannels.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/ooh245.Po ./$(DEPDIR)/ooh323.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/ooh323ep.Po ./$(DEPDIR)/ooports.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/ooq931.Po ./$(DEPDIR)/ootrace.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/perutil.Po ./$(DEPDIR)/printHandler.Po \ +@AMDEP_TRUE@ ./$(DEPDIR)/rtctype.Po +COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \ + $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +LTCOMPILE = $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) \ + $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) +CCLD = $(CC) +LINK = $(LIBTOOL) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \ + $(AM_LDFLAGS) $(LDFLAGS) -o $@ +DIST_SOURCES = $(libooh323c_a_SOURCES) +DIST_COMMON = Makefile.am Makefile.in +SOURCES = $(libooh323c_a_SOURCES) + +all: all-am + +.SUFFIXES: +.SUFFIXES: .c .lo .o .obj +$(srcdir)/Makefile.in: Makefile.am $(top_srcdir)/configure.in $(ACLOCAL_M4) + cd $(top_srcdir) && \ + $(AUTOMAKE) --gnu ooh323c/src/Makefile +Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status + cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe) + +AR = ar + +clean-noinstLIBRARIES: + -test -z "$(noinst_LIBRARIES)" || rm -f $(noinst_LIBRARIES) +H235-SECURITY-MESSAGESDec.$(OBJEXT): h323/H235-SECURITY-MESSAGESDec.c +H235-SECURITY-MESSAGESEnc.$(OBJEXT): h323/H235-SECURITY-MESSAGESEnc.c +H323-MESSAGES.$(OBJEXT): h323/H323-MESSAGES.c +H323-MESSAGESDec.$(OBJEXT): h323/H323-MESSAGESDec.c +H323-MESSAGESEnc.$(OBJEXT): h323/H323-MESSAGESEnc.c +MULTIMEDIA-SYSTEM-CONTROL.$(OBJEXT): h323/MULTIMEDIA-SYSTEM-CONTROL.c +MULTIMEDIA-SYSTEM-CONTROLDec.$(OBJEXT): \ + h323/MULTIMEDIA-SYSTEM-CONTROLDec.c +MULTIMEDIA-SYSTEM-CONTROLEnc.$(OBJEXT): \ + h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c +libooh323c.a: $(libooh323c_a_OBJECTS) $(libooh323c_a_DEPENDENCIES) + -rm -f libooh323c.a + $(libooh323c_a_AR) libooh323c.a $(libooh323c_a_OBJECTS) $(libooh323c_a_LIBADD) + $(RANLIB) libooh323c.a + +mostlyclean-compile: + -rm -f *.$(OBJEXT) core *.core + +distclean-compile: + -rm -f *.tab.c + +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H235-SECURITY-MESSAGESDec.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H323-MESSAGES.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H323-MESSAGESDec.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/H323-MESSAGESEnc.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/context.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decode.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/dlist.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encode.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/errmgmt.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/eventHandler.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/memheap.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooCalls.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooCapability.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooDateTime.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooGkClient.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooLogChan.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooSocket.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooStackCmds.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooTimer.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooUtils.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/oochannels.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooh245.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooh323.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooh323ep.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooports.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ooq931.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/ootrace.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/perutil.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/printHandler.Po@am__quote@ +@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/rtctype.Po@am__quote@ + +distclean-depend: + -rm -rf ./$(DEPDIR) + +.c.o: +@AMDEP_TRUE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(COMPILE) -c `test -f '$<' || echo '$(srcdir)/'`$< + +.c.obj: +@AMDEP_TRUE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Po' tmpdepfile='$(DEPDIR)/$*.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(COMPILE) -c `cygpath -w $<` + +.c.lo: +@AMDEP_TRUE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/$*.Plo' tmpdepfile='$(DEPDIR)/$*.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LTCOMPILE) -c -o $@ `test -f '$<' || echo '$(srcdir)/'`$< + +H235-SECURITY-MESSAGESDec.o: h323/H235-SECURITY-MESSAGESDec.c +@AMDEP_TRUE@ source='h323/H235-SECURITY-MESSAGESDec.c' object='H235-SECURITY-MESSAGESDec.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.Po' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESDec.o `test -f 'h323/H235-SECURITY-MESSAGESDec.c' || echo '$(srcdir)/'`h323/H235-SECURITY-MESSAGESDec.c + +H235-SECURITY-MESSAGESDec.obj: h323/H235-SECURITY-MESSAGESDec.c +@AMDEP_TRUE@ source='h323/H235-SECURITY-MESSAGESDec.c' object='H235-SECURITY-MESSAGESDec.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.Po' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESDec.obj `cygpath -w h323/H235-SECURITY-MESSAGESDec.c` + +H235-SECURITY-MESSAGESDec.lo: h323/H235-SECURITY-MESSAGESDec.c +@AMDEP_TRUE@ source='h323/H235-SECURITY-MESSAGESDec.c' object='H235-SECURITY-MESSAGESDec.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.Plo' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESDec.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESDec.lo `test -f 'h323/H235-SECURITY-MESSAGESDec.c' || echo '$(srcdir)/'`h323/H235-SECURITY-MESSAGESDec.c + +H235-SECURITY-MESSAGESEnc.o: h323/H235-SECURITY-MESSAGESEnc.c +@AMDEP_TRUE@ source='h323/H235-SECURITY-MESSAGESEnc.c' object='H235-SECURITY-MESSAGESEnc.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Po' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESEnc.o `test -f 'h323/H235-SECURITY-MESSAGESEnc.c' || echo '$(srcdir)/'`h323/H235-SECURITY-MESSAGESEnc.c + +H235-SECURITY-MESSAGESEnc.obj: h323/H235-SECURITY-MESSAGESEnc.c +@AMDEP_TRUE@ source='h323/H235-SECURITY-MESSAGESEnc.c' object='H235-SECURITY-MESSAGESEnc.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Po' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESEnc.obj `cygpath -w h323/H235-SECURITY-MESSAGESEnc.c` + +H235-SECURITY-MESSAGESEnc.lo: h323/H235-SECURITY-MESSAGESEnc.c +@AMDEP_TRUE@ source='h323/H235-SECURITY-MESSAGESEnc.c' object='H235-SECURITY-MESSAGESEnc.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.Plo' tmpdepfile='$(DEPDIR)/H235-SECURITY-MESSAGESEnc.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H235-SECURITY-MESSAGESEnc.lo `test -f 'h323/H235-SECURITY-MESSAGESEnc.c' || echo '$(srcdir)/'`h323/H235-SECURITY-MESSAGESEnc.c + +H323-MESSAGES.o: h323/H323-MESSAGES.c +@AMDEP_TRUE@ source='h323/H323-MESSAGES.c' object='H323-MESSAGES.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGES.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGES.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGES.o `test -f 'h323/H323-MESSAGES.c' || echo '$(srcdir)/'`h323/H323-MESSAGES.c + +H323-MESSAGES.obj: h323/H323-MESSAGES.c +@AMDEP_TRUE@ source='h323/H323-MESSAGES.c' object='H323-MESSAGES.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGES.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGES.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGES.obj `cygpath -w h323/H323-MESSAGES.c` + +H323-MESSAGES.lo: h323/H323-MESSAGES.c +@AMDEP_TRUE@ source='h323/H323-MESSAGES.c' object='H323-MESSAGES.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGES.Plo' tmpdepfile='$(DEPDIR)/H323-MESSAGES.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGES.lo `test -f 'h323/H323-MESSAGES.c' || echo '$(srcdir)/'`h323/H323-MESSAGES.c + +H323-MESSAGESDec.o: h323/H323-MESSAGESDec.c +@AMDEP_TRUE@ source='h323/H323-MESSAGESDec.c' object='H323-MESSAGESDec.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGESDec.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGESDec.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESDec.o `test -f 'h323/H323-MESSAGESDec.c' || echo '$(srcdir)/'`h323/H323-MESSAGESDec.c + +H323-MESSAGESDec.obj: h323/H323-MESSAGESDec.c +@AMDEP_TRUE@ source='h323/H323-MESSAGESDec.c' object='H323-MESSAGESDec.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGESDec.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGESDec.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESDec.obj `cygpath -w h323/H323-MESSAGESDec.c` + +H323-MESSAGESDec.lo: h323/H323-MESSAGESDec.c +@AMDEP_TRUE@ source='h323/H323-MESSAGESDec.c' object='H323-MESSAGESDec.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGESDec.Plo' tmpdepfile='$(DEPDIR)/H323-MESSAGESDec.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESDec.lo `test -f 'h323/H323-MESSAGESDec.c' || echo '$(srcdir)/'`h323/H323-MESSAGESDec.c + +H323-MESSAGESEnc.o: h323/H323-MESSAGESEnc.c +@AMDEP_TRUE@ source='h323/H323-MESSAGESEnc.c' object='H323-MESSAGESEnc.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGESEnc.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGESEnc.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESEnc.o `test -f 'h323/H323-MESSAGESEnc.c' || echo '$(srcdir)/'`h323/H323-MESSAGESEnc.c + +H323-MESSAGESEnc.obj: h323/H323-MESSAGESEnc.c +@AMDEP_TRUE@ source='h323/H323-MESSAGESEnc.c' object='H323-MESSAGESEnc.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGESEnc.Po' tmpdepfile='$(DEPDIR)/H323-MESSAGESEnc.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESEnc.obj `cygpath -w h323/H323-MESSAGESEnc.c` + +H323-MESSAGESEnc.lo: h323/H323-MESSAGESEnc.c +@AMDEP_TRUE@ source='h323/H323-MESSAGESEnc.c' object='H323-MESSAGESEnc.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/H323-MESSAGESEnc.Plo' tmpdepfile='$(DEPDIR)/H323-MESSAGESEnc.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o H323-MESSAGESEnc.lo `test -f 'h323/H323-MESSAGESEnc.c' || echo '$(srcdir)/'`h323/H323-MESSAGESEnc.c + +MULTIMEDIA-SYSTEM-CONTROL.o: h323/MULTIMEDIA-SYSTEM-CONTROL.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROL.c' object='MULTIMEDIA-SYSTEM-CONTROL.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROL.o `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROL.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROL.c + +MULTIMEDIA-SYSTEM-CONTROL.obj: h323/MULTIMEDIA-SYSTEM-CONTROL.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROL.c' object='MULTIMEDIA-SYSTEM-CONTROL.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROL.obj `cygpath -w h323/MULTIMEDIA-SYSTEM-CONTROL.c` + +MULTIMEDIA-SYSTEM-CONTROL.lo: h323/MULTIMEDIA-SYSTEM-CONTROL.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROL.c' object='MULTIMEDIA-SYSTEM-CONTROL.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.Plo' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROL.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROL.lo `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROL.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROL.c + +MULTIMEDIA-SYSTEM-CONTROLDec.o: h323/MULTIMEDIA-SYSTEM-CONTROLDec.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' object='MULTIMEDIA-SYSTEM-CONTROLDec.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLDec.o `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROLDec.c + +MULTIMEDIA-SYSTEM-CONTROLDec.obj: h323/MULTIMEDIA-SYSTEM-CONTROLDec.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' object='MULTIMEDIA-SYSTEM-CONTROLDec.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLDec.obj `cygpath -w h323/MULTIMEDIA-SYSTEM-CONTROLDec.c` + +MULTIMEDIA-SYSTEM-CONTROLDec.lo: h323/MULTIMEDIA-SYSTEM-CONTROLDec.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' object='MULTIMEDIA-SYSTEM-CONTROLDec.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.Plo' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLDec.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLDec.lo `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROLDec.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROLDec.c + +MULTIMEDIA-SYSTEM-CONTROLEnc.o: h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' object='MULTIMEDIA-SYSTEM-CONTROLEnc.o' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLEnc.o `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c + +MULTIMEDIA-SYSTEM-CONTROLEnc.obj: h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' object='MULTIMEDIA-SYSTEM-CONTROLEnc.obj' libtool=no @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Po' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.TPo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLEnc.obj `cygpath -w h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c` + +MULTIMEDIA-SYSTEM-CONTROLEnc.lo: h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c +@AMDEP_TRUE@ source='h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' object='MULTIMEDIA-SYSTEM-CONTROLEnc.lo' libtool=yes @AMDEPBACKSLASH@ +@AMDEP_TRUE@ depfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.Plo' tmpdepfile='$(DEPDIR)/MULTIMEDIA-SYSTEM-CONTROLEnc.TPlo' @AMDEPBACKSLASH@ +@AMDEP_TRUE@ $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@ + $(LIBTOOL) --mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS) -c -o MULTIMEDIA-SYSTEM-CONTROLEnc.lo `test -f 'h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c' || echo '$(srcdir)/'`h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c +CCDEPMODE = @CCDEPMODE@ + +mostlyclean-libtool: + -rm -f *.lo + +clean-libtool: + -rm -rf .libs _libs + +distclean-libtool: + -rm -f libtool +uninstall-info-am: + +ETAGS = etags +ETAGSFLAGS = + +tags: TAGS + +ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES) + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + mkid -fID $$unique + +TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \ + $(TAGS_FILES) $(LISP) + tags=; \ + here=`pwd`; \ + list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \ + unique=`for i in $$list; do \ + if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \ + done | \ + $(AWK) ' { files[$$0] = 1; } \ + END { for (i in files) print i; }'`; \ + test -z "$(ETAGS_ARGS)$$tags$$unique" \ + || $(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \ + $$tags $$unique + +GTAGS: + here=`$(am__cd) $(top_builddir) && pwd` \ + && cd $(top_srcdir) \ + && gtags -i $(GTAGS_ARGS) $$here + +distclean-tags: + -rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH +DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST) + +top_distdir = ../.. +distdir = $(top_distdir)/$(PACKAGE)-$(VERSION) + +distdir: $(DISTFILES) + @list='$(DISTFILES)'; for file in $$list; do \ + if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \ + dir=`echo "$$file" | sed -e 's,/[^/]*$$,,'`; \ + if test "$$dir" != "$$file" && test "$$dir" != "."; then \ + dir="/$$dir"; \ + $(mkinstalldirs) "$(distdir)$$dir"; \ + else \ + dir=''; \ + fi; \ + if test -d $$d/$$file; then \ + if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \ + cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \ + fi; \ + cp -pR $$d/$$file $(distdir)$$dir || exit 1; \ + else \ + test -f $(distdir)/$$file \ + || cp -p $$d/$$file $(distdir)/$$file \ + || exit 1; \ + fi; \ + done +check-am: all-am +check: check-am +all-am: Makefile $(LIBRARIES) + +installdirs: + +install: install-am +install-exec: install-exec-am +install-data: install-data-am +uninstall: uninstall-am + +install-am: all-am + @$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am + +installcheck: installcheck-am +install-strip: + $(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \ + INSTALL_STRIP_FLAG=-s \ + `test -z '$(STRIP)' || \ + echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install +mostlyclean-generic: + +clean-generic: + +distclean-generic: + -rm -f Makefile $(CONFIG_CLEAN_FILES) + +maintainer-clean-generic: + @echo "This command is intended for maintainers to use" + @echo "it deletes files that may require special tools to rebuild." +clean: clean-am + +clean-am: clean-generic clean-libtool clean-noinstLIBRARIES \ + mostlyclean-am + +distclean: distclean-am + +distclean-am: clean-am distclean-compile distclean-depend \ + distclean-generic distclean-libtool distclean-tags + +dvi: dvi-am + +dvi-am: + +info: info-am + +info-am: + +install-data-am: + +install-exec-am: + +install-info: install-info-am + +install-man: + +installcheck-am: + +maintainer-clean: maintainer-clean-am + +maintainer-clean-am: distclean-am maintainer-clean-generic + +mostlyclean: mostlyclean-am + +mostlyclean-am: mostlyclean-compile mostlyclean-generic \ + mostlyclean-libtool + +uninstall-am: uninstall-info-am + +.PHONY: GTAGS all all-am check check-am clean clean-generic \ + clean-libtool clean-noinstLIBRARIES distclean distclean-compile \ + distclean-depend distclean-generic distclean-libtool \ + distclean-tags distdir dvi dvi-am info info-am install \ + install-am install-data install-data-am install-exec \ + install-exec-am install-info install-info-am install-man \ + install-strip installcheck installcheck-am installdirs \ + maintainer-clean maintainer-clean-generic mostlyclean \ + mostlyclean-compile mostlyclean-generic mostlyclean-libtool \ + tags uninstall uninstall-am uninstall-info-am + + +opt: + $(MAKE) "CFLAGS = -DGNU -D_GNU_SOURCE -D_REENTRANT -O2 -D_COMPACT" all + +debug: + $(MAKE) "CFLAGS = -g -DGNU -D_GNU_SOURCE -D_REENTRANT" all + +profile: + $(MAKE) "CFLAGS = -g -pg -DGNU -D_GNU_SOURCE -D_REENTRANT" all +# Tell versions [3.59,3.63) of GNU make to not export all variables. +# Otherwise a system limit (for SysV at least) may be exceeded. +.NOEXPORT: diff --git a/addons/ooh323c/src/context.c b/addons/ooh323c/src/context.c new file mode 100644 index 000000000..d243f88a0 --- /dev/null +++ b/addons/ooh323c/src/context.c @@ -0,0 +1,140 @@ +/* + * Copyright (C) 1997-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 + +int initContext (OOCTXT* pctxt) +{ + memset (pctxt, 0, sizeof(OOCTXT)); + + memHeapCreate (&pctxt->pTypeMemHeap); + pctxt->pMsgMemHeap = pctxt->pTypeMemHeap; + memHeapAddRef (&pctxt->pMsgMemHeap); + + return ASN_OK; +} + +int initContextBuffer +(OOCTXT* pctxt, const ASN1OCTET* bufaddr, ASN1UINT bufsiz) +{ + if (bufaddr == 0) { + /* dynamic buffer */ + if (bufsiz == 0) bufsiz = ASN_K_ENCBUFSIZ; + pctxt->buffer.data = (ASN1OCTET*) + memHeapAlloc (&pctxt->pMsgMemHeap, bufsiz); + if (!pctxt->buffer.data) return ASN_E_NOMEM; + pctxt->buffer.size = bufsiz; + pctxt->buffer.dynamic = TRUE; + } + else { + /* static buffer */ + pctxt->buffer.data = (ASN1OCTET*) bufaddr; + pctxt->buffer.size = bufsiz; + pctxt->buffer.dynamic = FALSE; + } + + pctxt->buffer.byteIndex = 0; + pctxt->buffer.bitOffset = 8; + + return ASN_OK; +} + +int initSubContext (OOCTXT* pctxt, OOCTXT* psrc) +{ + int stat = ASN_OK; + memset (pctxt, 0, sizeof(OOCTXT)); + pctxt->pTypeMemHeap = psrc->pTypeMemHeap; + memHeapAddRef (&pctxt->pTypeMemHeap); + pctxt->pMsgMemHeap = psrc->pMsgMemHeap; + memHeapAddRef (&pctxt->pMsgMemHeap); + pctxt->flags = psrc->flags; + pctxt->buffer.dynamic = TRUE; + pctxt->buffer.byteIndex = 0; + pctxt->buffer.bitOffset = 8; + return stat; +} + +void freeContext (OOCTXT* pctxt) +{ + ASN1BOOL saveBuf = (pctxt->flags & ASN1SAVEBUF) != 0; + + if (pctxt->buffer.dynamic && pctxt->buffer.data) { + if (saveBuf) { + memHeapMarkSaved (&pctxt->pMsgMemHeap, pctxt->buffer.data, TRUE); + } + else { + memHeapFreePtr (&pctxt->pMsgMemHeap, pctxt->buffer.data); + } + } + + errFreeParms (&pctxt->errInfo); + + memHeapRelease (&pctxt->pTypeMemHeap); + memHeapRelease (&pctxt->pMsgMemHeap); +} + +void copyContext (OOCTXT* pdest, OOCTXT* psrc) +{ + memcpy (&pdest->buffer, &psrc->buffer, sizeof(ASN1BUFFER)); + pdest->flags = psrc->flags; +} + +void setCtxtFlag (OOCTXT* pctxt, ASN1USINT mask) +{ + pctxt->flags |= mask; +} + +void clearCtxtFlag (OOCTXT* pctxt, ASN1USINT mask) +{ + pctxt->flags &= ~mask; +} + +int setPERBufferUsingCtxt (OOCTXT* pTarget, OOCTXT* pSource) +{ + int stat = initContextBuffer + (pTarget, pSource->buffer.data, pSource->buffer.size); + + if (ASN_OK == stat) { + pTarget->buffer.byteIndex = pSource->buffer.byteIndex; + pTarget->buffer.bitOffset = pSource->buffer.bitOffset; + } + + return stat; +} + +int setPERBuffer (OOCTXT* pctxt, + ASN1OCTET* bufaddr, ASN1UINT bufsiz, ASN1BOOL aligned) +{ + int stat = initContextBuffer (pctxt, bufaddr, bufsiz); + if(stat != ASN_OK) return stat; + + + return ASN_OK; +} + +OOCTXT* newContext () +{ + OOCTXT* pctxt = (OOCTXT*) ASN1CRTMALLOC0 (sizeof(OOCTXT)); + if (pctxt) { + if (initContext(pctxt) != ASN_OK) { + ASN1CRTFREE0 (pctxt); + pctxt = 0; + } + pctxt->flags |= ASN1DYNCTXT; + } + return (pctxt); +} diff --git a/addons/ooh323c/src/decode.c b/addons/ooh323c/src/decode.c new file mode 100644 index 000000000..d09247c94 --- /dev/null +++ b/addons/ooh323c/src/decode.c @@ -0,0 +1,1050 @@ +/* + * Copyright (C) 1997-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" + +static int decode16BitConstrainedString +(OOCTXT* pctxt, Asn116BitCharString* pString, Asn116BitCharSet* pCharSet); + +static int decodeOctets +(OOCTXT* pctxt, ASN1OCTET* pbuffer, ASN1UINT bufsiz, ASN1UINT nbits); + +static int getComponentLength (OOCTXT* pctxt, ASN1UINT itemBits); + +int decodeBits (OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT nbits) +{ + unsigned char mask; + + if (nbits == 0) { + *pvalue = 0; + return ASN_OK; + } + + /* If the number of bits is less than the current bit offset, mask */ + /* off the required number of bits and return.. */ + + if (nbits < (unsigned)pctxt->buffer.bitOffset) { + /* Check if buffer contains number of bits requested */ + + if (pctxt->buffer.byteIndex >= pctxt->buffer.size) + return LOG_ASN1ERR (pctxt, ASN_E_ENDOFBUF); + + pctxt->buffer.bitOffset -= nbits; + + *pvalue = ((pctxt->buffer.data[pctxt->buffer.byteIndex]) >> + pctxt->buffer.bitOffset) & ((1 << nbits) - 1); + + return ASN_OK; + } + + /* Otherwise, we first need to mask off the remaining bits in the */ + /* current byte, followed by a loop to extract bits from full bytes, */ + /* followed by logic to mask of remaining bits from the start of */ + /* of the last byte.. */ + + else { + /* Check if buffer contains number of bits requested */ + + int nbytes = (((nbits - pctxt->buffer.bitOffset) + 7) / 8); + + if ((pctxt->buffer.byteIndex + nbytes) >= pctxt->buffer.size) { + return LOG_ASN1ERR (pctxt, ASN_E_ENDOFBUF); + } + + /* first read current byte remaining bits */ + mask = ((1 << pctxt->buffer.bitOffset) - 1); + + *pvalue = (pctxt->buffer.data[pctxt->buffer.byteIndex]) & mask; + + nbits -= pctxt->buffer.bitOffset; + pctxt->buffer.bitOffset = 8; + pctxt->buffer.byteIndex++; + + /* second read bytes from next byteIndex */ + while (nbits >= 8) { + *pvalue = (*pvalue << 8) | + (pctxt->buffer.data[pctxt->buffer.byteIndex]); + pctxt->buffer.byteIndex++; + nbits -= 8; + } + + /* third read bits & set bitoffset of the byteIndex */ + if (nbits > 0) { + pctxt->buffer.bitOffset = 8 - nbits; + *pvalue = (*pvalue << nbits) | + ((pctxt->buffer.data[pctxt->buffer.byteIndex]) >> + pctxt->buffer.bitOffset); + } + + return ASN_OK; + } +} + +int decodeBitString +(OOCTXT* pctxt, ASN1UINT* numbits_p, ASN1OCTET* buffer, ASN1UINT bufsiz) +{ + ASN1UINT bitcnt; + int lstat, octidx = 0, stat; + Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint; + ASN1BOOL doAlign; + + for (*numbits_p = 0;;) { + lstat = decodeLength (pctxt, &bitcnt); + if (lstat < 0) return LOG_ASN1ERR (pctxt, lstat); + + if (bitcnt > 0) { + *numbits_p += bitcnt; + + stat = bitAndOctetStringAlignmentTest + (pSizeList, bitcnt, TRUE, &doAlign); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + if (doAlign) { + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + stat = decodeOctets (pctxt, &buffer[octidx], bufsiz - octidx, bitcnt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + if (lstat == ASN_OK_FRAG) { + octidx += (bitcnt / 8); + } + else break; + } + + return ASN_OK; +} + +int decodeBMPString +(OOCTXT* pctxt, ASN1BMPString* pvalue, Asn116BitCharSet* permCharSet) +{ + Asn116BitCharSet charSet; + int stat; + + /* Set character set */ + + init16BitCharSet (&charSet, BMP_FIRST, BMP_LAST, BMP_ABITS, BMP_UBITS); + + if (permCharSet) { + set16BitCharSet (pctxt, &charSet, permCharSet); + } + + /* Decode constrained string */ + + stat = decode16BitConstrainedString (pctxt, pvalue, &charSet); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + return (stat); +} + +int decodeByteAlign (OOCTXT* pctxt) +{ + if (pctxt->buffer.bitOffset != 8) { + pctxt->buffer.byteIndex++; + pctxt->buffer.bitOffset = 8; + } + return ASN_OK; +} + +int decodeConstrainedStringEx +(OOCTXT* pctxt, const char** string, const char* charSet, + ASN1UINT abits, ASN1UINT ubits, ASN1UINT canSetBits) +{ + int stat; + char* tmpstr; + + ASN1UINT i, idx, len, nbits = abits; + + /* note: need to save size constraint for use in alignCharStr */ + /* because it will be cleared in decodeLength from the context.. */ + Asn1SizeCnst* psize = pctxt->pSizeConstraint; + + /* Decode length */ + + stat = decodeLength (pctxt, &len); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + /* Byte-align */ + + if (alignCharStr (pctxt, len, nbits, psize)) { + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + /* Decode data */ + + tmpstr = (char*) ASN1MALLOC (pctxt, len+1); + if (0 != tmpstr) { + if (nbits >= canSetBits && canSetBits > 4) { + for (i = 0; i < len; i++) { + if ((stat = decodeBits (pctxt, &idx, nbits)) == ASN_OK) { + tmpstr[i] = (char) idx; + } + else break; + } + } + else if (0 != charSet) { + ASN1UINT nchars = strlen (charSet); + for (i = 0; i < len; i++) { + if ((stat = decodeBits (pctxt, &idx, nbits)) == ASN_OK) { + if (idx < nchars) { + tmpstr[i] = charSet[idx]; + } + else return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO); + } + else break; + } + } + else stat = ASN_E_INVPARAM; + + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + tmpstr[i] = '\0'; /* add null-terminator */ + } + else + return LOG_ASN1ERR (pctxt, ASN_E_NOMEM); + + *string = tmpstr; + + return ASN_OK; +} + +int decodeConsInteger +(OOCTXT* pctxt, ASN1INT* pvalue, ASN1INT lower, ASN1INT upper) +{ + ASN1UINT range_value = upper - lower; + ASN1UINT adjusted_value; + int stat = ASN_OK; + + if (range_value != ASN1UINT_MAX) { range_value += 1; } + + if (lower > upper) + return ASN_E_RANGERR; + else if (lower != upper) { + stat = decodeConsWholeNumber (pctxt, &adjusted_value, range_value); + if (stat == ASN_OK) { + *pvalue = adjusted_value + lower; + + if (*pvalue < lower || *pvalue > upper) + stat = ASN_E_CONSVIO; + } + } + else { + *pvalue = lower; + } + + return stat; +} + +int decodeConsUInt8 +(OOCTXT* pctxt, ASN1UINT8* pvalue, ASN1UINT lower, ASN1UINT upper) +{ + ASN1UINT range_value, value; + ASN1UINT adjusted_value; + int stat = ASN_OK; + + /* Check for special case: if lower is 0 and upper is ASN1UINT_MAX, */ + /* set range to ASN1UINT_MAX; otherwise to upper - lower + 1 */ + + range_value = (lower == 0 && upper == ASN1UINT_MAX) ? + ASN1UINT_MAX : upper - lower + 1; + + if (lower != upper) { + ASN1UINT range_bitcnt; + + /* If range is <= 255, bit-field case (10.5.7a) */ + + if (range_value <= 255) { + range_bitcnt = getUIntBitCount (range_value - 1); + } + + /* If range is exactly 256, one-octet case (10.5.7b) */ + + else if (range_value == 256) { + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + range_bitcnt = 8; + } + stat = decodeBits (pctxt, &adjusted_value, range_bitcnt); + if (stat == ASN_OK) { + value = adjusted_value + lower; + + if (value < lower || value > upper) + stat = ASN_E_CONSVIO; + + *pvalue = (ASN1OCTET)value; + } + } + else *pvalue = (ASN1OCTET)lower; + + return stat; +} + +int decodeConsUInt16 +(OOCTXT* pctxt, ASN1USINT* pvalue, ASN1UINT lower, ASN1UINT upper) +{ + ASN1UINT range_value, value; + ASN1UINT adjusted_value; + int stat = ASN_OK; + + /* Check for special case: if lower is 0 and upper is ASN1UINT_MAX, */ + /* set range to ASN1UINT_MAX; otherwise to upper - lower + 1 */ + + range_value = (lower == 0 && upper == ASN1UINT_MAX) ? + ASN1UINT_MAX : upper - lower + 1; + + if (lower != upper) { + stat = decodeConsWholeNumber (pctxt, &adjusted_value, range_value); + if (stat == ASN_OK) { + value = adjusted_value + lower; + + /* Verify value is within given range (ED, 1/15/2002) */ + if (value < lower || value > upper) + stat = ASN_E_CONSVIO; + *pvalue = (ASN1USINT) value; + } + } + else *pvalue = (ASN1USINT) lower; + + return stat; +} + +int decodeConsUnsigned +(OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT lower, ASN1UINT upper) +{ + ASN1UINT range_value; + ASN1UINT adjusted_value; + int stat = ASN_OK; + + /* Check for special case: if lower is 0 and upper is ASN1UINT_MAX, */ + /* set range to ASN1UINT_MAX; otherwise to upper - lower + 1 */ + + range_value = (lower == 0 && upper == ASN1UINT_MAX) ? + ASN1UINT_MAX : upper - lower + 1; + + if (lower != upper) { + stat = decodeConsWholeNumber (pctxt, &adjusted_value, range_value); + if (stat == ASN_OK) { + *pvalue = adjusted_value + lower; + if (*pvalue < lower || *pvalue > upper) + stat = ASN_E_CONSVIO; + } + } + else *pvalue = lower; + + return stat; +} + +int decodeConsWholeNumber +(OOCTXT* pctxt, ASN1UINT* padjusted_value, ASN1UINT range_value) +{ + ASN1UINT nocts, range_bitcnt; + int stat; + + /* If unaligned, decode non-negative binary integer in the minimum */ + /* number of bits necessary to represent the range (10.5.6) */ + + if (!TRUE) { + range_bitcnt = getUIntBitCount (range_value - 1); + } + + /* If aligned, encoding depended on range value (10.5.7) */ + + else { /* aligned */ + + /* If range is <= 255, bit-field case (10.5.7a) */ + + if (range_value <= 255) { + range_bitcnt = getUIntBitCount (range_value - 1); + } + + /* If range is exactly 256, one-octet case (10.5.7b) */ + + else if (range_value == 256) { + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + range_bitcnt = 8; + } + + /* If range > 256 and <= 64k (65535), two-octet case (10.5.7c) */ + + else if (range_value <= 65536) { + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + range_bitcnt = 16; + } + + /* If range > 64k, indefinite-length case (10.5.7d) */ + + else { + stat = decodeBits (pctxt, &nocts, 2); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + range_bitcnt = (nocts + 1) * 8; + } + } + + return decodeBits (pctxt, padjusted_value, range_bitcnt); +} + +int decodeDynBitString (OOCTXT* pctxt, ASN1DynBitStr* pBitStr) +{ + ASN1UINT nocts; + ASN1OCTET* ptmp; + int nbits, stat = ASN_OK; + + /* If "fast copy" option is not set (ASN1FATSCOPY) or if constructed, + * copy the bit string value into a dynamic memory buffer; + * otherwise, store the pointer to the value in the decode + * buffer in the data pointer argument. */ + + if (pctxt->flags & ASN1FASTCOPY) { + /* check is it possible to do optimized decoding */ + + ASN1OCTET bit; + ASN1UINT byteIndex = pctxt->buffer.byteIndex; /* save byte index */ + ASN1USINT bitOffset = pctxt->buffer.bitOffset; /* save bit offset */ + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = DECODEBIT (pctxt, &bit); /* read first bit of length determinant */ + if (bit == 1 && stat == ASN_OK) + stat = DECODEBIT (pctxt, &bit); /* read second bit */ + + pctxt->buffer.byteIndex = byteIndex; /* restore byte index */ + pctxt->buffer.bitOffset = bitOffset; /* restore bit offset */ + + /* if either first or second bit != 0 - not fragmented */ + + if (bit == 0 && stat == ASN_OK) { + ASN1UINT bitcnt; + + stat = decodeLength (pctxt, &bitcnt); + if (stat != 0) return LOG_ASN1ERR (pctxt, stat); + + pBitStr->numbits = bitcnt; + if (bitcnt > 0) { + pBitStr->data = ASN1BUFPTR (pctxt); + + stat = moveBitCursor (pctxt, bitcnt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + else + pBitStr->data = 0; + + return stat; + } + } + + nbits = getComponentLength (pctxt, 1); + + if (nbits < 0) return LOG_ASN1ERR (pctxt, nbits); + else if (nbits == 0) { + pBitStr->numbits = 0; + ptmp = 0; + } + + nocts = (nbits + 7) / 8; + + /* Allocate memory for the target string */ + + if (nocts > 0) { + ptmp = (ASN1OCTET*) ASN1MALLOC (pctxt, nocts); + if (0 == ptmp) return LOG_ASN1ERR (pctxt, ASN_E_NOMEM); + + /* Call static bit string decode function */ + + stat = decodeBitString (pctxt, &pBitStr->numbits, ptmp, nocts); + } + pBitStr->data = ptmp; + + return stat; +} + +int decodeDynOctetString (OOCTXT* pctxt, ASN1DynOctStr* pOctStr) +{ + ASN1OCTET* ptmp; + int nocts, stat; + + /* If "fast copy" option is not set (ASN1FASTCOPY) or if constructed, + * copy the octet string value into a dynamic memory buffer; + * otherwise, store the pointer to the value in the decode + * buffer in the data pointer argument. */ + + if (pctxt->flags & ASN1FASTCOPY) { + /* check if it is possible to do optimized decoding */ + + ASN1OCTET bit; + ASN1UINT byteIndex = pctxt->buffer.byteIndex; /* save byte index */ + ASN1USINT bitOffset = pctxt->buffer.bitOffset; /* save bit offset */ + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = DECODEBIT (pctxt, &bit); /* read first bit of length determinant */ + if (bit == 1 && stat == ASN_OK) + stat = DECODEBIT (pctxt, &bit); /* read second bit */ + + pctxt->buffer.byteIndex = byteIndex; /* restore byte index */ + pctxt->buffer.bitOffset = bitOffset; /* restore bit offset */ + + /* if either first or second bit != 0 - not fragmented */ + + if (bit == 0 && stat == ASN_OK) { + ASN1UINT octcnt; + + stat = decodeLength (pctxt, &octcnt); + if (stat != 0) return LOG_ASN1ERR (pctxt, stat); + + pOctStr->numocts = octcnt; + if (octcnt > 0) { + pOctStr->data = ASN1BUFPTR (pctxt); + + stat = moveBitCursor (pctxt, octcnt * 8); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + else + pOctStr->data = 0; + + return stat; + } + } + + nocts = getComponentLength (pctxt, 8); + + if (nocts < 0) return LOG_ASN1ERR (pctxt, nocts); + else if (nocts == 0) { + pOctStr->numocts = 0; + ptmp = 0; + } + + /* Allocate memory for the target string */ + + else { + ptmp = (ASN1OCTET*) ASN1MALLOC (pctxt, nocts); + if (0 == ptmp) return LOG_ASN1ERR (pctxt, ASN_E_NOMEM); + } + + /* Call static octet string decode function */ + + stat = decodeOctetString (pctxt, &pOctStr->numocts, ptmp, nocts); + + pOctStr->data = ptmp; + + return stat; +} + +int decodeLength (OOCTXT* pctxt, ASN1UINT* pvalue) +{ + Asn1SizeCnst* pSize; + ASN1UINT lower, upper; + ASN1BOOL bitValue, extbit; + int stat; + + /* If size constraint is present and extendable, decode extension */ + /* bit.. */ + + if (isExtendableSize(pctxt->pSizeConstraint)) { + stat = DECODEBIT (pctxt, &extbit); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + else extbit = 0; + + /* Now use the value of the extension bit to select the proper */ + /* size constraint range specification.. */ + + pSize = getSizeConstraint (pctxt, extbit); + + lower = (pSize) ? pSize->lower : 0; + upper = (pSize) ? pSize->upper : ASN1UINT_MAX; + + /* Reset the size constraint in the context block structure */ + + pctxt->pSizeConstraint = 0; + + /* If upper limit is less than 64k, constrained case */ + + if (upper < 65536) { + if (lower == upper) { + *pvalue = 0; + stat = ASN_OK; + } + else + stat = decodeConsWholeNumber (pctxt, pvalue, (upper - lower + 1)); + + if (stat == ASN_OK) *pvalue += lower; + } + else { + /* unconstrained case OR constrained with upper bound >= 64K*/ + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = DECODEBIT (pctxt, &bitValue); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + if (bitValue == 0) { + stat = decodeBits (pctxt, pvalue, 7); /* 10.9.3.6 */ + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + else { + stat = DECODEBIT (pctxt, &bitValue); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + if (bitValue == 0) { + stat = decodeBits (pctxt, pvalue, 14); /* 10.9.3.7 */ + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + else { + ASN1UINT multiplier; + + stat = decodeBits (pctxt, &multiplier, 6); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + *pvalue = 16384 * multiplier; + + stat = ASN_OK_FRAG; + } + } + } + + return stat; +} + +int decodeObjectIdentifier (OOCTXT* pctxt, ASN1OBJID* pvalue) +{ + ASN1UINT len; + int stat, j; + unsigned subid; + ASN1UINT b; + + /* Decode unconstrained length */ + + if ((stat = decodeLength (pctxt, &len)) < 0) { + return LOG_ASN1ERR (pctxt, stat); + } + + /* Copy contents to a byte-aligned local buffer */ + + j = 0; + while (len > 0 && stat == ASN_OK) { + if (j < ASN_K_MAXSUBIDS) { + + /* Parse a subidentifier out of the contents field */ + + pvalue->subid[j] = 0; + do { + if ((stat = decodeBits (pctxt, &b, 8)) == ASN_OK) { + pvalue->subid[j] = (pvalue->subid[j] * 128) + (b & 0x7F); + len--; + } + } while (b & 0x80 && stat == ASN_OK); + + /* Handle the first subidentifier special case: the first two */ + /* sub-id's are encoded into one using the formula (x * 40) + y */ + + if (j == 0) { + subid = pvalue->subid[0]; + pvalue->subid[0] = ((subid / 40) >= 2) ? 2 : subid / 40; + pvalue->subid[1] = (pvalue->subid[0] == 2) ? + subid - 80 : subid % 40; + j = 2; + } + else j++; + } + else + stat = ASN_E_INVOBJID; + } + + pvalue->numids = j; + if (stat == ASN_OK && len != 0) stat = ASN_E_INVLEN; + + return (stat); +} + +static int decodeOctets +(OOCTXT* pctxt, ASN1OCTET* pbuffer, ASN1UINT bufsiz, ASN1UINT nbits) +{ + ASN1UINT nbytes = (nbits + 7) / 8 ; + ASN1UINT i = 0, j; + ASN1UINT rshift = pctxt->buffer.bitOffset; + ASN1UINT lshift = 8 - rshift; + ASN1UINT nbitsInLastOctet; + ASN1OCTET mask; + int stat; + + /* Check to make sure buffer contains number of bits requested */ + + if ((pctxt->buffer.byteIndex + nbytes) > pctxt->buffer.size) { + return LOG_ASN1ERR (pctxt, ASN_E_ENDOFBUF); + } + + /* Check to make sure buffer is big enough to hold requested */ + /* number of bits.. */ + + if (nbytes > bufsiz) { + return LOG_ASN1ERR (pctxt, ASN_E_STROVFLW); + } + + /* If on a byte boundary, can do a direct memcpy to target buffer */ + + if (pctxt->buffer.bitOffset == 8) { + memcpy (pbuffer, &pctxt->buffer.data[pctxt->buffer.byteIndex], nbytes); + stat = moveBitCursor (pctxt, nbits); + if (stat != ASN_OK) return stat; + i = nbytes - 1; nbits %= 8; + } + else { + while (nbits >= 8) { + + /* Transfer lower bits from stream octet to upper bits of */ + /* target octet.. */ + + pbuffer[i] = pctxt->buffer.data[pctxt->buffer.byteIndex++] + << lshift; + + /* Transfer upper bits from next stream octet to lower bits */ + /* target octet.. */ + + pbuffer[i++] |= pctxt->buffer.data[pctxt->buffer.byteIndex] + >> rshift; + + nbits -= 8; + } + + /* Copy last partial byte */ + + if (nbits >= rshift) { + pbuffer[i] = + pctxt->buffer.data[pctxt->buffer.byteIndex++] << lshift; + + nbitsInLastOctet = nbits - rshift; + + if (nbitsInLastOctet > 0) { + pbuffer[i] |= + pctxt->buffer.data[pctxt->buffer.byteIndex] >> rshift; + } + + pctxt->buffer.bitOffset = 8 - nbitsInLastOctet; + } + else if (nbits > 0) { /* nbits < rshift */ + pbuffer[i] = + pctxt->buffer.data[pctxt->buffer.byteIndex] << lshift; + pctxt->buffer.bitOffset = rshift - nbits; + } + } + + /* Mask unused bits off of last byte */ + + if (nbits > 0) { + mask = 0; + for (j = 0; j < nbits; j++) { + mask >>= 1; + mask |= 0x80; + } + pbuffer[i] &= mask; + } + + return ASN_OK; +} + +int decodeOctetString +(OOCTXT* pctxt, ASN1UINT* numocts_p, ASN1OCTET* buffer, ASN1UINT bufsiz) +{ + ASN1UINT octcnt; + int lstat, octidx = 0, stat; + Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint; + + for (*numocts_p = 0;;) { + lstat = decodeLength (pctxt, &octcnt); + if (lstat < 0) return LOG_ASN1ERR (pctxt, lstat); + + if (octcnt > 0) { + *numocts_p += octcnt; + + if (TRUE) { + ASN1BOOL doAlign; + + stat = bitAndOctetStringAlignmentTest + (pSizeList, octcnt, FALSE, &doAlign); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + if (doAlign) { + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + } + + stat = decodeOctets (pctxt, &buffer[octidx], + bufsiz - octidx, (octcnt * 8)); + + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + if (lstat == ASN_OK_FRAG) { + octidx += octcnt; + } + else break; + } + + return ASN_OK; +} + +int decodeOpenType +(OOCTXT* pctxt, const ASN1OCTET** object_p2, ASN1UINT* numocts_p) +{ + ASN1DynOctStr octStr; + int stat; + + stat = decodeDynOctetString (pctxt, &octStr); + if (stat == ASN_OK) { + *numocts_p = octStr.numocts; + *object_p2 = octStr.data; + } + + return stat; +} + +int decodeSemiConsInteger (OOCTXT* pctxt, ASN1INT* pvalue, ASN1INT lower) +{ + signed char b; + unsigned char ub; + ASN1UINT nbytes; + int stat; + + stat = decodeLength (pctxt, &nbytes); + if (stat < 0) return LOG_ASN1ERR (pctxt, stat); + + if (nbytes > 0) { + + /* Align buffer */ + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + /* Decode first byte into a signed byte value and assign to integer. */ + /* This should handle sign extension.. */ + + stat = decodeOctets (pctxt, (ASN1OCTET*)&b, 1, 8); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + *pvalue = b; + nbytes--; + + /* Decode remaining bytes and add to result */ + + while (nbytes > 0) { + stat = decodeOctets (pctxt, (ASN1OCTET*)&ub, 1, 8); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + *pvalue = (*pvalue * 256) + ub; + nbytes--; + } + } + else { /* nbytes == 0 */ + *pvalue = 0; + } + if (lower > ASN1INT_MIN) + *pvalue += lower; + + return ASN_OK; +} + +int decodeSemiConsUnsigned (OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT lower) +{ + ASN1UINT nbytes; + int stat; + + stat = decodeLength (pctxt, &nbytes); + if (stat < 0) return LOG_ASN1ERR (pctxt, stat); + + + if (nbytes > 0) { + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = decodeBits (pctxt, pvalue, nbytes * 8); + } + else + *pvalue = 0; + *pvalue += lower; + + return stat; +} + +int decodeSmallNonNegWholeNumber (OOCTXT* pctxt, ASN1UINT* pvalue) +{ + ASN1BOOL bitValue; + ASN1UINT len; + int ret; + + if ((ret = DECODEBIT (pctxt, &bitValue)) != ASN_OK) + return ret; + + if (bitValue == 0) { + return decodeBits (pctxt, pvalue, 6); /* 10.6.1 */ + } + else { + if ((ret = decodeLength (pctxt, &len)) < 0) + return ret; + + if ((ret = decodeByteAlign (pctxt)) != ASN_OK) + return ret; + + return decodeBits (pctxt, pvalue, len*8); + } +} + +int decodeVarWidthCharString (OOCTXT* pctxt, const char** pvalue) +{ + int stat; + ASN1OCTET* tmpstr; + ASN1UINT len; + + /* note: need to save size constraint for use in alignCharStr */ + /* because it will be cleared in decodeLength from the context.. */ + Asn1SizeCnst* psize = pctxt->pSizeConstraint; + + /* Decode length */ + + stat = decodeLength (pctxt, &len); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + /* Byte-align */ + + if (alignCharStr (pctxt, len, 8, psize)) { + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + /* Decode data */ + + tmpstr = (ASN1OCTET*) ASN1MALLOC (pctxt, len + 1); + if (0 != tmpstr) { + if ((stat = decodeOctets (pctxt, tmpstr, len, len * 8)) != ASN_OK) + return LOG_ASN1ERR (pctxt, stat); + + tmpstr[len] = '\0'; /* add null-terminator */ + } + else + return LOG_ASN1ERR (pctxt, ASN_E_NOMEM); + + *pvalue = (char*)tmpstr; + + return ASN_OK; +} + +static int decode16BitConstrainedString +(OOCTXT* pctxt, Asn116BitCharString* pString, Asn116BitCharSet* pCharSet) +{ + ASN1UINT i, idx, nbits = pCharSet->alignedBits; + int stat; + + /* Decode length */ + + stat = decodeLength (pctxt, &pString->nchars); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + /* Byte-align */ + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + /* Decode data */ + + pString->data = (ASN116BITCHAR*) + ASN1MALLOC (pctxt, pString->nchars*sizeof(ASN116BITCHAR)); + + if (pString->data) { + for (i = 0; i < pString->nchars; i++) { + stat = decodeBits (pctxt, &idx, nbits); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + pString->data[i] = (pCharSet->charSet.data == 0) ? + idx + pCharSet->firstChar : pCharSet->charSet.data[idx]; + } + } + else + return LOG_ASN1ERR (pctxt, ASN_E_NOMEM); + + return ASN_OK; +} + +static int getComponentLength (OOCTXT* pctxt, ASN1UINT itemBits) +{ + OOCTXT lctxt; + ASN1UINT len, totalLen = 0; + int stat; + + stat = initSubContext (&lctxt, pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = setPERBufferUsingCtxt (&lctxt, pctxt); + if (stat != ASN_OK) { + freeContext (&lctxt); + return LOG_ASN1ERR (pctxt, stat); + } + lctxt.pSizeConstraint = pctxt->pSizeConstraint; + + for (;;) { + stat = decodeLength (&lctxt, &len); + if (stat < 0) { + freeContext (&lctxt); + return LOG_ASN1ERR (pctxt, stat); + } + + totalLen += len; + + if (stat == ASN_OK_FRAG) { + stat = moveBitCursor (&lctxt, len * itemBits); + if (stat != ASN_OK) { + freeContext (&lctxt); + return LOG_ASN1ERR (pctxt, stat); + } + } + else break; + } + + freeContext (&lctxt); + + return totalLen; +} + +int moveBitCursor (OOCTXT* pctxt, int bitOffset) +{ + int currBitOffset = + (pctxt->buffer.byteIndex * 8) + (8 - pctxt->buffer.bitOffset); + + currBitOffset += bitOffset; + + pctxt->buffer.byteIndex = (currBitOffset / 8); + pctxt->buffer.bitOffset = 8 - (currBitOffset % 8); + + if (pctxt->buffer.byteIndex > pctxt->buffer.size) { + return (ASN_E_ENDOFBUF); + } + + return ASN_OK; +} diff --git a/addons/ooh323c/src/dlist.c b/addons/ooh323c/src/dlist.c new file mode 100644 index 000000000..52fc87d42 --- /dev/null +++ b/addons/ooh323c/src/dlist.c @@ -0,0 +1,256 @@ +/* + * Copyright (C) 1997-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" + +void dListInit (DList* pList) +{ + if (pList) { + pList->count = 0; + pList->head = (DListNode*) 0; + pList->tail = (DListNode*) 0; + } +} + +DListNode* dListAppend (OOCTXT* pctxt, DList* pList, void* pData) +{ + DListNode* pListNode = (DListNode*) + memAlloc (pctxt, sizeof(DListNode)); + + if (0 != pListNode) { + pListNode->data = pData; + pListNode->next = (DListNode*) 0; + if (0 != pList->tail) { + pList->tail->next = pListNode; + pListNode->prev = pList->tail; + } + if (0 == pList->head) { + pList->head = pListNode; + pListNode->prev = (DListNode*) 0; + } + pList->tail = pListNode; + pList->count++; + } + + return pListNode; +} + +DListNode* dListAppendNode (OOCTXT* pctxt, DList* pList, void* pData) +{ + DListNode* pListNode = + (DListNode*) (((char*)pData) - sizeof(DListNode)); + + if (0 != pListNode) { + pListNode->data = pData; + pListNode->next = (DListNode*) 0; + if (0 != pList->tail) { + pList->tail->next = pListNode; + pListNode->prev = pList->tail; + } + if (0 == pList->head) { + pList->head = pListNode; + pListNode->prev = (DListNode*) 0; + } + pList->tail = pListNode; + pList->count++; + } + + return pListNode; +} + +/* Delete the head node from the list and return the data item stored */ +/* in that node.. */ + +void* dListDeleteHead (OOCTXT* pctxt, DList* pList) +{ + DListNode* pNode = (0 != pList) ? pList->head : 0; + if (0 != pNode) { + void* pdata = pNode->data; + dListRemove (pList, pNode); + memFreePtr (pctxt, pNode); + return pdata; + } + return 0; +} + +/* Free all nodes, but not the data */ +void dListFreeNodes (OOCTXT* pctxt, DList* pList) +{ + DListNode* pNode, *pNextNode; + + for (pNode = pList->head; pNode != 0; pNode = pNextNode) { + pNextNode = pNode->next; + memFreePtr (pctxt, pNode); + } + pList->count = 0; + pList->head = pList->tail = 0; +} + +/* Free all nodes and their data */ +void dListFreeAll (OOCTXT* pctxt, DList* pList) +{ + DListNode* pNode, *pNextNode; + + for (pNode = pList->head; pNode != 0; pNode = pNextNode) { + pNextNode = pNode->next; + + memFreePtr (pctxt, pNode->data); + memFreePtr (pctxt, pNode); + } + pList->count = 0; + pList->head = pList->tail = 0; +} + +/* Remove node from list. Node is not freed */ +void dListRemove (DList* pList, DListNode* node) +{ + if(node->next != 0) { + node->next->prev = node->prev; + } + else { /* tail */ + pList->tail = node->prev; + } + if(node->prev != 0) { + node->prev->next = node->next; + } + else { /* head */ + pList->head = node->next; + } + pList->count--; +} + +void dListFindAndRemove(DList* pList, void *data) +{ + DListNode *pNode, *pNextNode; + for(pNode = pList->head; pNode !=0; pNode = pNextNode){ + pNextNode = pNode->next; + if(pNode->data == data) /* pointer comparison*/ + break; + } + if(pNode) + dListRemove(pList, pNode); +} + +DListNode* dListFindByIndex (DList* pList, int index) +{ + DListNode* curNode; + int i; + + if(index >= (int)pList->count) return 0; + for(i = 0, curNode = pList->head; i < index && curNode != 0; i++) { + curNode = curNode->next; + } + return curNode; +} + +/* Insert item before given node */ + +DListNode* dListInsertBefore +(OOCTXT* pctxt, DList* pList, DListNode* node, const void* pData) +{ + DListNode* pListNode = (DListNode*) memAlloc (pctxt, sizeof(DListNode)); + + if (0 != pListNode) { + pListNode->data = (void*)pData; + + if (node == 0) { /* insert before end (as last element) */ + pListNode->next = (DListNode*) 0; + if (0 != pList->tail) { + pList->tail->next = pListNode; + pListNode->prev = pList->tail; + } + if (0 == pList->head) { + pList->head = pListNode; + pListNode->prev = (DListNode*) 0; + } + pList->tail = pListNode; + } + else if (node == pList->head) { /* insert as head (head case) */ + pListNode->next = pList->head; + pListNode->prev = (DListNode*) 0; + if(pList->head != 0) { + pList->head->prev = pListNode; + } + if(pList->tail == 0) { + pList->tail = pListNode; + } + pList->head = pListNode; + } + else { /* other cases */ + pListNode->next = node; + pListNode->prev = node->prev; + node->prev = pListNode; + /* here, pListNode->prev always should be non-zero, + * because if pListNode->prev is zero - it is head case (see above). + */ + pListNode->prev->next = pListNode; + } + + pList->count++; + } + + return pListNode; +} + +/* Insert item after given node */ + +DListNode* dListInsertAfter +(OOCTXT* pctxt, DList* pList, DListNode* node, const void* pData) +{ + DListNode* pListNode = (DListNode*) memAlloc (pctxt, sizeof(DListNode)); + + if (0 != pListNode) { + pListNode->data = (void*)pData; + + if (node == 0) { /* insert as head (as first element) */ + pListNode->next = pList->head; + pListNode->prev = (DListNode*) 0; + if (pList->head != 0) { + pList->head->prev = pListNode; + } + if (pList->tail == 0) { + pList->tail = pListNode; + } + pList->head = pListNode; + } + else if (node == pList->tail) { /* insert as tail (as last element) */ + pListNode->next = (DListNode*) 0; + if (0 != pList->tail) { + pList->tail->next = pListNode; + pListNode->prev = pList->tail; + } + if (0 == pList->head) { + pList->head = pListNode; + pListNode->prev = (DListNode*) 0; + } + pList->tail = pListNode; + } + else { /* other cases */ + pListNode->next = node->next; + pListNode->prev = node; + node->next = pListNode; + /* here, pListNode->next always should be non-zero, + * because if pListNode->next is zero - it is tail case (see above). + */ + pListNode->next->prev = pListNode; + } + + pList->count++; + } + + return pListNode; +} + diff --git a/addons/ooh323c/src/dlist.h b/addons/ooh323c/src/dlist.h new file mode 100644 index 000000000..79663d999 --- /dev/null +++ b/addons/ooh323c/src/dlist.h @@ -0,0 +1,204 @@ +/* + * Copyright (C) 1997-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. + * + *****************************************************************************/ +/** + * @file dlist.h + * Doubly-linked list structures and utility functions. + */ +#ifndef _OODLIST_H_ +#define _OODLIST_H_ + +struct OOCTXT; + +/** + * @defgroup llfuns Doubly-linked list structures and utility functions. + * @{ + */ +typedef struct _DListNode { + void* data; + struct _DListNode* next; + struct _DListNode* prev; +} DListNode; + +typedef struct _DList { + unsigned int count; + DListNode* head; + DListNode* tail; +} DList; + +#define ALLOC_ASN1ELEMDNODE(pctxt,type) \ +(type*) (((char*)memHeapAllocZ (&(pctxt)->pTypeMemHeap, sizeof(type) + \ +sizeof(DListNode))) + sizeof(DListNode)) + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#if defined (MAKE_DLL) +#define EXTERN __declspec(dllexport) +#elif defined (USEASN1DLL) +#define EXTERN __declspec(dllimport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +/** + * This function appends an item to the linked list structure. The data item is + * passed into the function as a void pointer that can point to any object of + * any type. The memAlloc function is used to allocated the memory for the + * list node structure; therefore, all internal list memory will be released + * whenever memFree is called. The pointer to the data item itself is stored + * in the node structure - a copy is not made. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pList A pointer to a linked list structure onto which the data + * item is to be appended. A pointer to an updated linked + * list structure. + * @param pData A pointer to a data item to be appended to the list. + * @return A pointer to an allocated node structure used to link + * the given data value into the list. + */ +EXTERN DListNode* dListAppend +(struct OOCTXT* pctxt, DList* pList, void* pData); + +EXTERN DListNode* dListAppendNode +(struct OOCTXT* pctxt, DList* pList, void* pData); + +/** + * This function delete the head item from the list and returns a pointer + * the data item stored in that node. The memory for the node structure + * is released. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pList A pointer to the linked list structure from which + * the node will be deleted. + * @return A pointer to the data item stored in the deleted node. + */ +EXTERN void* dListDeleteHead (struct OOCTXT* pctxt, DList* pList); + +EXTERN DListNode* dListFindByIndex (DList* pList, int index); + +/** + * This function initializes a doubly linked list structure. It sets the number + * of elements to zero and sets all internal pointer values to NULL. A doubly + * linked-list structure is described by the DList type. Nodes of the list + * are of type DListNode. + * + * Memory for the structures is allocated using the memAlloc run-time + * function and is maintained within the context structure that is a required + * parameter to all dList functions. This memory is released when memFree + * is called or the Context is released. Unless otherwise noted, all data + * passed into the list functions is simply stored on the list by value (i.e. a + * deep-copy of the data is not done). + * + * @param pList A pointer to a linked list structure to be initialized. + */ +EXTERN void dListInit (DList* pList); + +/** + * This function removes all nodes from the linked list and releases the memory + * that was allocated for storing the node structures (DListNode). The data + * will not be released. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pList A pointer to a linked list structure onto which the data + * item is to be appended. A pointer to an updated linked + * list structure. + */ +EXTERN void dListFreeNodes (struct OOCTXT* pctxt, DList* pList); + +/** + * This function removes all nodes from the linked list structure and releases + * the memory that was allocated for storing the node structures + * (DListNode) and for data. The memory for data in each node must have + * been previously allocated with calls to memAlloc, memAllocZ, or + * memRealloc functions. + * + * @param pctxt Pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pList Pointer to a linked list structure. + */ +EXTERN void dListFreeAll (struct OOCTXT* pctxt, DList* pList); + +/** + * This function inserts an item into the linked list structure before the + * specified element. + * + * @param pctxt Pointer to a context structure. + * @param pList A pointer to a linked list structure into which the + * data item is to be inserted. + * @param node The position in the list where the item is to be + * inserted. The item will be inserted before this + * node or appended to the list if node is null. + * @param pData A pointer to the data item to be inserted to the list. + * @return A pointer to an allocated node structure used to + * link the given data value into the list. + */ +EXTERN DListNode* dListInsertBefore +(struct OOCTXT* pctxt, DList* pList, DListNode* node, const void* pData); + +/** + * This function inserts an item into the linked list structure after the + * specified element. + * + * @param pctxt Pointer to a context structure. + * @param pList A pointer to a linked list structure into which the + * data item is to be inserted. + * @param node The position in the list where the item is to be + * inserted. The item will be inserted after this + * node or added as the head element if node is null. + * @param pData A pointer to the data item to be inserted to the list. + * @return A pointer to an allocated node structure used to + * link the given data value into the list. + */ +EXTERN DListNode* dListInsertAfter +(struct OOCTXT* pctxt, DList* pList, DListNode* node, const void* pData); + +/** + * This function removes a node from the linked list structure. The memAlloc + * function was used to allocate the memory for the list node structure, + * therefore, all internal list memory will be released whenever memFree or + * memFreePtr is called. + * + * @param pList A pointer to a linked list structure onto which the data + * item is to be removed. A pointer to an updated linked + * list structure. + * @param node A pointer to the node that is to be removed. It should + * already be in the linked list structure. + */ +EXTERN void dListRemove (DList* pList, DListNode* node); +void dListFindAndRemove(DList* pList, void* data); + +/** + * @} + */ +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/encode.c b/addons/ooh323c/src/encode.c new file mode 100644 index 000000000..45e5916df --- /dev/null +++ b/addons/ooh323c/src/encode.c @@ -0,0 +1,1103 @@ +/* + * Copyright (C) 1997-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 +#include "ooasn1.h" + +static int encode16BitConstrainedString +(OOCTXT* pctxt, Asn116BitCharString value, Asn116BitCharSet* pCharSet); + +static int encode2sCompBinInt (OOCTXT* pctxt, ASN1INT value); +static int encodeNonNegBinInt (OOCTXT* pctxt, ASN1UINT value); +static int encodeUnconsLength (OOCTXT* pctxt, ASN1UINT value); +static int getIdentByteCount (ASN1UINT ident); + +int encodeBit (OOCTXT* pctxt, ASN1BOOL value) +{ + int stat = ASN_OK; + + /* If start of new byte, init to zero */ + + if (pctxt->buffer.bitOffset == 8) { + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + } + + /* Adjust bit offset and determine if at end of current byte */ + + if (--pctxt->buffer.bitOffset < 0) { + if (++pctxt->buffer.byteIndex >= pctxt->buffer.size) { + if ((stat = encodeExpandBuffer (pctxt, 1)) != ASN_OK) { + return stat; + } + } + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + pctxt->buffer.bitOffset = 7; + } + + /* Set single-bit value */ + + if (value) { + pctxt->buffer.data[pctxt->buffer.byteIndex] |= + ( 1 << pctxt->buffer.bitOffset ); + } + + /* If last bit in octet, set offsets to start new byte (ED, 9/7/01) */ + + if (pctxt->buffer.bitOffset == 0) { + pctxt->buffer.bitOffset = 8; + pctxt->buffer.byteIndex++; + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + } + + return stat; +} + +int encodeBits (OOCTXT* pctxt, ASN1UINT value, ASN1UINT nbits) +{ + int nbytes = (nbits + 7)/ 8, stat = ASN_OK; + + if (nbits == 0) return stat; + + /* If start of new byte, init to zero */ + + if (pctxt->buffer.bitOffset == 8) { + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + } + + /* Mask off unused bits from the front of the value */ + + if (nbits < (sizeof(ASN1UINT) * 8)) + value &= ((1 << nbits) - 1); + + /* If bits will fit in current byte, set them and return */ + + if (nbits < (unsigned)pctxt->buffer.bitOffset) { + pctxt->buffer.bitOffset -= nbits; + pctxt->buffer.data[pctxt->buffer.byteIndex] |= + ( value << pctxt->buffer.bitOffset ); + return stat; + } + + /* Check buffer space and allocate more memory if necessary */ + + stat = encodeCheckBuffer (pctxt, nbytes); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + /* Set bits in remainder of the current byte and then loop */ + /* to set bits in subsequent bytes.. */ + + nbits -= pctxt->buffer.bitOffset; + pctxt->buffer.data[pctxt->buffer.byteIndex++] |= + (ASN1OCTET)( value >> nbits ); + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + + while (nbits >= 8) { + nbits -= 8; + pctxt->buffer.data[pctxt->buffer.byteIndex++] = + (ASN1OCTET)( value >> nbits ); + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + } + + /* copy final partial byte */ + + pctxt->buffer.bitOffset = 8 - nbits; + if (nbits > 0) { + pctxt->buffer.data[pctxt->buffer.byteIndex] = + (ASN1OCTET)((value & ((1 << nbits)-1)) << pctxt->buffer.bitOffset); + } + else + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + + return stat; +} + +int encodeBitsFromOctet (OOCTXT* pctxt, ASN1OCTET value, ASN1UINT nbits) +{ + int lshift = pctxt->buffer.bitOffset; + int rshift = 8 - pctxt->buffer.bitOffset; + int stat = ASN_OK; + ASN1OCTET mask; + + if (nbits == 0) return ASN_OK; + + /* Mask off unused bits from the end of the value */ + + if (nbits < 8) { + switch (nbits) { + case 1: mask = 0x80; break; + case 2: mask = 0xC0; break; + case 3: mask = 0xE0; break; + case 4: mask = 0xF0; break; + case 5: mask = 0xF8; break; + case 6: mask = 0xFC; break; + case 7: mask = 0xFE; break; + default:; + } + value &= mask; + } + + /* If we are on a byte boundary, we can do a direct assignment */ + + if (pctxt->buffer.bitOffset == 8) { + pctxt->buffer.data[pctxt->buffer.byteIndex] = value; + if (nbits == 8) { + pctxt->buffer.byteIndex++; + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + } + else + pctxt->buffer.bitOffset -= nbits; + } + + /* Otherwise, need to set some bits in the first octet and */ + /* possibly some bits in the following octet.. */ + + else { + pctxt->buffer.data[pctxt->buffer.byteIndex] |= + (ASN1OCTET)(value >> rshift); + + pctxt->buffer.bitOffset -= nbits; + + if (pctxt->buffer.bitOffset < 0) { + pctxt->buffer.byteIndex++; + pctxt->buffer.data[pctxt->buffer.byteIndex] = + (ASN1OCTET)(value << lshift); + pctxt->buffer.bitOffset += 8; + } + } + + return stat; +} + +int encodeBitString (OOCTXT* pctxt, ASN1UINT numbits, const ASN1OCTET* data) +{ + int enclen, octidx = 0, stat; + Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint; + + for (;;) { + if ((enclen = encodeLength (pctxt, numbits)) < 0) { + return LOG_ASN1ERR (pctxt, enclen); + } + + if (enclen > 0) { + ASN1BOOL doAlign; + + stat = bitAndOctetStringAlignmentTest + (pSizeList, numbits, TRUE, &doAlign); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + if (doAlign) { + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + stat = encodeOctets (pctxt, &data[octidx], enclen); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + if (enclen < (int)numbits) { + numbits -= enclen; + octidx += (enclen/8); + } + else break; + } + + return ASN_OK; +} + +int encodeBMPString +(OOCTXT* pctxt, ASN1BMPString value, Asn116BitCharSet* permCharSet) +{ + Asn116BitCharSet charSet; + int stat; + + /* Set character set */ + + init16BitCharSet (&charSet, BMP_FIRST, BMP_LAST, BMP_ABITS, BMP_UBITS); + + if (permCharSet) { + set16BitCharSet (pctxt, &charSet, permCharSet); + } + + /* Encode constrained string */ + + stat = encode16BitConstrainedString (pctxt, value, &charSet); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + return stat; +} + +int encodeByteAlign (OOCTXT* pctxt) +{ + if (pctxt->buffer.bitOffset != 8) { + if ((pctxt->buffer.byteIndex + 1) >= pctxt->buffer.size) { + int stat = encodeExpandBuffer (pctxt, 1); + if (stat != ASN_OK) return (stat); + } + pctxt->buffer.byteIndex++; + pctxt->buffer.bitOffset = 8; + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + } + + return ASN_OK; +} + +int encodeCheckBuffer (OOCTXT* pctxt, ASN1UINT nbytes) +{ + int stat = ASN_OK; + + /* Add one to required bytes because increment logic will always */ + /* init the byte at the incremented index to zero.. */ + + if ( ( pctxt->buffer.byteIndex + nbytes + 1 ) >= pctxt->buffer.size ) { + if ((stat = encodeExpandBuffer (pctxt, nbytes+1)) != ASN_OK) { + return LOG_ASN1ERR (pctxt, stat); + } + } + + return (stat); +} + +int encodeConsInteger +(OOCTXT* pctxt, ASN1INT value, ASN1INT lower, ASN1INT upper) +{ + ASN1UINT range_value; + ASN1UINT adjusted_value; + int stat; + + /* Check value against given range */ + + if (value < lower || value > upper) { + return ASN_E_CONSVIO; + } + + /* Adjust range value based on lower/upper signed values and */ + /* other possible conflicts.. */ + + if ((upper > 0 && lower >= 0) || (upper <= 0 && lower < 0)) { + range_value = upper - lower; + adjusted_value = value - lower; + } + else { + range_value = upper + abs(lower); + adjusted_value = value + abs(lower); + } + + if (range_value != ASN1UINT_MAX) { range_value += 1; } + + if (range_value == 0 || lower > upper) + stat = ASN_E_RANGERR; + else if (lower != upper) { + stat = encodeConsWholeNumber (pctxt, adjusted_value, range_value); + } + else + stat = ASN_OK; + + return stat; +} + +int encodeConsUnsigned +(OOCTXT* pctxt, ASN1UINT value, ASN1UINT lower, ASN1UINT upper) +{ + ASN1UINT range_value; + ASN1UINT adjusted_value; + int stat; + + /* Check for special case: if lower is 0 and upper is ASN1UINT_MAX, */ + /* set range to ASN1UINT_MAX; otherwise to upper - lower + 1 */ + + range_value = (lower == 0 && upper == ASN1UINT_MAX) ? + ASN1UINT_MAX : upper - lower + 1; + + adjusted_value = value - lower; + + if (lower != upper) { + stat = encodeConsWholeNumber (pctxt, adjusted_value, range_value); + } + else + stat = ASN_OK; + + return stat; +} + +int encodeConsWholeNumber +(OOCTXT* pctxt, ASN1UINT adjusted_value, ASN1UINT range_value) +{ + ASN1UINT nocts, range_bitcnt = getUIntBitCount (range_value - 1); + int stat; + + if (adjusted_value >= range_value && range_value != ASN1UINT_MAX) { + return LOG_ASN1ERR (pctxt, ASN_E_RANGERR); + } + + /* If range is <= 255, bit-field case (10.5.7a) */ + + if (range_value <= 255) { + return encodeBits (pctxt, adjusted_value, range_bitcnt); + } + + /* If range is exactly 256, one-octet case (10.5.7b) */ + + else if (range_value == 256) { + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + return encodeBits (pctxt, adjusted_value, 8); + } + + /* If range > 256 and <= 64k (65536), two-octet case (10.5.7c) */ + + else if (range_value <= 65536) { + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + return encodeBits (pctxt, adjusted_value, 16); + } + + /* If range > 64k, indefinite-length case (10.5.7d) */ + + else { + /* Encode length determinant as a constrained whole number. */ + /* Constraint is 1 to max number of bytes needed to hold */ + /* the target integer value.. */ + + if (adjusted_value < 256) nocts = 1; + else if (adjusted_value < 65536) nocts = 2; + else if (adjusted_value < 0x1000000) nocts = 3; + else nocts = 4; + + stat = encodeBits (pctxt, nocts - 1, 2); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + return encodeNonNegBinInt (pctxt, adjusted_value); + } +} + +int encodeConstrainedStringEx (OOCTXT* pctxt, + const char* string, + const char* charSet, + ASN1UINT abits, /* aligned char bits */ + ASN1UINT ubits, /* unaligned char bits */ + ASN1UINT canSetBits) +{ + ASN1UINT i, len = strlen(string); + int stat; + /* note: need to save size constraint for use in alignCharStr */ + /* because it will be cleared in encodeLength from the context.. */ + Asn1SizeCnst* psize = pctxt->pSizeConstraint; + + /* Encode length */ + + stat = encodeLength (pctxt, len); + if (stat < 0) return LOG_ASN1ERR (pctxt, stat); + + /* Byte align */ + + if (alignCharStr (pctxt, len, abits, psize)) { + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + /* Encode data */ + + if (abits >= canSetBits && canSetBits > 4) { + for (i = 0; i < len; i++) { + if ((stat = encodeBits (pctxt, string[i], abits)) != ASN_OK) + return LOG_ASN1ERR (pctxt, stat); + } + } + else if (0 != charSet) { + ASN1UINT nchars = strlen(charSet), pos; + const char* ptr; + for (i = 0; i < len; i++) { + ptr = memchr (charSet, string[i], nchars); + + if (0 == ptr) + return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO); + else + pos = ptr - charSet; + + if ((stat = encodeBits (pctxt, pos, abits)) != ASN_OK) + return LOG_ASN1ERR (pctxt, stat); + } + } + else return LOG_ASN1ERR (pctxt, ASN_E_INVPARAM); + + return stat; +} + +int encodeExpandBuffer (OOCTXT* pctxt, ASN1UINT nbytes) +{ + if (pctxt->buffer.dynamic) + { + /* If dynamic encoding is enabled, expand the current buffer to */ + /* allow encoding to continue. */ + + pctxt->buffer.size += ASN1MAX (ASN_K_ENCBUFSIZ, nbytes); + + pctxt->buffer.data = (ASN1OCTET*) memHeapRealloc + (&pctxt->pMsgMemHeap, pctxt->buffer.data, pctxt->buffer.size); + + if (!pctxt->buffer.data) return (ASN_E_NOMEM); + + return (ASN_OK); + } + + return (ASN_E_BUFOVFLW); +} + +int encodeGetMsgBitCnt (OOCTXT* pctxt) +{ + int numBitsInLastByte = 8 - pctxt->buffer.bitOffset; + return ((pctxt->buffer.byteIndex * 8) + numBitsInLastByte); +} + +ASN1OCTET* encodeGetMsgPtr (OOCTXT* pctxt, int* pLength) +{ + if (pLength) *pLength = getPERMsgLen (pctxt); + return pctxt->buffer.data; +} + +int encodeIdent (OOCTXT* pctxt, ASN1UINT ident) +{ + ASN1UINT mask; + int nshifts = 0, stat; + + if (ident !=0) { + ASN1UINT lv; + nshifts = getIdentByteCount (ident); + while (nshifts > 0) { + mask = ((ASN1UINT)0x7f) << (7 * (nshifts - 1)); + nshifts--; + lv = (ASN1UINT)((ident & mask) >> (nshifts * 7)); + if (nshifts != 0) { lv |= 0x80; } + if ((stat = encodeBits (pctxt, lv, 8)) != ASN_OK) + return LOG_ASN1ERR (pctxt, stat); + } + } + else { + /* encode a single zero byte */ + if ((stat = encodeBits (pctxt, 0, 8)) != ASN_OK) + return LOG_ASN1ERR (pctxt, stat); + } + + return ASN_OK; +} + +int encodeLength (OOCTXT* pctxt, ASN1UINT value) +{ + ASN1BOOL extendable; + Asn1SizeCnst* pSize = + checkSize (pctxt->pSizeConstraint, value, &extendable); + ASN1UINT lower = (pSize) ? pSize->lower : 0; + ASN1UINT upper = (pSize) ? pSize->upper : ASN1UINT_MAX; + int enclen, stat; + + /* If size constraints exist and the given length did not fall */ + /* within the range of any of them, signal constraint violation */ + /* error.. */ + + if (pctxt->pSizeConstraint && !pSize) + return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO); + + /* Reset the size constraint in the context block structure */ + + pctxt->pSizeConstraint = 0; + + /* If size constraint is present and extendable, encode extension */ + /* bit.. */ + + if (extendable) { + stat = (pSize) ? + encodeBit (pctxt, pSize->extended) : encodeBit (pctxt, 1); + + if (stat != ASN_OK) return (stat); + } + + /* If upper limit is less than 64k, constrained case */ + + if (upper < 65536) { + stat = (lower == upper) ? ASN_OK : + encodeConsWholeNumber (pctxt, value - lower, upper - lower + 1); + enclen = (stat == ASN_OK) ? value : stat; + } + else { + /* unconstrained case or Constrained with upper bound >= 64K*/ + enclen = encodeUnconsLength (pctxt, value); + } + + return enclen; + +} + +int encodeObjectIdentifier (OOCTXT* pctxt, ASN1OBJID* pvalue) +{ + int len, stat; + ASN1UINT temp; + register int numids, i; + + /* Calculate length in bytes and encode */ + + len = 1; /* 1st 2 arcs require 1 byte */ + numids = pvalue->numids; + for (i = 2; i < numids; i++) { + len += getIdentByteCount (pvalue->subid[i]); + } + + /* PER encode length */ + + if ((stat = encodeLength (pctxt, (ASN1UINT)len)) < 0) { + return LOG_ASN1ERR (pctxt, stat); + } + + /* Validate given object ID by applying ASN.1 rules */ + + if (0 == pvalue) return LOG_ASN1ERR (pctxt, ASN_E_INVOBJID); + if (numids < 2) return LOG_ASN1ERR (pctxt, ASN_E_INVOBJID); + if (pvalue->subid[0] > 2) return LOG_ASN1ERR (pctxt, ASN_E_INVOBJID); + if (pvalue->subid[0] != 2 && pvalue->subid[1] > 39) + return LOG_ASN1ERR (pctxt, ASN_E_INVOBJID); + + /* Passed checks, encode object identifier */ + + /* Munge first two sub ID's and encode */ + + temp = ((pvalue->subid[0] * 40) + pvalue->subid[1]); + if ((stat = encodeIdent (pctxt, temp)) != ASN_OK) + return LOG_ASN1ERR (pctxt, stat); + + /* Encode the remainder of the OID value */ + + for (i = 2; i < numids; i++) { + if ((stat = encodeIdent (pctxt, pvalue->subid[i])) != ASN_OK) + return LOG_ASN1ERR (pctxt, stat); + } + + return ASN_OK; +} + +int encodebitsFromOctet (OOCTXT* pctxt, ASN1OCTET value, ASN1UINT nbits) +{ + int lshift = pctxt->buffer.bitOffset; + int rshift = 8 - pctxt->buffer.bitOffset; + int stat = ASN_OK; + ASN1OCTET mask; + + if (nbits == 0) return ASN_OK; + + /* Mask off unused bits from the end of the value */ + + if (nbits < 8) { + switch (nbits) { + case 1: mask = 0x80; break; + case 2: mask = 0xC0; break; + case 3: mask = 0xE0; break; + case 4: mask = 0xF0; break; + case 5: mask = 0xF8; break; + case 6: mask = 0xFC; break; + case 7: mask = 0xFE; break; + default:; + } + value &= mask; + } + + /* If we are on a byte boundary, we can do a direct assignment */ + + if (pctxt->buffer.bitOffset == 8) { + pctxt->buffer.data[pctxt->buffer.byteIndex] = value; + if (nbits == 8) { + pctxt->buffer.byteIndex++; + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + } + else + pctxt->buffer.bitOffset -= nbits; + } + + /* Otherwise, need to set some bits in the first octet and */ + /* possibly some bits in the following octet.. */ + + else { + pctxt->buffer.data[pctxt->buffer.byteIndex] |= + (ASN1OCTET)(value >> rshift); + + pctxt->buffer.bitOffset -= nbits; + + if (pctxt->buffer.bitOffset < 0) { + pctxt->buffer.byteIndex++; + pctxt->buffer.data[pctxt->buffer.byteIndex] = + (ASN1OCTET)(value << lshift); + pctxt->buffer.bitOffset += 8; + } + } + + return stat; +} + +int encodeOctets (OOCTXT* pctxt, const ASN1OCTET* pvalue, ASN1UINT nbits) +{ + int i = 0, stat; + int numFullOcts = nbits / 8; + + if (nbits == 0) return 0; + + /* Check buffer space and allocate more memory if necessary */ + + stat = encodeCheckBuffer (pctxt, numFullOcts + 1); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + if (numFullOcts > 0) { + + /* If the current bit offset is 8 (i.e. we don't have a */ + /* byte started), can copy the string directly to the */ + /* encode buffer.. */ + + if (pctxt->buffer.bitOffset == 8) { + memcpy (&pctxt->buffer.data[pctxt->buffer.byteIndex], pvalue, + numFullOcts); + pctxt->buffer.byteIndex += numFullOcts; + pctxt->buffer.data[pctxt->buffer.byteIndex] = 0; + i = numFullOcts; + } + + /* Else, copy bits */ + + else { + for (i = 0; i < numFullOcts; i++) { + stat = encodeBitsFromOctet (pctxt, pvalue[i], 8); + if (stat != ASN_OK) return stat; + } + } + } + + /* Move remaining bits from the last octet to the output buffer */ + + if (nbits % 8 != 0) { + stat = encodeBitsFromOctet (pctxt, pvalue[i], nbits % 8); + } + + return stat; +} + +int encodeOctetString (OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data) +{ + int enclen, octidx = 0, stat; + Asn1SizeCnst* pSizeList = pctxt->pSizeConstraint; + + for (;;) { + if ((enclen = encodeLength (pctxt, numocts)) < 0) { + return LOG_ASN1ERR (pctxt, enclen); + } + + if (enclen > 0) { + ASN1BOOL doAlign; + + stat = bitAndOctetStringAlignmentTest + (pSizeList, numocts, FALSE, &doAlign); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + if (doAlign) { + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + stat = encodeOctets (pctxt, &data[octidx], enclen * 8); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + if (enclen < (int)numocts) { + numocts -= enclen; + octidx += enclen; + } + else break; + } + + return ASN_OK; +} + +int encodeOpenType (OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data) +{ + int enclen, octidx = 0, stat; + ASN1OCTET zeroByte = 0x00; + ASN1OpenType openType; + + /* If open type contains length zero, add a single zero byte (10.1) */ + + if (numocts == 0) { + openType.numocts = 1; + openType.data = &zeroByte; + } + else { + openType.numocts = numocts; + openType.data = data; + } + + /* Encode the open type */ + + for (;;) { + if ((enclen = encodeLength (pctxt, openType.numocts)) < 0) { + return LOG_ASN1ERR (pctxt, enclen); + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = encodeOctets (pctxt, &openType.data[octidx], enclen * 8); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + if (enclen < (int)openType.numocts) { + openType.numocts -= enclen; + octidx += enclen; + } + else break; + } + + return ASN_OK; +} + +int encodeOpenTypeExt (OOCTXT* pctxt, DList* pElemList) +{ + DListNode* pnode; + ASN1OpenType* pOpenType; + int stat; + + if (0 != pElemList) { + pnode = pElemList->head; + while (0 != pnode) { + if (0 != pnode->data) { + pOpenType = (ASN1OpenType*)pnode->data; + + if (pOpenType->numocts > 0) { + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + stat = encodeOpenType + (pctxt, pOpenType->numocts, pOpenType->data); + + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + } + pnode = pnode->next; + } + } + + return ASN_OK; +} + +int encodeOpenTypeExtBits (OOCTXT* pctxt, DList* pElemList) +{ + DListNode* pnode; + int stat; + + if (0 != pElemList) { + pnode = pElemList->head; + + while (0 != pnode) { + stat = encodeBit (pctxt, (ASN1BOOL)(0 != pnode->data)); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + pnode = pnode->next; + } + } + + return ASN_OK; +} + +int encodeSemiConsInteger (OOCTXT* pctxt, ASN1INT value, ASN1INT lower) +{ + int nbytes, stat; + int shift = ((sizeof(value) - 1) * 8) - 1; + ASN1UINT tempValue; + + if (lower > ASN1INT_MIN) + value -= lower; + + /* Calculate signed number value length */ + + for ( ; shift > 0; shift -= 8) { + tempValue = (value >> shift) & 0x1ff; + if (tempValue == 0 || tempValue == 0x1ff) continue; + else break; + } + + nbytes = (shift + 9) / 8; + + /* Encode length */ + + if ((stat = encodeLength (pctxt, nbytes)) < 0) { + return stat; + } + + if ((stat = encodeByteAlign (pctxt)) != ASN_OK) + return stat; + + /* Encode signed value */ + + stat = encode2sCompBinInt (pctxt, value); + + return stat; +} + +int encodeSemiConsUnsigned (OOCTXT* pctxt, ASN1UINT value, ASN1UINT lower) +{ + int nbytes, stat; + int shift = ((sizeof(value) - 1) * 8) - 1; + ASN1UINT mask = 1UL << ((sizeof(value) * 8) - 1); + ASN1UINT tempValue; + + value -= lower; + + /* Calculate unsigned number value length */ + + for ( ; shift > 0; shift -= 8) { + tempValue = (value >> shift) & 0x1ff; + + if (tempValue == 0) continue; + else break; + } + + nbytes = (shift + 9) / 8; + + /* If MS bit in unsigned number is set, add an extra zero byte */ + + if ((value & mask) != 0) nbytes++; + + /* Encode length */ + + if ((stat = encodeLength (pctxt, nbytes)) < 0) { + return stat; + } + + if ((stat = encodeByteAlign (pctxt)) != ASN_OK) + return stat; + + /* Encode additional zero byte if necessary */ + + if (nbytes > sizeof(value)) { + stat = encodebitsFromOctet (pctxt, 0, 8); + if (stat != ASN_OK) return (stat); + } + + /* Encode unsigned value */ + + stat = encodeNonNegBinInt (pctxt, value); + + return stat; +} + +int encodeSmallNonNegWholeNumber (OOCTXT* pctxt, ASN1UINT value) +{ + int stat; + + if (value < 64) { + stat = encodeBits (pctxt, value, 7); + } + else { + ASN1UINT len; + + /* Encode a one-byte length determinant value */ + if (value < 256) len = 1; + else if (value < 65536) len = 2; + else if (value < 0x1000000) len = 3; + else len = 4; + + stat = encodeBits (pctxt, len, 8); + + /* Byte-align and encode the value */ + if (stat == ASN_OK) { + if ((stat = encodeByteAlign (pctxt)) == ASN_OK) { + stat = encodeBits (pctxt, value, len*8); + } + } + } + + return stat; +} + +int encodeVarWidthCharString (OOCTXT* pctxt, const char* value) +{ + int stat; + ASN1UINT len = strlen (value); + /* note: need to save size constraint for use in alignCharStr */ + /* because it will be cleared in encodeLength from the context.. */ + Asn1SizeCnst* psize = pctxt->pSizeConstraint; + + /* Encode length */ + + stat = encodeLength (pctxt, len); + if (stat < 0) return LOG_ASN1ERR (pctxt, stat); + + /* Byte align */ + + if (alignCharStr (pctxt, len, 8, psize)) { + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + + /* Encode data */ + + stat = encodeOctets (pctxt, (const ASN1OCTET*)value, len * 8); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + return ASN_OK; +} + +static int encode16BitConstrainedString +(OOCTXT* pctxt, Asn116BitCharString value, Asn116BitCharSet* pCharSet) +{ + ASN1UINT i, pos; + ASN1UINT nbits = pCharSet->alignedBits; + int stat; + + /* Encode length */ + + stat = encodeLength (pctxt, value.nchars); + if (stat < 0) return LOG_ASN1ERR (pctxt, stat); + + /* Byte align */ + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + /* Encode data */ + + for (i = 0; i < value.nchars; i++) { + if (pCharSet->charSet.data == 0) { + stat = encodeBits + (pctxt, value.data[i] - pCharSet->firstChar, nbits); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + else { + for (pos = 0; pos < pCharSet->charSet.nchars; pos++) { + if (value.data[i] == pCharSet->charSet.data[pos]) { + stat = encodeBits (pctxt, pos, nbits); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + break; + } + } + } + } + + return stat; +} + +int encode2sCompBinInt (OOCTXT* pctxt, ASN1INT value) +{ + /* 10.4.6 A minimum octet 2's-complement-binary-integer encoding */ + /* of the whole number has a field width that is a multiple of 8 */ + /* bits and also satisifies the condition that the leading 9 bits */ + /* field shall not be all zeros and shall not be all ones. */ + + /* first encode integer value into a local buffer */ + + ASN1OCTET lbuf[8], lb; + ASN1INT i = sizeof(lbuf), temp = value; + + memset (lbuf, 0, sizeof(lbuf)); + do { + lb = temp % 256; + temp /= 256; + if (temp < 0 && lb != 0) temp--; /* two's complement adjustment */ + lbuf[--i] = lb; + } while (temp != 0 && temp != -1); + + /* If the value is positive and bit 8 of the leading byte is set, */ + /* copy a zero byte to the contents to signal a positive number.. */ + + if (value > 0 && (lb & 0x80) != 0) { + i--; + } + + /* If the value is negative and bit 8 of the leading byte is clear, */ + /* copy a -1 byte (0xFF) to the contents to signal a negative */ + /* number.. */ + + else if (value < 0 && ((lb & 0x80) == 0)) { + lbuf[--i] = 0xff; + } + + /* Add the data to the encode buffer */ + + return encodeOctets (pctxt, &lbuf[i], (sizeof(lbuf) - i) * 8); +} + +static int encodeNonNegBinInt (OOCTXT* pctxt, ASN1UINT value) +{ + /* 10.3.6 A minimum octet non-negative binary integer encoding of */ + /* the whole number (which does not predetermine the number of */ + /* octets to be used for the encoding) has a field which is a */ + /* multiple of 8 bits and also satisifies the condition that the */ + /* leading eight bits of the field shall not be zero unless the */ + /* field is precisely 8 bits long. */ + + ASN1UINT bitcnt = (value == 0) ? 1 : getUIntBitCount (value); + + /* round-up to nearest 8-bit boundary */ + + bitcnt = (bitcnt + 7) & (~7); + + /* encode bits */ + + return encodeBits (pctxt, value, bitcnt); +} + +static int encodeUnconsLength (OOCTXT* pctxt, ASN1UINT value) +{ + int enclen, stat; + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + + /* 1 octet case */ + if (value < 128) { + stat = encodeBits (pctxt, value, 8); + enclen = (stat == ASN_OK) ? value : stat; + } + /* 2 octet case */ + else if (value < 16384) { + if ((stat = encodeBit (pctxt, 1)) == ASN_OK) + stat = encodeBits (pctxt, value, 15); + enclen = (stat == ASN_OK) ? value : stat; + } + /* fragmentation case */ + else { + int multiplier = ASN1MIN (value/16384, 4); + encodeBit (pctxt, 1); /* set bit 8 of first octet */ + encodeBit (pctxt, 1); /* set bit 7 of first octet */ + stat = encodeBits (pctxt, multiplier, 6); + enclen = (stat == ASN_OK) ? 16384 * multiplier : stat; + } + + return enclen; +} + +static int getIdentByteCount (ASN1UINT ident) +{ + if (ident < (1u << 7)) { /* 7 */ + return 1; + } + else if (ident < (1u << 14)) { /* 14 */ + return 2; + } + else if (ident < (1u << 21)) { /* 21 */ + return 3; + } + else if (ident < (1u << 28)) { /* 28 */ + return 4; + } + return 5; +} diff --git a/addons/ooh323c/src/errmgmt.c b/addons/ooh323c/src/errmgmt.c new file mode 100644 index 000000000..d41bad102 --- /dev/null +++ b/addons/ooh323c/src/errmgmt.c @@ -0,0 +1,261 @@ +/* + * Copyright (C) 1997-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. + * + *****************************************************************************/ + +/* Error management functions */ + +#include +#include "ooasn1.h" + +/* Error status text */ +static const char* g_status_text[] = { + "Encode buffer overflow", + "Unexpected end of buffer on decode", + "Unexpected tag encountered: expected = %s, parsed = %s", + "Invalid object identifier", + "Invalid field length detected", + "Enumerated value %s not in defined set", + "Duplicate element in SET", + "Missing required element in SET", + "Element with tag %s not part of SET", + "Max elements defined for SEQUENCE field exceeded", + "Element with tag %s is an invalid option in choice", + "No dynamic memory available", + "Invalid string type", + "Invalid hex string", + "Invalid binary string", + "Invalid real value", + "Max items in sized BIT or OCTET STRING field exceeded", + "Invalid value specification", + "No definition found for referenced defined value", + "No definition found for referenced defined type", + "Invalid tag value", + "Nesting level too deep", + "Value constraint violation: field %s, value %s", + "Value range error: lower bound is greater than upper", + "Unexpected end of file detected", + "Invalid UTF-8 character at index %d", + "List error: concurrent modification attempt while iterating", + "List error: illegal state for attempted operation", + "Array index out of bounds", + "Invalid parameter passed to function or method", + "Invalid time string format", + "Context is not initialized", + "ASN.1 value will not fit in target variable", + "Character is not within the defined character set", + "Invalid XML state for attempted operation", + "Error condition returned from XML parser:\n%s", + "SEQUENCE elements not in correct order", + "Invalid index for table constraint identifier", + "Invalid value for relational table constraint fixed type field", + "File not found", + "File read error", + "File write error", + "Invalid Base64 string", + "Socket error", + "XML interface library not found", + "Invalid XML interface library" +} ; + +#define ASN1_K_MAX_STAT (sizeof(g_status_text)/sizeof(char *)) + +/* Add an integer parameter to an error message */ + +int errAddIntParm (ASN1ErrInfo* pErrInfo, int errParm) +{ + char lbuf[16]; + sprintf (lbuf, "%d", errParm); + return errAddStrParm (pErrInfo, lbuf); +} + +/* Add a character string parameter to an error message */ + +int errAddStrParm (ASN1ErrInfo* pErrInfo, const char* errprm_p) +{ +#if defined(_NO_THREADS) || !defined(_NO_MALLOC) + if (pErrInfo->parmcnt < ASN_K_MAXERRP) { + char* tmpstr = (char*) ASN1CRTMALLOC0 (strlen(errprm_p)+1); + strcpy (tmpstr, errprm_p); + pErrInfo->parms[pErrInfo->parmcnt] = tmpstr; + pErrInfo->parmcnt++; + return TRUE; + } + else +#endif + return FALSE; +} + +/* Add an unsigned integer parameter to an error message */ + +int errAddUIntParm (ASN1ErrInfo* pErrInfo, unsigned int errParm) +{ + char lbuf[16]; + sprintf (lbuf, "%u", errParm); + return errAddStrParm (pErrInfo, lbuf); +} + +/* Free error parameter memory */ + +void errFreeParms (ASN1ErrInfo* pErrInfo) +{ +#if defined(_NO_THREADS) || !defined(_NO_MALLOC) + int i; + + for (i = 0; i < pErrInfo->parmcnt; i++) + ASN1CRTFREE0 ((char*)pErrInfo->parms[i]); +#endif + + pErrInfo->parmcnt = 0; + pErrInfo->status = 0; +} + +/* Reset error */ + +int errReset (ASN1ErrInfo* pErrInfo) +{ + errFreeParms (pErrInfo); + pErrInfo->stkx = 0; + return ASN_OK; +} + +/* Format error message */ + +char* errFmtMsg (ASN1ErrInfo* pErrInfo, char* bufp) +{ + const char* tp; + int i, j, pcnt; + + if (pErrInfo->status < 0) + { + i = abs (pErrInfo->status + 1); + + if (i >= 0 && i < ASN1_K_MAX_STAT) + { + /* Substitute error parameters into error message */ + + j = pcnt = 0; + tp = g_status_text[i]; + + while (*tp) + { + if (*tp == '%' && *(tp+1) == 's') + { + /* Plug in error parameter */ + + if (pcnt < pErrInfo->parmcnt && pErrInfo->parms[pcnt]) + { + strcpy (&bufp[j], pErrInfo->parms[pcnt]); + j += strlen (pErrInfo->parms[pcnt++]); + } + else + bufp[j++] = '?'; + + tp += 2; + } + else + bufp[j++] = *tp++; + } + + bufp[j] = '\0'; /* null terminate string */ + } + else + strcpy (bufp, "unrecognized completion status"); + } + else strcpy (bufp, "normal completion status"); + + return (bufp); +} + +/* Get error text in a dynamic memory buffer. This allocates memory */ +/* using the 'memAlloc' function. This memory is automatically freed */ +/* at the time the 'memFree' function is called. */ + +char* errGetText (OOCTXT* pctxt) +{ + char lbuf[500]; + char* pBuf = (char*) ASN1MALLOC (pctxt, + (sizeof(lbuf) + 100 * (2 + pctxt->errInfo.stkx)) * sizeof(char)); + + sprintf (pBuf, "ASN.1 ERROR: Status %d\n", pctxt->errInfo.status); + sprintf (lbuf, "%s\nStack trace:", errFmtMsg (&pctxt->errInfo, lbuf)); + strcat(pBuf, lbuf); + + while (pctxt->errInfo.stkx > 0) { + pctxt->errInfo.stkx--; + sprintf (lbuf, " Module: %s, Line %d\n", + pctxt->errInfo.stack[pctxt->errInfo.stkx].module, + pctxt->errInfo.stack[pctxt->errInfo.stkx].lineno); + strcat(pBuf, lbuf); + } + + errFreeParms (&pctxt->errInfo); + + return pBuf; +} + +/* Print error information to the standard output */ + +void errPrint (ASN1ErrInfo* pErrInfo) +{ + char lbuf[200]; + printf ("ASN.1 ERROR: Status %d\n", pErrInfo->status); + printf ("%s\n", errFmtMsg (pErrInfo, lbuf)); + printf ("Stack trace:"); + while (pErrInfo->stkx > 0) { + pErrInfo->stkx--; + printf (" Module: %s, Line %d\n", + pErrInfo->stack[pErrInfo->stkx].module, + pErrInfo->stack[pErrInfo->stkx].lineno); + } + errFreeParms (pErrInfo); +} + +/* Copy error data from one error structure to another */ + +int errCopyData (ASN1ErrInfo* pSrcErrInfo, ASN1ErrInfo* pDestErrInfo) +{ + int i; + pDestErrInfo->status = pSrcErrInfo->status; + + /* copy error parameters */ + + for (i = 0; i < pSrcErrInfo->parmcnt; i++) { + errAddStrParm (pDestErrInfo, pSrcErrInfo->parms[i]); + } + + /* copy stack info */ + + for (i = 0; i < pSrcErrInfo->stkx; i++) { + if (pDestErrInfo->stkx < ASN_K_MAXERRSTK) { + pDestErrInfo->stack[pDestErrInfo->stkx].module = + pSrcErrInfo->stack[i].module; + pDestErrInfo->stack[pDestErrInfo->stkx++].lineno = + pSrcErrInfo->stack[i].lineno; + } + } + + return (pSrcErrInfo->status); +} + + +int errSetData (ASN1ErrInfo* pErrInfo, int status, + const char* module, int lno) +{ + if (pErrInfo->status == 0) { + pErrInfo->status = status; + } + ooLogAsn1Error(status, module, lno); + return status; +} diff --git a/addons/ooh323c/src/eventHandler.c b/addons/ooh323c/src/eventHandler.c new file mode 100644 index 000000000..7b15759a6 --- /dev/null +++ b/addons/ooh323c/src/eventHandler.c @@ -0,0 +1,122 @@ +/* + * 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 "eventHandler.h" + +void setEventHandler (OOCTXT* pctxt, EventHandler* pHandler) +{ + pctxt->pEventHandler = pHandler; +} + +void removeEventHandler (OOCTXT* pctxt) +{ + pctxt->pEventHandler = 0; +} + +void invokeStartElement (OOCTXT* pctxt, const char* name, int index) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->startElement (name, index); + } +} + +void invokeEndElement (OOCTXT* pctxt, const char* name, int index) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->endElement (name, index); + } +} + +void invokeBoolValue (OOCTXT* pctxt, ASN1BOOL value) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->boolValue (value); + } +} + +void invokeIntValue (OOCTXT* pctxt, ASN1INT value) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->intValue (value); + } +} + +void invokeUIntValue (OOCTXT* pctxt, ASN1UINT value) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->uIntValue (value); + } +} + +void invokeBitStrValue (OOCTXT* pctxt, ASN1UINT numbits, + const ASN1OCTET* data) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->bitStrValue (numbits, data); + } +} + +void invokeOctStrValue (OOCTXT* pctxt, ASN1UINT numocts, + const ASN1OCTET* data) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->octStrValue (numocts, data); + } +} + +void invokeCharStrValue (OOCTXT* pctxt, const char* value) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->charStrValue (value); + } +} + +void invokeCharStr16BitValue (OOCTXT* pctxt, ASN1UINT nchars, + ASN116BITCHAR* data) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->charStr16BitValue (nchars, data); + } +} + +void invokeNullValue (OOCTXT* pctxt) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->nullValue (); + } +} + +void invokeOidValue (OOCTXT* pctxt, ASN1UINT numSubIds, ASN1UINT* pSubIds) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->oidValue (numSubIds, pSubIds); + } +} + +void invokeEnumValue (OOCTXT* pctxt, ASN1UINT value) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->enumValue (value); + } +} + +void invokeOpenTypeValue (OOCTXT* pctxt, ASN1UINT numocts, + const ASN1OCTET* data) +{ + if (0 != pctxt->pEventHandler) { + pctxt->pEventHandler->openTypeValue (numocts, data); + } +} diff --git a/addons/ooh323c/src/eventHandler.h b/addons/ooh323c/src/eventHandler.h new file mode 100644 index 000000000..320a55b99 --- /dev/null +++ b/addons/ooh323c/src/eventHandler.h @@ -0,0 +1,284 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * @file eventHandler.h + * C event handler structure. This structure holds event handler function + * callbacks for use by the generated code. + */ +/** + * @defgroup EventHandler event handler + * Event handler structures and callback function definitions. + * @{ + */ +#ifndef _EVENTHANDLER_H_ +#define _EVENTHANDLER_H_ + +#include +#include "ooasn1.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +#ifndef EXTERN +#if define (MAKE_DLL) +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + + +/** + * This is a function pointer for a callback function which is invoked + * from within a decode function when an element of a SEQUENCE, SET, + * SEQUENCE OF, SET OF, or CHOICE construct is parsed. + * + * @param name For SEQUENCE, SET, or CHOICE, this is the name of the + * element as defined in the ASN.1 defination. For + * SEQUENCE OF or SET OF, this is set to the name + * "element". + * @param index For SEQUENCE, SET, or CHOICE, this is not used and is + * set to the value + * -1. For SEQUENCE OF or SET OF, this contains the + * zero-based index of the element in the conceptual + * array associated with the construct. + * @return - none + */ +typedef void (*StartElement) (const char* name, int index) ; + + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when parsing is complete on an element of a + * SEQUENCE, SET, SEQUENCE OF, SET OF, or CHOICE construct. + * + * @param name For SEQUENCE, SET, or CHOICE, this is the name of the + * element as defined in the ASN.1 defination. For + * SEQUENCE OF or SET OF, this is set to the name + * "element". + * @param index For SEQUENCE, SET, or CHOICE, this is not used and is + * set to the value + * -1. For SEQUENCE OF or SET OF, this contains the + * zero-based index of the element in the conceptual + * array associated with the construct. + * @return - none + */ +typedef void (*EndElement) (const char* name, int index) ; + + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when a value of the BOOLEAN ASN.1 type is parsed. + * + * @param value Parsed value. + * @return - none + */ +typedef void (*BoolValue) (ASN1BOOL value); + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when a value of the INTERGER ASN.1 type is parsed. + * + * @param value Parsed value. + * @return - none + */ +typedef void (*IntValue) (ASN1INT value); + +/** + * This is a function pointer for a callback function which is invoked + * from within a decode function when a value of the INTEGER ASN.1 type + * is parsed. In this case, constraints on the integer value forced the + * use of unsigned integer C type to represent the value. + * + * @param value Parsed value. + * @return - none + */ +typedef void (*UIntValue) (ASN1UINT value); + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when a value of the BIT STRING ASN.1 type is + * parsed. + * + * @param numbits - Number of bits in the parsed value. + * @param data - Pointer to a byte array that contains the bit + * string data. + * @return - none + */ +typedef void (*BitStrValue) (ASN1UINT numbits, const ASN1OCTET* data); + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when a value of one of the OCTET STRING ASN.1 type + * is parsed. + * + * @param numocts Number of octets in the parsed value. + * @param data Pointer to byte array containing the octet string + * data. + * @return - none + */ +typedef void (*OctStrValue) (ASN1UINT numocts, const ASN1OCTET* data) ; + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when a value of one of the 8-bit ASN.1 character + * string types is parsed. + * + * @param value Null terminated character string value. + * @return - none + */ +typedef void (*CharStrValue) (const char* value) ; + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when a value of one of the 16-bit ASN.1 character + * string types is parsed. + * + * This is used for the ASN.1 BmpString type. + * + * @param nchars Number of characters in the parsed value. + * @param data Pointer to an array containing 16-bit values. + * These are represented using unsigned short integer + * values. + * @return - none + */ +typedef void (*CharStrValue16Bit) (ASN1UINT nchars, ASN116BITCHAR* data) ; + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when a value of the NULL ASN.1 type is parsed. + * + * @param - none + * @return - none + */ +typedef void (*NullValue) () ; + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function whn a value the OBJECT IDENTIFIER ASN.1 type is + * parsed. + * + * @param numSubIds Number of subidentifiers in the object identifier. + * @param pSubIds Pointer to array containing the subidentifier values. + * @return -none + */ +typedef void (*OidValue) (ASN1UINT numSubIds, ASN1UINT* pSubIds) ; + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when a value of the ENUMERATED ASN.1 type is + * parsed. + * + * @param value - Parsed enumerated value + * @return - none + */ +typedef void (*EnumValue) (ASN1UINT value) ; + +/** + * This is a function pointer for a callback function which is invoked from + * within a decode function when an ASN.1 open type is parsed. + * + * @param numocts Number of octets in the parsed value. + * @param data Pointer to byet array contain in tencoded ASN.1 + * value. + * @return - none + */ +typedef void (*OpenTypeValue) (ASN1UINT numocts, const ASN1OCTET* data) ; + + +/** + * This is a basic C based event handler structure, which can be used + * to define user-defined event handlers. + */ +typedef struct EventHandler { + StartElement startElement; + EndElement endElement; + BoolValue boolValue; + IntValue intValue; + UIntValue uIntValue; + BitStrValue bitStrValue; + OctStrValue octStrValue; + CharStrValue charStrValue; + CharStrValue16Bit charStr16BitValue; + NullValue nullValue; + OidValue oidValue; + EnumValue enumValue; + OpenTypeValue openTypeValue; +} EventHandler; + + +/** + * This function sets the event handler object within the context. It + * will overwrite the definition of any handler that was set previously. + * + * @param pctxt Context to which event handler has to be added. + * @param pHandler Pointer to the event handler structure. + * @return none + */ +EXTERN void setEventHandler (OOCTXT* pctxt, EventHandler* pHandler); + +/** + * This function is called to remove the event handler current defined + * in the context. This is done by setting the event handler object + * pointer to NULL. + * + * @param pctxt Context from which event handler has to be removed. + * @return none + */ +EXTERN void removeEventHandler (OOCTXT* pctxt); + +/** + * The following functions are invoked from within the generated + * code to call the various user-defined event handler methods .. + */ +EXTERN void invokeStartElement (OOCTXT* pctxt, const char* name, int index); +EXTERN void invokeEndElement (OOCTXT* pctxt, const char* name, int index); +EXTERN void invokeBoolValue (OOCTXT* pctxt, ASN1BOOL value); +EXTERN void invokeIntValue (OOCTXT* pctxt, ASN1INT value); +EXTERN void invokeUIntValue (OOCTXT* pctxt, ASN1UINT value); + +EXTERN void invokeBitStrValue +(OOCTXT* pctxt, ASN1UINT numbits, const ASN1OCTET* data); + +EXTERN void invokeOctStrValue +(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data); + +EXTERN void invokeCharStrValue (OOCTXT* pctxt, const char* value); + +EXTERN void invokeCharStr16BitValue +(OOCTXT* pctxt, ASN1UINT nchars, ASN116BITCHAR* data); + +EXTERN void invokeNullValue (OOCTXT* pctxt); + +EXTERN void invokeOidValue +(OOCTXT* pctxt, ASN1UINT numSubIds, ASN1UINT* pSubIds); + +EXTERN void invokeEnumValue (OOCTXT* pctxt, ASN1UINT value); + +EXTERN void invokeOpenTypeValue +(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/h323/H235-SECURITY-MESSAGES.h b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGES.h new file mode 100644 index 000000000..2f401b39a --- /dev/null +++ b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGES.h @@ -0,0 +1,690 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#ifndef H235_SECURITY_MESSAGES_H +#define H235_SECURITY_MESSAGES_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "ooasn1.h" + +/**************************************************************/ +/* */ +/* ChallengeString */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ChallengeString { + ASN1UINT numocts; + ASN1OCTET data[128]; +} H235ChallengeString; + +EXTERN int asn1PE_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue); + +EXTERN int asn1PD_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue); + +/**************************************************************/ +/* */ +/* TimeStamp */ +/* */ +/**************************************************************/ + +typedef ASN1UINT H235TimeStamp; + +EXTERN int asn1PE_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp value); + +EXTERN int asn1PD_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp* pvalue); + +/**************************************************************/ +/* */ +/* RandomVal */ +/* */ +/**************************************************************/ + +typedef ASN1INT H235RandomVal; + +EXTERN int asn1PE_H235RandomVal (OOCTXT* pctxt, H235RandomVal value); + +EXTERN int asn1PD_H235RandomVal (OOCTXT* pctxt, H235RandomVal* pvalue); + +/**************************************************************/ +/* */ +/* Password */ +/* */ +/**************************************************************/ + +typedef ASN1BMPString H235Password; + +EXTERN int asn1PE_H235Password (OOCTXT* pctxt, H235Password value); + +EXTERN int asn1PD_H235Password (OOCTXT* pctxt, H235Password* pvalue); + +/**************************************************************/ +/* */ +/* EncodedPwdCertToken */ +/* */ +/**************************************************************/ + +typedef ASN1OpenType H235EncodedPwdCertToken; + +EXTERN int asn1PE_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken value); + +EXTERN int asn1PD_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken* pvalue); + +/**************************************************************/ +/* */ +/* NonStandardParameter */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235NonStandardParameter { + ASN1OBJID nonStandardIdentifier; + ASN1DynOctStr data; +} H235NonStandardParameter; + +EXTERN int asn1PE_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue); + +EXTERN int asn1PD_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue); + +/**************************************************************/ +/* */ +/* AuthenticationBES */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H235AuthenticationBES_default_ 1 +#define T_H235AuthenticationBES_radius 2 +#define T_H235AuthenticationBES_extElem1 3 + +typedef struct EXTERN H235AuthenticationBES { + int t; +} H235AuthenticationBES; + +EXTERN int asn1PE_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue); + +EXTERN int asn1PD_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue); + +/**************************************************************/ +/* */ +/* AuthenticationMechanism */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H235AuthenticationMechanism_dhExch 1 +#define T_H235AuthenticationMechanism_pwdSymEnc 2 +#define T_H235AuthenticationMechanism_pwdHash 3 +#define T_H235AuthenticationMechanism_certSign 4 +#define T_H235AuthenticationMechanism_ipsec 5 +#define T_H235AuthenticationMechanism_tls 6 +#define T_H235AuthenticationMechanism_nonStandard 7 +#define T_H235AuthenticationMechanism_authenticationBES 8 +#define T_H235AuthenticationMechanism_extElem1 9 + +typedef struct EXTERN H235AuthenticationMechanism { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + H235NonStandardParameter *nonStandard; + /* t = 8 */ + H235AuthenticationBES *authenticationBES; + /* t = 9 */ + } u; +} H235AuthenticationMechanism; + +EXTERN int asn1PE_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue); + +EXTERN int asn1PD_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue); + +/**************************************************************/ +/* */ +/* DHset_halfkey */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235DHset_halfkey { + ASN1UINT numbits; + ASN1OCTET data[256]; +} H235DHset_halfkey; + +EXTERN int asn1PE_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue); + +EXTERN int asn1PD_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue); + +/**************************************************************/ +/* */ +/* DHset_modSize */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235DHset_modSize { + ASN1UINT numbits; + ASN1OCTET data[256]; +} H235DHset_modSize; + +EXTERN int asn1PE_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue); + +EXTERN int asn1PD_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue); + +/**************************************************************/ +/* */ +/* DHset_generator */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235DHset_generator { + ASN1UINT numbits; + ASN1OCTET data[256]; +} H235DHset_generator; + +EXTERN int asn1PE_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue); + +EXTERN int asn1PD_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue); + +/**************************************************************/ +/* */ +/* DHset */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235DHset { + H235DHset_halfkey halfkey; + H235DHset_modSize modSize; + H235DHset_generator generator; +} H235DHset; + +EXTERN int asn1PE_H235DHset (OOCTXT* pctxt, H235DHset* pvalue); + +EXTERN int asn1PD_H235DHset (OOCTXT* pctxt, H235DHset* pvalue); + +/**************************************************************/ +/* */ +/* TypedCertificate */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235TypedCertificate { + ASN1OBJID type; + ASN1DynOctStr certificate; +} H235TypedCertificate; + +EXTERN int asn1PE_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue); + +EXTERN int asn1PD_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue); + +/**************************************************************/ +/* */ +/* Identifier */ +/* */ +/**************************************************************/ + +typedef ASN1BMPString H235Identifier; + +EXTERN int asn1PE_H235Identifier (OOCTXT* pctxt, H235Identifier value); + +EXTERN int asn1PD_H235Identifier (OOCTXT* pctxt, H235Identifier* pvalue); + +/**************************************************************/ +/* */ +/* ECpoint_x */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECpoint_x { + ASN1UINT numbits; + ASN1OCTET data[64]; +} H235ECpoint_x; + +EXTERN int asn1PE_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue); + +EXTERN int asn1PD_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue); + +/**************************************************************/ +/* */ +/* ECpoint_y */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECpoint_y { + ASN1UINT numbits; + ASN1OCTET data[64]; +} H235ECpoint_y; + +EXTERN int asn1PE_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue); + +EXTERN int asn1PD_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue); + +/**************************************************************/ +/* */ +/* ECpoint */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECpoint { + struct { + unsigned xPresent : 1; + unsigned yPresent : 1; + } m; + H235ECpoint_x x; + H235ECpoint_y y; +} H235ECpoint; + +EXTERN int asn1PE_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue); + +EXTERN int asn1PD_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_modulus */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECKASDH_eckasdhp_modulus { + ASN1UINT numbits; + ASN1OCTET data[64]; +} H235ECKASDH_eckasdhp_modulus; + +EXTERN int asn1PE_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue); + +EXTERN int asn1PD_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_weierstrassA */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECKASDH_eckasdhp_weierstrassA { + ASN1UINT numbits; + ASN1OCTET data[64]; +} H235ECKASDH_eckasdhp_weierstrassA; + +EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue); + +EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_weierstrassB */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECKASDH_eckasdhp_weierstrassB { + ASN1UINT numbits; + ASN1OCTET data[64]; +} H235ECKASDH_eckasdhp_weierstrassB; + +EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue); + +EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECKASDH_eckasdhp { + H235ECpoint public_key; + H235ECKASDH_eckasdhp_modulus modulus; + H235ECpoint base; + H235ECKASDH_eckasdhp_weierstrassA weierstrassA; + H235ECKASDH_eckasdhp_weierstrassB weierstrassB; +} H235ECKASDH_eckasdhp; + +EXTERN int asn1PE_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue); + +EXTERN int asn1PD_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_fieldSize */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECKASDH_eckasdh2_fieldSize { + ASN1UINT numbits; + ASN1OCTET data[64]; +} H235ECKASDH_eckasdh2_fieldSize; + +EXTERN int asn1PE_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue); + +EXTERN int asn1PD_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_weierstrassA */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECKASDH_eckasdh2_weierstrassA { + ASN1UINT numbits; + ASN1OCTET data[64]; +} H235ECKASDH_eckasdh2_weierstrassA; + +EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue); + +EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_weierstrassB */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECKASDH_eckasdh2_weierstrassB { + ASN1UINT numbits; + ASN1OCTET data[64]; +} H235ECKASDH_eckasdh2_weierstrassB; + +EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue); + +EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ECKASDH_eckasdh2 { + H235ECpoint public_key; + H235ECKASDH_eckasdh2_fieldSize fieldSize; + H235ECpoint base; + H235ECKASDH_eckasdh2_weierstrassA weierstrassA; + H235ECKASDH_eckasdh2_weierstrassB weierstrassB; +} H235ECKASDH_eckasdh2; + +EXTERN int asn1PE_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue); + +EXTERN int asn1PD_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue); + +/**************************************************************/ +/* */ +/* ECKASDH */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H235ECKASDH_eckasdhp 1 +#define T_H235ECKASDH_eckasdh2 2 +#define T_H235ECKASDH_extElem1 3 + +typedef struct EXTERN H235ECKASDH { + int t; + union { + /* t = 1 */ + H235ECKASDH_eckasdhp *eckasdhp; + /* t = 2 */ + H235ECKASDH_eckasdh2 *eckasdh2; + /* t = 3 */ + } u; +} H235ECKASDH; + +EXTERN int asn1PE_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue); + +EXTERN int asn1PD_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue); + +/**************************************************************/ +/* */ +/* ClearToken */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ClearToken { + struct { + unsigned timeStampPresent : 1; + unsigned passwordPresent : 1; + unsigned dhkeyPresent : 1; + unsigned challengePresent : 1; + unsigned randomPresent : 1; + unsigned certificatePresent : 1; + unsigned generalIDPresent : 1; + unsigned nonStandardPresent : 1; + unsigned eckasdhkeyPresent : 1; + unsigned sendersIDPresent : 1; + } m; + ASN1OBJID tokenOID; + H235TimeStamp timeStamp; + H235Password password; + H235DHset dhkey; + H235ChallengeString challenge; + H235RandomVal random; + H235TypedCertificate certificate; + H235Identifier generalID; + H235NonStandardParameter nonStandard; + H235ECKASDH eckasdhkey; + H235Identifier sendersID; +} H235ClearToken; + +EXTERN int asn1PE_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue); + +EXTERN int asn1PD_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue); + +/**************************************************************/ +/* */ +/* IV8 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235IV8 { + ASN1UINT numocts; + ASN1OCTET data[8]; +} H235IV8; + +EXTERN int asn1PE_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue); + +EXTERN int asn1PD_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue); + +/**************************************************************/ +/* */ +/* IV16 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235IV16 { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H235IV16; + +EXTERN int asn1PE_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue); + +EXTERN int asn1PD_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue); + +/**************************************************************/ +/* */ +/* Params */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235Params { + struct { + unsigned ranIntPresent : 1; + unsigned iv8Present : 1; + unsigned iv16Present : 1; + } m; + ASN1INT ranInt; + H235IV8 iv8; + H235IV16 iv16; +} H235Params; + +EXTERN int asn1PE_H235Params (OOCTXT* pctxt, H235Params* pvalue); + +EXTERN int asn1PD_H235Params (OOCTXT* pctxt, H235Params* pvalue); + +/**************************************************************/ +/* */ +/* ENCRYPTED */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235ENCRYPTED { + ASN1OBJID algorithmOID; + H235Params paramS; + ASN1DynOctStr encryptedData; +} H235ENCRYPTED; + +EXTERN int asn1PE_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue); + +EXTERN int asn1PD_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue); + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoEncryptedToken */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235CryptoToken_cryptoEncryptedToken { + ASN1OBJID tokenOID; + H235ENCRYPTED token; +} H235CryptoToken_cryptoEncryptedToken; + +EXTERN int asn1PE_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue); + +EXTERN int asn1PD_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue); + +/**************************************************************/ +/* */ +/* EncodedGeneralToken */ +/* */ +/**************************************************************/ + +typedef ASN1OpenType H235EncodedGeneralToken; + +EXTERN int asn1PE_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken value); + +EXTERN int asn1PD_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken* pvalue); + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoSignedToken_token */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235CryptoToken_cryptoSignedToken_token { + H235EncodedGeneralToken toBeSigned; + ASN1OBJID algorithmOID; + H235Params paramS; + ASN1DynBitStr signature; +} H235CryptoToken_cryptoSignedToken_token; + +EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue); + +EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue); + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoSignedToken */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235CryptoToken_cryptoSignedToken { + ASN1OBJID tokenOID; + H235CryptoToken_cryptoSignedToken_token token; +} H235CryptoToken_cryptoSignedToken; + +EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue); + +EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue); + +/**************************************************************/ +/* */ +/* HASHED */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235HASHED { + ASN1OBJID algorithmOID; + H235Params paramS; + ASN1DynBitStr hash; +} H235HASHED; + +EXTERN int asn1PE_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue); + +EXTERN int asn1PD_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue); + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoHashedToken */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H235CryptoToken_cryptoHashedToken { + ASN1OBJID tokenOID; + H235ClearToken hashedVals; + H235HASHED token; +} H235CryptoToken_cryptoHashedToken; + +EXTERN int asn1PE_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue); + +EXTERN int asn1PD_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue); + +/**************************************************************/ +/* */ +/* CryptoToken */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H235CryptoToken_cryptoEncryptedToken 1 +#define T_H235CryptoToken_cryptoSignedToken 2 +#define T_H235CryptoToken_cryptoHashedToken 3 +#define T_H235CryptoToken_cryptoPwdEncr 4 +#define T_H235CryptoToken_extElem1 5 + +typedef struct EXTERN H235CryptoToken { + int t; + union { + /* t = 1 */ + H235CryptoToken_cryptoEncryptedToken *cryptoEncryptedToken; + /* t = 2 */ + H235CryptoToken_cryptoSignedToken *cryptoSignedToken; + /* t = 3 */ + H235CryptoToken_cryptoHashedToken *cryptoHashedToken; + /* t = 4 */ + H235ENCRYPTED *cryptoPwdEncr; + /* t = 5 */ + } u; +} H235CryptoToken; + +EXTERN int asn1PE_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue); + +EXTERN int asn1PD_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESDec.c b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESDec.c new file mode 100644 index 000000000..897bf0eec --- /dev/null +++ b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESDec.c @@ -0,0 +1,1782 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#include "ooasn1.h" +#include "H235-SECURITY-MESSAGES.h" +#include "eventHandler.h" + +/**************************************************************/ +/* */ +/* ChallengeString */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 8, 128, 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); +} + +/**************************************************************/ +/* */ +/* TimeStamp */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUnsigned (pctxt, pvalue, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* RandomVal */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235RandomVal (OOCTXT* pctxt, H235RandomVal* pvalue) +{ + int stat = ASN_OK; + + stat = decodeUnconsInteger (pctxt, pvalue); + if (stat != ASN_OK) return stat; + invokeIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* Password */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235Password (OOCTXT* pctxt, H235Password* 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); +} + +/**************************************************************/ +/* */ +/* EncodedPwdCertToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken* 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); +} + +/**************************************************************/ +/* */ +/* NonStandardParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue) +{ + int stat = ASN_OK; + + /* decode nonStandardIdentifier */ + + invokeStartElement (pctxt, "nonStandardIdentifier", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->nonStandardIdentifier); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->nonStandardIdentifier.numids, pvalue->nonStandardIdentifier.subid); + + 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); +} + +/**************************************************************/ +/* */ +/* AuthenticationBES */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* default_ */ + case 0: + invokeStartElement (pctxt, "default_", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "default_", -1); + + break; + + /* radius */ + case 1: + invokeStartElement (pctxt, "radius", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "radius", -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); +} + +/**************************************************************/ +/* */ +/* AuthenticationMechanism */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* dhExch */ + case 0: + invokeStartElement (pctxt, "dhExch", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "dhExch", -1); + + break; + + /* pwdSymEnc */ + case 1: + invokeStartElement (pctxt, "pwdSymEnc", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "pwdSymEnc", -1); + + break; + + /* pwdHash */ + case 2: + invokeStartElement (pctxt, "pwdHash", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "pwdHash", -1); + + break; + + /* certSign */ + case 3: + invokeStartElement (pctxt, "certSign", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "certSign", -1); + + break; + + /* ipsec */ + case 4: + invokeStartElement (pctxt, "ipsec", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "ipsec", -1); + + break; + + /* tls */ + case 5: + invokeStartElement (pctxt, "tls", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "tls", -1); + + break; + + /* nonStandard */ + case 6: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H235NonStandardParameter); + + stat = asn1PD_H235NonStandardParameter (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 + 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) { + /* authenticationBES */ + case 8: + invokeStartElement (pctxt, "authenticationBES", -1); + + pvalue->u.authenticationBES = ALLOC_ASN1ELEM (pctxt, H235AuthenticationBES); + + stat = asn1PD_H235AuthenticationBES (pctxt, pvalue->u.authenticationBES); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "authenticationBES", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DHset_halfkey */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 2048, 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); +} + +/**************************************************************/ +/* */ +/* DHset_modSize */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 2048, 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); +} + +/**************************************************************/ +/* */ +/* DHset_generator */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 2048, 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); +} + +/**************************************************************/ +/* */ +/* DHset */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235DHset (OOCTXT* pctxt, H235DHset* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode halfkey */ + + invokeStartElement (pctxt, "halfkey", -1); + + stat = asn1PD_H235DHset_halfkey (pctxt, &pvalue->halfkey); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "halfkey", -1); + + /* decode modSize */ + + invokeStartElement (pctxt, "modSize", -1); + + stat = asn1PD_H235DHset_modSize (pctxt, &pvalue->modSize); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "modSize", -1); + + /* decode generator */ + + invokeStartElement (pctxt, "generator", -1); + + stat = asn1PD_H235DHset_generator (pctxt, &pvalue->generator); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "generator", -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); +} + +/**************************************************************/ +/* */ +/* TypedCertificate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->type.numids, pvalue->type.subid); + + invokeEndElement (pctxt, "type", -1); + + /* decode certificate */ + + invokeStartElement (pctxt, "certificate", -1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->certificate); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->certificate.numocts, pvalue->certificate.data); + + invokeEndElement (pctxt, "certificate", -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); +} + +/**************************************************************/ +/* */ +/* Identifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235Identifier (OOCTXT* pctxt, H235Identifier* 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); +} + +/**************************************************************/ +/* */ +/* ECpoint_x */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 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); +} + +/**************************************************************/ +/* */ +/* ECpoint_y */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 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); +} + +/**************************************************************/ +/* */ +/* ECpoint */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.xPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.yPresent = optbit; + + /* decode x */ + + if (pvalue->m.xPresent) { + invokeStartElement (pctxt, "x", -1); + + stat = asn1PD_H235ECpoint_x (pctxt, &pvalue->x); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "x", -1); + } + + /* decode y */ + + if (pvalue->m.yPresent) { + invokeStartElement (pctxt, "y", -1); + + stat = asn1PD_H235ECpoint_y (pctxt, &pvalue->y); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "y", -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); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_modulus */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 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); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_weierstrassA */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 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); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_weierstrassB */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 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); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue) +{ + int stat = ASN_OK; + + /* decode public_key */ + + invokeStartElement (pctxt, "public_key", -1); + + stat = asn1PD_H235ECpoint (pctxt, &pvalue->public_key); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "public_key", -1); + + /* decode modulus */ + + invokeStartElement (pctxt, "modulus", -1); + + stat = asn1PD_H235ECKASDH_eckasdhp_modulus (pctxt, &pvalue->modulus); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "modulus", -1); + + /* decode base */ + + invokeStartElement (pctxt, "base", -1); + + stat = asn1PD_H235ECpoint (pctxt, &pvalue->base); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "base", -1); + + /* decode weierstrassA */ + + invokeStartElement (pctxt, "weierstrassA", -1); + + stat = asn1PD_H235ECKASDH_eckasdhp_weierstrassA (pctxt, &pvalue->weierstrassA); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "weierstrassA", -1); + + /* decode weierstrassB */ + + invokeStartElement (pctxt, "weierstrassB", -1); + + stat = asn1PD_H235ECKASDH_eckasdhp_weierstrassB (pctxt, &pvalue->weierstrassB); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "weierstrassB", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_fieldSize */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 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); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_weierstrassA */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 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); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_weierstrassB */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 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); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue) +{ + int stat = ASN_OK; + + /* decode public_key */ + + invokeStartElement (pctxt, "public_key", -1); + + stat = asn1PD_H235ECpoint (pctxt, &pvalue->public_key); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "public_key", -1); + + /* decode fieldSize */ + + invokeStartElement (pctxt, "fieldSize", -1); + + stat = asn1PD_H235ECKASDH_eckasdh2_fieldSize (pctxt, &pvalue->fieldSize); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "fieldSize", -1); + + /* decode base */ + + invokeStartElement (pctxt, "base", -1); + + stat = asn1PD_H235ECpoint (pctxt, &pvalue->base); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "base", -1); + + /* decode weierstrassA */ + + invokeStartElement (pctxt, "weierstrassA", -1); + + stat = asn1PD_H235ECKASDH_eckasdh2_weierstrassA (pctxt, &pvalue->weierstrassA); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "weierstrassA", -1); + + /* decode weierstrassB */ + + invokeStartElement (pctxt, "weierstrassB", -1); + + stat = asn1PD_H235ECKASDH_eckasdh2_weierstrassB (pctxt, &pvalue->weierstrassB); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "weierstrassB", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* eckasdhp */ + case 0: + invokeStartElement (pctxt, "eckasdhp", -1); + + pvalue->u.eckasdhp = ALLOC_ASN1ELEM (pctxt, H235ECKASDH_eckasdhp); + + stat = asn1PD_H235ECKASDH_eckasdhp (pctxt, pvalue->u.eckasdhp); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "eckasdhp", -1); + + break; + + /* eckasdh2 */ + case 1: + invokeStartElement (pctxt, "eckasdh2", -1); + + pvalue->u.eckasdh2 = ALLOC_ASN1ELEM (pctxt, H235ECKASDH_eckasdh2); + + stat = asn1PD_H235ECKASDH_eckasdh2 (pctxt, pvalue->u.eckasdh2); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "eckasdh2", -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); +} + +/**************************************************************/ +/* */ +/* ClearToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.timeStampPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.passwordPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.dhkeyPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.challengePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.randomPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.certificatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.generalIDPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.nonStandardPresent = optbit; + + /* decode tokenOID */ + + invokeStartElement (pctxt, "tokenOID", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid); + + invokeEndElement (pctxt, "tokenOID", -1); + + /* decode timeStamp */ + + if (pvalue->m.timeStampPresent) { + invokeStartElement (pctxt, "timeStamp", -1); + + stat = asn1PD_H235TimeStamp (pctxt, &pvalue->timeStamp); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "timeStamp", -1); + } + + /* decode password */ + + if (pvalue->m.passwordPresent) { + invokeStartElement (pctxt, "password", -1); + + stat = asn1PD_H235Password (pctxt, &pvalue->password); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "password", -1); + } + + /* decode dhkey */ + + if (pvalue->m.dhkeyPresent) { + invokeStartElement (pctxt, "dhkey", -1); + + stat = asn1PD_H235DHset (pctxt, &pvalue->dhkey); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dhkey", -1); + } + + /* decode challenge */ + + if (pvalue->m.challengePresent) { + invokeStartElement (pctxt, "challenge", -1); + + stat = asn1PD_H235ChallengeString (pctxt, &pvalue->challenge); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "challenge", -1); + } + + /* decode random */ + + if (pvalue->m.randomPresent) { + invokeStartElement (pctxt, "random", -1); + + stat = asn1PD_H235RandomVal (pctxt, &pvalue->random); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "random", -1); + } + + /* decode certificate */ + + if (pvalue->m.certificatePresent) { + invokeStartElement (pctxt, "certificate", -1); + + stat = asn1PD_H235TypedCertificate (pctxt, &pvalue->certificate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "certificate", -1); + } + + /* decode generalID */ + + if (pvalue->m.generalIDPresent) { + invokeStartElement (pctxt, "generalID", -1); + + stat = asn1PD_H235Identifier (pctxt, &pvalue->generalID); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "generalID", -1); + } + + /* decode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + invokeStartElement (pctxt, "nonStandard", -1); + + stat = asn1PD_H235NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -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.eckasdhkeyPresent = 1; + + invokeStartElement (pctxt, "eckasdhkey", -1); + + stat = asn1PD_H235ECKASDH (pctxt, &pvalue->eckasdhkey); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "eckasdhkey", -1); + break; + + case 1: + pvalue->m.sendersIDPresent = 1; + + invokeStartElement (pctxt, "sendersID", -1); + + stat = asn1PD_H235Identifier (pctxt, &pvalue->sendersID); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sendersID", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IV8 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 8, 8, 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); +} + +/**************************************************************/ +/* */ +/* IV16 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235IV16 (OOCTXT* pctxt, H235IV16* 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); +} + +/**************************************************************/ +/* */ +/* Params */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235Params (OOCTXT* pctxt, H235Params* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.ranIntPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.iv8Present = optbit; + + /* decode ranInt */ + + if (pvalue->m.ranIntPresent) { + invokeStartElement (pctxt, "ranInt", -1); + + stat = decodeUnconsInteger (pctxt, &pvalue->ranInt); + if (stat != ASN_OK) return stat; + invokeIntValue (pctxt, pvalue->ranInt); + + invokeEndElement (pctxt, "ranInt", -1); + } + + /* decode iv8 */ + + if (pvalue->m.iv8Present) { + invokeStartElement (pctxt, "iv8", -1); + + stat = asn1PD_H235IV8 (pctxt, &pvalue->iv8); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "iv8", -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.iv16Present = 1; + + invokeStartElement (pctxt, "iv16", -1); + + stat = asn1PD_H235IV16 (pctxt, &pvalue->iv16); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "iv16", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ENCRYPTED */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* 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 paramS */ + + invokeStartElement (pctxt, "paramS", -1); + + stat = asn1PD_H235Params (pctxt, &pvalue->paramS); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "paramS", -1); + + /* decode encryptedData */ + + invokeStartElement (pctxt, "encryptedData", -1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->encryptedData); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->encryptedData.numocts, pvalue->encryptedData.data); + + invokeEndElement (pctxt, "encryptedData", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoEncryptedToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue) +{ + int stat = ASN_OK; + + /* decode tokenOID */ + + invokeStartElement (pctxt, "tokenOID", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid); + + invokeEndElement (pctxt, "tokenOID", -1); + + /* decode token */ + + invokeStartElement (pctxt, "token", -1); + + stat = asn1PD_H235ENCRYPTED (pctxt, &pvalue->token); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "token", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncodedGeneralToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken* 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); +} + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoSignedToken_token */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue) +{ + int stat = ASN_OK; + + /* decode toBeSigned */ + + invokeStartElement (pctxt, "toBeSigned", -1); + + stat = asn1PD_H235EncodedGeneralToken (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); +} + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoSignedToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue) +{ + int stat = ASN_OK; + + /* decode tokenOID */ + + invokeStartElement (pctxt, "tokenOID", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid); + + invokeEndElement (pctxt, "tokenOID", -1); + + /* decode token */ + + invokeStartElement (pctxt, "token", -1); + + stat = asn1PD_H235CryptoToken_cryptoSignedToken_token (pctxt, &pvalue->token); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "token", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* HASHED */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235HASHED (OOCTXT* pctxt, H235HASHED* 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 paramS */ + + invokeStartElement (pctxt, "paramS", -1); + + stat = asn1PD_H235Params (pctxt, &pvalue->paramS); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "paramS", -1); + + /* decode hash */ + + invokeStartElement (pctxt, "hash", -1); + + stat = decodeDynBitString (pctxt, (ASN1DynBitStr*)&pvalue->hash); + if (stat != ASN_OK) return stat; + + invokeBitStrValue (pctxt, pvalue->hash.numbits, pvalue->hash.data); + + invokeEndElement (pctxt, "hash", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoHashedToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue) +{ + int stat = ASN_OK; + + /* decode tokenOID */ + + invokeStartElement (pctxt, "tokenOID", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->tokenOID); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->tokenOID.numids, pvalue->tokenOID.subid); + + invokeEndElement (pctxt, "tokenOID", -1); + + /* decode hashedVals */ + + invokeStartElement (pctxt, "hashedVals", -1); + + stat = asn1PD_H235ClearToken (pctxt, &pvalue->hashedVals); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "hashedVals", -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); +} + +/**************************************************************/ +/* */ +/* CryptoToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* cryptoEncryptedToken */ + case 0: + invokeStartElement (pctxt, "cryptoEncryptedToken", -1); + + pvalue->u.cryptoEncryptedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoEncryptedToken); + + stat = asn1PD_H235CryptoToken_cryptoEncryptedToken (pctxt, pvalue->u.cryptoEncryptedToken); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cryptoEncryptedToken", -1); + + break; + + /* cryptoSignedToken */ + case 1: + invokeStartElement (pctxt, "cryptoSignedToken", -1); + + pvalue->u.cryptoSignedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoSignedToken); + + stat = asn1PD_H235CryptoToken_cryptoSignedToken (pctxt, pvalue->u.cryptoSignedToken); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cryptoSignedToken", -1); + + break; + + /* cryptoHashedToken */ + case 2: + invokeStartElement (pctxt, "cryptoHashedToken", -1); + + pvalue->u.cryptoHashedToken = ALLOC_ASN1ELEM (pctxt, H235CryptoToken_cryptoHashedToken); + + stat = asn1PD_H235CryptoToken_cryptoHashedToken (pctxt, pvalue->u.cryptoHashedToken); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cryptoHashedToken", -1); + + break; + + /* cryptoPwdEncr */ + case 3: + invokeStartElement (pctxt, "cryptoPwdEncr", -1); + + pvalue->u.cryptoPwdEncr = ALLOC_ASN1ELEM (pctxt, H235ENCRYPTED); + + stat = asn1PD_H235ENCRYPTED (pctxt, pvalue->u.cryptoPwdEncr); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cryptoPwdEncr", -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); +} + diff --git a/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESEnc.c b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESEnc.c new file mode 100644 index 000000000..8530c5198 --- /dev/null +++ b/addons/ooh323c/src/h323/H235-SECURITY-MESSAGESEnc.c @@ -0,0 +1,1269 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#include "ooasn1.h" +#include "H235-SECURITY-MESSAGES.h" + +/**************************************************************/ +/* */ +/* ChallengeString */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ChallengeString (OOCTXT* pctxt, H235ChallengeString* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 8, 128, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TimeStamp */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235TimeStamp (OOCTXT* pctxt, H235TimeStamp value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RandomVal */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235RandomVal (OOCTXT* pctxt, H235RandomVal value) +{ + int stat = ASN_OK; + + stat = encodeUnconsInteger (pctxt, value); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Password */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235Password (OOCTXT* pctxt, H235Password value) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBMPString (pctxt, value, 0); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncodedPwdCertToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235EncodedPwdCertToken (OOCTXT* pctxt, H235EncodedPwdCertToken value) +{ + int stat = ASN_OK; + + stat = encodeOpenType (pctxt, value.numocts, value.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235NonStandardParameter (OOCTXT* pctxt, H235NonStandardParameter* pvalue) +{ + int stat = ASN_OK; + + /* encode nonStandardIdentifier */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->nonStandardIdentifier); + if (stat != ASN_OK) return stat; + + /* encode data */ + + stat = encodeOctetString (pctxt, pvalue->data.numocts, pvalue->data.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* AuthenticationBES */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235AuthenticationBES (OOCTXT* pctxt, H235AuthenticationBES* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* default_ */ + case 1: + /* NULL */ + break; + + /* radius */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AuthenticationMechanism */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235AuthenticationMechanism (OOCTXT* pctxt, H235AuthenticationMechanism* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 7); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* dhExch */ + case 1: + /* NULL */ + break; + + /* pwdSymEnc */ + case 2: + /* NULL */ + break; + + /* pwdHash */ + case 3: + /* NULL */ + break; + + /* certSign */ + case 4: + /* NULL */ + break; + + /* ipsec */ + case 5: + /* NULL */ + break; + + /* tls */ + case 6: + /* NULL */ + break; + + /* nonStandard */ + case 7: + stat = asn1PE_H235NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* authenticationBES */ + case 8: + stat = asn1PE_H235AuthenticationBES (&lctxt, pvalue->u.authenticationBES); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DHset_halfkey */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235DHset_halfkey (OOCTXT* pctxt, H235DHset_halfkey* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DHset_modSize */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235DHset_modSize (OOCTXT* pctxt, H235DHset_modSize* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DHset_generator */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235DHset_generator (OOCTXT* pctxt, H235DHset_generator* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 2048, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DHset */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235DHset (OOCTXT* pctxt, H235DHset* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode halfkey */ + + stat = asn1PE_H235DHset_halfkey (pctxt, &pvalue->halfkey); + if (stat != ASN_OK) return stat; + + /* encode modSize */ + + stat = asn1PE_H235DHset_modSize (pctxt, &pvalue->modSize); + if (stat != ASN_OK) return stat; + + /* encode generator */ + + stat = asn1PE_H235DHset_generator (pctxt, &pvalue->generator); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TypedCertificate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235TypedCertificate (OOCTXT* pctxt, H235TypedCertificate* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + /* encode certificate */ + + stat = encodeOctetString (pctxt, pvalue->certificate.numocts, pvalue->certificate.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Identifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235Identifier (OOCTXT* pctxt, H235Identifier value) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBMPString (pctxt, value, 0); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECpoint_x */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECpoint_x (OOCTXT* pctxt, H235ECpoint_x* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECpoint_y */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECpoint_y (OOCTXT* pctxt, H235ECpoint_y* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECpoint */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECpoint (OOCTXT* pctxt, H235ECpoint* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.xPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.yPresent); + + /* encode x */ + + if (pvalue->m.xPresent) { + stat = asn1PE_H235ECpoint_x (pctxt, &pvalue->x); + if (stat != ASN_OK) return stat; + } + + /* encode y */ + + if (pvalue->m.yPresent) { + stat = asn1PE_H235ECpoint_y (pctxt, &pvalue->y); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_modulus */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH_eckasdhp_modulus (OOCTXT* pctxt, H235ECKASDH_eckasdhp_modulus* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_weierstrassA */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassA* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp_weierstrassB */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH_eckasdhp_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdhp_weierstrassB* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdhp */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH_eckasdhp (OOCTXT* pctxt, H235ECKASDH_eckasdhp* pvalue) +{ + int stat = ASN_OK; + + /* encode public_key */ + + stat = asn1PE_H235ECpoint (pctxt, &pvalue->public_key); + if (stat != ASN_OK) return stat; + + /* encode modulus */ + + stat = asn1PE_H235ECKASDH_eckasdhp_modulus (pctxt, &pvalue->modulus); + if (stat != ASN_OK) return stat; + + /* encode base */ + + stat = asn1PE_H235ECpoint (pctxt, &pvalue->base); + if (stat != ASN_OK) return stat; + + /* encode weierstrassA */ + + stat = asn1PE_H235ECKASDH_eckasdhp_weierstrassA (pctxt, &pvalue->weierstrassA); + if (stat != ASN_OK) return stat; + + /* encode weierstrassB */ + + stat = asn1PE_H235ECKASDH_eckasdhp_weierstrassB (pctxt, &pvalue->weierstrassB); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_fieldSize */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH_eckasdh2_fieldSize (OOCTXT* pctxt, H235ECKASDH_eckasdh2_fieldSize* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_weierstrassA */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassA (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassA* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2_weierstrassB */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH_eckasdh2_weierstrassB (OOCTXT* pctxt, H235ECKASDH_eckasdh2_weierstrassB* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 0, 511, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH_eckasdh2 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH_eckasdh2 (OOCTXT* pctxt, H235ECKASDH_eckasdh2* pvalue) +{ + int stat = ASN_OK; + + /* encode public_key */ + + stat = asn1PE_H235ECpoint (pctxt, &pvalue->public_key); + if (stat != ASN_OK) return stat; + + /* encode fieldSize */ + + stat = asn1PE_H235ECKASDH_eckasdh2_fieldSize (pctxt, &pvalue->fieldSize); + if (stat != ASN_OK) return stat; + + /* encode base */ + + stat = asn1PE_H235ECpoint (pctxt, &pvalue->base); + if (stat != ASN_OK) return stat; + + /* encode weierstrassA */ + + stat = asn1PE_H235ECKASDH_eckasdh2_weierstrassA (pctxt, &pvalue->weierstrassA); + if (stat != ASN_OK) return stat; + + /* encode weierstrassB */ + + stat = asn1PE_H235ECKASDH_eckasdh2_weierstrassB (pctxt, &pvalue->weierstrassB); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ECKASDH */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ECKASDH (OOCTXT* pctxt, H235ECKASDH* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* eckasdhp */ + case 1: + stat = asn1PE_H235ECKASDH_eckasdhp (pctxt, pvalue->u.eckasdhp); + if (stat != ASN_OK) return stat; + break; + + /* eckasdh2 */ + case 2: + stat = asn1PE_H235ECKASDH_eckasdh2 (pctxt, pvalue->u.eckasdh2); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ClearToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ClearToken (OOCTXT* pctxt, H235ClearToken* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.eckasdhkeyPresent || + pvalue->m.sendersIDPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.timeStampPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.passwordPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dhkeyPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.challengePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.randomPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.certificatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.generalIDPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + /* encode tokenOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID); + if (stat != ASN_OK) return stat; + + /* encode timeStamp */ + + if (pvalue->m.timeStampPresent) { + stat = asn1PE_H235TimeStamp (pctxt, pvalue->timeStamp); + if (stat != ASN_OK) return stat; + } + + /* encode password */ + + if (pvalue->m.passwordPresent) { + stat = asn1PE_H235Password (pctxt, pvalue->password); + if (stat != ASN_OK) return stat; + } + + /* encode dhkey */ + + if (pvalue->m.dhkeyPresent) { + stat = asn1PE_H235DHset (pctxt, &pvalue->dhkey); + if (stat != ASN_OK) return stat; + } + + /* encode challenge */ + + if (pvalue->m.challengePresent) { + stat = asn1PE_H235ChallengeString (pctxt, &pvalue->challenge); + if (stat != ASN_OK) return stat; + } + + /* encode random */ + + if (pvalue->m.randomPresent) { + stat = asn1PE_H235RandomVal (pctxt, pvalue->random); + if (stat != ASN_OK) return stat; + } + + /* encode certificate */ + + if (pvalue->m.certificatePresent) { + stat = asn1PE_H235TypedCertificate (pctxt, &pvalue->certificate); + if (stat != ASN_OK) return stat; + } + + /* encode generalID */ + + if (pvalue->m.generalIDPresent) { + stat = asn1PE_H235Identifier (pctxt, pvalue->generalID); + if (stat != ASN_OK) return stat; + } + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H235NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.eckasdhkeyPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sendersIDPresent); + /* encode extension elements */ + + if (pvalue->m.eckasdhkeyPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H235ECKASDH (&lctxt, &pvalue->eckasdhkey); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.sendersIDPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H235Identifier (&lctxt, pvalue->sendersID); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IV8 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235IV8 (OOCTXT* pctxt, H235IV8* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 8, 8, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* IV16 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235IV16 (OOCTXT* pctxt, H235IV16* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Params */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235Params (OOCTXT* pctxt, H235Params* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.iv16Present); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.ranIntPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.iv8Present); + + /* encode ranInt */ + + if (pvalue->m.ranIntPresent) { + stat = encodeUnconsInteger (pctxt, pvalue->ranInt); + if (stat != ASN_OK) return stat; + } + + /* encode iv8 */ + + if (pvalue->m.iv8Present) { + stat = asn1PE_H235IV8 (pctxt, &pvalue->iv8); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.iv16Present); + /* encode extension elements */ + + if (pvalue->m.iv16Present) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H235IV16 (&lctxt, &pvalue->iv16); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ENCRYPTED */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235ENCRYPTED (OOCTXT* pctxt, H235ENCRYPTED* pvalue) +{ + int stat = ASN_OK; + + /* encode algorithmOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID); + if (stat != ASN_OK) return stat; + + /* encode paramS */ + + stat = asn1PE_H235Params (pctxt, &pvalue->paramS); + if (stat != ASN_OK) return stat; + + /* encode encryptedData */ + + stat = encodeOctetString (pctxt, pvalue->encryptedData.numocts, pvalue->encryptedData.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoEncryptedToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235CryptoToken_cryptoEncryptedToken (OOCTXT* pctxt, H235CryptoToken_cryptoEncryptedToken* pvalue) +{ + int stat = ASN_OK; + + /* encode tokenOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID); + if (stat != ASN_OK) return stat; + + /* encode token */ + + stat = asn1PE_H235ENCRYPTED (pctxt, &pvalue->token); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncodedGeneralToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235EncodedGeneralToken (OOCTXT* pctxt, H235EncodedGeneralToken value) +{ + int stat = ASN_OK; + + stat = encodeOpenType (pctxt, value.numocts, value.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoSignedToken_token */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken_token (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken_token* pvalue) +{ + int stat = ASN_OK; + + /* encode toBeSigned */ + + stat = asn1PE_H235EncodedGeneralToken (pctxt, pvalue->toBeSigned); + if (stat != ASN_OK) return stat; + + /* encode algorithmOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID); + if (stat != ASN_OK) return stat; + + /* encode paramS */ + + stat = asn1PE_H235Params (pctxt, &pvalue->paramS); + if (stat != ASN_OK) return stat; + + /* encode signature */ + + stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoSignedToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235CryptoToken_cryptoSignedToken (OOCTXT* pctxt, H235CryptoToken_cryptoSignedToken* pvalue) +{ + int stat = ASN_OK; + + /* encode tokenOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID); + if (stat != ASN_OK) return stat; + + /* encode token */ + + stat = asn1PE_H235CryptoToken_cryptoSignedToken_token (pctxt, &pvalue->token); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* HASHED */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235HASHED (OOCTXT* pctxt, H235HASHED* pvalue) +{ + int stat = ASN_OK; + + /* encode algorithmOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID); + if (stat != ASN_OK) return stat; + + /* encode paramS */ + + stat = asn1PE_H235Params (pctxt, &pvalue->paramS); + if (stat != ASN_OK) return stat; + + /* encode hash */ + + stat = encodeBitString (pctxt, pvalue->hash.numbits, pvalue->hash.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoToken_cryptoHashedToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235CryptoToken_cryptoHashedToken (OOCTXT* pctxt, H235CryptoToken_cryptoHashedToken* pvalue) +{ + int stat = ASN_OK; + + /* encode tokenOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->tokenOID); + if (stat != ASN_OK) return stat; + + /* encode hashedVals */ + + stat = asn1PE_H235ClearToken (pctxt, &pvalue->hashedVals); + if (stat != ASN_OK) return stat; + + /* encode token */ + + stat = asn1PE_H235HASHED (pctxt, &pvalue->token); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H235CryptoToken (OOCTXT* pctxt, H235CryptoToken* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* cryptoEncryptedToken */ + case 1: + stat = asn1PE_H235CryptoToken_cryptoEncryptedToken (pctxt, pvalue->u.cryptoEncryptedToken); + if (stat != ASN_OK) return stat; + break; + + /* cryptoSignedToken */ + case 2: + stat = asn1PE_H235CryptoToken_cryptoSignedToken (pctxt, pvalue->u.cryptoSignedToken); + if (stat != ASN_OK) return stat; + break; + + /* cryptoHashedToken */ + case 3: + stat = asn1PE_H235CryptoToken_cryptoHashedToken (pctxt, pvalue->u.cryptoHashedToken); + if (stat != ASN_OK) return stat; + break; + + /* cryptoPwdEncr */ + case 4: + stat = asn1PE_H235ENCRYPTED (pctxt, pvalue->u.cryptoPwdEncr); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + diff --git a/addons/ooh323c/src/h323/H323-MESSAGES.c b/addons/ooh323c/src/h323/H323-MESSAGES.c new file mode 100644 index 000000000..2c27f3b93 --- /dev/null +++ b/addons/ooh323c/src/h323/H323-MESSAGES.c @@ -0,0 +1,112 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#include "ooasn1.h" +#include "H323-MESSAGES.h" + +/**************************************************************/ +/* */ +/* NumberDigits */ +/* */ +/**************************************************************/ + +EXTERN const char* gs_H323_MESSAGES_NumberDigits_CharSet = +"#*,0123456789"; + +/**************************************************************/ +/* */ +/* TBCD_STRING */ +/* */ +/**************************************************************/ + +EXTERN const char* gs_H323_MESSAGES_TBCD_STRING_CharSet = +"#*0123456789abc"; + +/**************************************************************/ +/* */ +/* ANSI_41_UIM_system_id */ +/* */ +/**************************************************************/ + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet = +"#*0123456789abc"; + +/**************************************************************/ +/* */ +/* ANSI_41_UIM */ +/* */ +/**************************************************************/ + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet = +"#*0123456789abc"; + +/**************************************************************/ +/* */ +/* GSM_UIM */ +/* */ +/**************************************************************/ + +EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imsi_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_GSM_UIM_imei_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet = +"#*0123456789abc"; + +EXTERN const char* gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet = +"#*0123456789abc"; + +/**************************************************************/ +/* */ +/* AliasAddress */ +/* */ +/**************************************************************/ + +EXTERN const char* gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet = +"#*,0123456789"; + diff --git a/addons/ooh323c/src/h323/H323-MESSAGES.h b/addons/ooh323c/src/h323/H323-MESSAGES.h new file mode 100644 index 000000000..fbd87b336 --- /dev/null +++ b/addons/ooh323c/src/h323/H323-MESSAGES.h @@ -0,0 +1,6510 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#ifndef H323_MESSAGES_H +#define H323_MESSAGES_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "ooasn1.h" +#include "H235-SECURITY-MESSAGES.h" +#include "MULTIMEDIA-SYSTEM-CONTROL.h" + +/**************************************************************/ +/* */ +/* ScreeningIndicator */ +/* */ +/**************************************************************/ + +typedef enum { + userProvidedNotScreened = 0, + userProvidedVerifiedAndPassed = 1, + userProvidedVerifiedAndFailed = 2, + networkProvided = 3 +} H225ScreeningIndicator_Root; + +typedef ASN1UINT H225ScreeningIndicator; + +EXTERN int asn1PE_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator value); + +EXTERN int asn1PD_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator* pvalue); + +/**************************************************************/ +/* */ +/* NumberDigits */ +/* */ +/**************************************************************/ + +typedef ASN1IA5String H225NumberDigits; + +EXTERN int asn1PE_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits value); + +EXTERN int asn1PD_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits* pvalue); + +/**************************************************************/ +/* */ +/* TBCD_STRING */ +/* */ +/**************************************************************/ + +typedef ASN1IA5String H225TBCD_STRING; + +EXTERN int asn1PE_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING value); + +EXTERN int asn1PD_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING* pvalue); + +/**************************************************************/ +/* */ +/* GloballyUniqueID */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GloballyUniqueID { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H225GloballyUniqueID; + +EXTERN int asn1PE_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue); + +EXTERN int asn1PD_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceIdentifier */ +/* */ +/**************************************************************/ + +typedef H225GloballyUniqueID H225ConferenceIdentifier; + +EXTERN int asn1PE_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue); + +EXTERN int asn1PD_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* RequestSeqNum */ +/* */ +/**************************************************************/ + +typedef ASN1USINT H225RequestSeqNum; + +EXTERN int asn1PE_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum value); + +EXTERN int asn1PD_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum* pvalue); + +/**************************************************************/ +/* */ +/* GatekeeperIdentifier */ +/* */ +/**************************************************************/ + +typedef ASN1BMPString H225GatekeeperIdentifier; + +EXTERN int asn1PE_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier value); + +EXTERN int asn1PD_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* BandWidth */ +/* */ +/**************************************************************/ + +typedef ASN1UINT H225BandWidth; + +EXTERN int asn1PE_H225BandWidth (OOCTXT* pctxt, H225BandWidth value); + +EXTERN int asn1PD_H225BandWidth (OOCTXT* pctxt, H225BandWidth* pvalue); + +/**************************************************************/ +/* */ +/* CallReferenceValue */ +/* */ +/**************************************************************/ + +typedef ASN1USINT H225CallReferenceValue; + +EXTERN int asn1PE_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue value); + +EXTERN int asn1PD_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue* pvalue); + +/**************************************************************/ +/* */ +/* EndpointIdentifier */ +/* */ +/**************************************************************/ + +typedef ASN1BMPString H225EndpointIdentifier; + +EXTERN int asn1PE_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier value); + +EXTERN int asn1PD_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* ProtocolIdentifier */ +/* */ +/**************************************************************/ + +typedef ASN1OBJID H225ProtocolIdentifier; + +EXTERN int asn1PE_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier value); + +EXTERN int asn1PD_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* TimeToLive */ +/* */ +/**************************************************************/ + +typedef ASN1UINT H225TimeToLive; + +EXTERN int asn1PE_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive value); + +EXTERN int asn1PD_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive* pvalue); + +/**************************************************************/ +/* */ +/* H248PackagesDescriptor */ +/* */ +/**************************************************************/ + +typedef ASN1DynOctStr H225H248PackagesDescriptor; + +EXTERN int asn1PE_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor value); + +EXTERN int asn1PD_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* H248SignalsDescriptor */ +/* */ +/**************************************************************/ + +typedef ASN1DynOctStr H225H248SignalsDescriptor; + +EXTERN int asn1PE_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor value); + +EXTERN int asn1PD_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* GenericIdentifier */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225GenericIdentifier_standard 1 +#define T_H225GenericIdentifier_oid 2 +#define T_H225GenericIdentifier_nonStandard 3 +#define T_H225GenericIdentifier_extElem1 4 + +typedef struct EXTERN H225GenericIdentifier { + int t; + union { + /* t = 1 */ + ASN1INT standard; + /* t = 2 */ + ASN1OBJID *oid; + /* t = 3 */ + H225GloballyUniqueID *nonStandard; + /* t = 4 */ + } u; +} H225GenericIdentifier; + +EXTERN int asn1PE_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue); + +EXTERN int asn1PD_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipAddress_ip */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipAddress_ip { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H225TransportAddress_ipAddress_ip; + +EXTERN int asn1PE_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipAddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipAddress { + H225TransportAddress_ipAddress_ip ip; + ASN1USINT port; +} H225TransportAddress_ipAddress; + +EXTERN int asn1PE_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipSourceRoute_ip */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipSourceRoute_ip { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H225TransportAddress_ipSourceRoute_ip; + +EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipSourceRoute_route_element */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipSourceRoute_route_element { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H225TransportAddress_ipSourceRoute_route_element; + +EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_route_element* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225TransportAddress_ipSourceRoute_route_element */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225_SeqOfH225TransportAddress_ipSourceRoute_route_element { + ASN1UINT n; + H225TransportAddress_ipSourceRoute_route_element *elem; +} H225_SeqOfH225TransportAddress_ipSourceRoute_route_element; + +EXTERN int asn1PE_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipSourceRoute_routing */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225TransportAddress_ipSourceRoute_routing_strict 1 +#define T_H225TransportAddress_ipSourceRoute_routing_loose 2 +#define T_H225TransportAddress_ipSourceRoute_routing_extElem1 3 + +typedef struct EXTERN H225TransportAddress_ipSourceRoute_routing { + int t; +} H225TransportAddress_ipSourceRoute_routing; + +EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipSourceRoute */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipSourceRoute { + H225TransportAddress_ipSourceRoute_ip ip; + ASN1USINT port; + H225_SeqOfH225TransportAddress_ipSourceRoute_route_element route; + H225TransportAddress_ipSourceRoute_routing routing; +} H225TransportAddress_ipSourceRoute; + +EXTERN int asn1PE_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipxAddress_node */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipxAddress_node { + ASN1UINT numocts; + ASN1OCTET data[6]; +} H225TransportAddress_ipxAddress_node; + +EXTERN int asn1PE_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipxAddress_netnum */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipxAddress_netnum { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H225TransportAddress_ipxAddress_netnum; + +EXTERN int asn1PE_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipxAddress_port */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipxAddress_port { + ASN1UINT numocts; + ASN1OCTET data[2]; +} H225TransportAddress_ipxAddress_port; + +EXTERN int asn1PE_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ipxAddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ipxAddress { + H225TransportAddress_ipxAddress_node node; + H225TransportAddress_ipxAddress_netnum netnum; + H225TransportAddress_ipxAddress_port port; +} H225TransportAddress_ipxAddress; + +EXTERN int asn1PE_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ip6Address_ip */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ip6Address_ip { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H225TransportAddress_ip6Address_ip; + +EXTERN int asn1PE_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_ip6Address */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_ip6Address { + H225TransportAddress_ip6Address_ip ip; + ASN1USINT port; +} H225TransportAddress_ip6Address; + +EXTERN int asn1PE_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue); + +EXTERN int asn1PD_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_netBios */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_netBios { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H225TransportAddress_netBios; + +EXTERN int asn1PE_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue); + +EXTERN int asn1PD_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress_nsap */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportAddress_nsap { + ASN1UINT numocts; + ASN1OCTET data[20]; +} H225TransportAddress_nsap; + +EXTERN int asn1PE_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue); + +EXTERN int asn1PD_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue); + +/**************************************************************/ +/* */ +/* H221NonStandard */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H221NonStandard { + ASN1UINT8 t35CountryCode; + ASN1UINT8 t35Extension; + ASN1USINT manufacturerCode; +} H225H221NonStandard; + +EXTERN int asn1PE_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue); + +EXTERN int asn1PD_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue); + +/**************************************************************/ +/* */ +/* NonStandardIdentifier */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225NonStandardIdentifier_object 1 +#define T_H225NonStandardIdentifier_h221NonStandard 2 +#define T_H225NonStandardIdentifier_extElem1 3 + +typedef struct EXTERN H225NonStandardIdentifier { + int t; + union { + /* t = 1 */ + ASN1OBJID *object; + /* t = 2 */ + H225H221NonStandard *h221NonStandard; + /* t = 3 */ + } u; +} H225NonStandardIdentifier; + +EXTERN int asn1PE_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue); + +EXTERN int asn1PD_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* NonStandardParameter */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225NonStandardParameter { + H225NonStandardIdentifier nonStandardIdentifier; + ASN1DynOctStr data; +} H225NonStandardParameter; + +EXTERN int asn1PE_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue); + +EXTERN int asn1PD_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225TransportAddress_ipAddress 1 +#define T_H225TransportAddress_ipSourceRoute 2 +#define T_H225TransportAddress_ipxAddress 3 +#define T_H225TransportAddress_ip6Address 4 +#define T_H225TransportAddress_netBios 5 +#define T_H225TransportAddress_nsap 6 +#define T_H225TransportAddress_nonStandardAddress 7 +#define T_H225TransportAddress_extElem1 8 + +typedef struct EXTERN H225TransportAddress { + int t; + union { + /* t = 1 */ + H225TransportAddress_ipAddress *ipAddress; + /* t = 2 */ + H225TransportAddress_ipSourceRoute *ipSourceRoute; + /* t = 3 */ + H225TransportAddress_ipxAddress *ipxAddress; + /* t = 4 */ + H225TransportAddress_ip6Address *ip6Address; + /* t = 5 */ + H225TransportAddress_netBios *netBios; + /* t = 6 */ + H225TransportAddress_nsap *nsap; + /* t = 7 */ + H225NonStandardParameter *nonStandardAddress; + /* t = 8 */ + } u; +} H225TransportAddress; + +EXTERN int asn1PE_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue); + +EXTERN int asn1PD_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue); + +/**************************************************************/ +/* */ +/* PublicTypeOfNumber */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225PublicTypeOfNumber_unknown 1 +#define T_H225PublicTypeOfNumber_internationalNumber 2 +#define T_H225PublicTypeOfNumber_nationalNumber 3 +#define T_H225PublicTypeOfNumber_networkSpecificNumber 4 +#define T_H225PublicTypeOfNumber_subscriberNumber 5 +#define T_H225PublicTypeOfNumber_abbreviatedNumber 6 +#define T_H225PublicTypeOfNumber_extElem1 7 + +typedef struct EXTERN H225PublicTypeOfNumber { + int t; +} H225PublicTypeOfNumber; + +EXTERN int asn1PE_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue); + +EXTERN int asn1PD_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue); + +/**************************************************************/ +/* */ +/* PublicPartyNumber */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225PublicPartyNumber { + H225PublicTypeOfNumber publicTypeOfNumber; + H225NumberDigits publicNumberDigits; +} H225PublicPartyNumber; + +EXTERN int asn1PE_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue); + +EXTERN int asn1PD_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue); + +/**************************************************************/ +/* */ +/* PrivateTypeOfNumber */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225PrivateTypeOfNumber_unknown 1 +#define T_H225PrivateTypeOfNumber_level2RegionalNumber 2 +#define T_H225PrivateTypeOfNumber_level1RegionalNumber 3 +#define T_H225PrivateTypeOfNumber_pISNSpecificNumber 4 +#define T_H225PrivateTypeOfNumber_localNumber 5 +#define T_H225PrivateTypeOfNumber_abbreviatedNumber 6 +#define T_H225PrivateTypeOfNumber_extElem1 7 + +typedef struct EXTERN H225PrivateTypeOfNumber { + int t; +} H225PrivateTypeOfNumber; + +EXTERN int asn1PE_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue); + +EXTERN int asn1PD_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue); + +/**************************************************************/ +/* */ +/* PrivatePartyNumber */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225PrivatePartyNumber { + H225PrivateTypeOfNumber privateTypeOfNumber; + H225NumberDigits privateNumberDigits; +} H225PrivatePartyNumber; + +EXTERN int asn1PE_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue); + +EXTERN int asn1PD_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue); + +/**************************************************************/ +/* */ +/* PartyNumber */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225PartyNumber_e164Number 1 +#define T_H225PartyNumber_dataPartyNumber 2 +#define T_H225PartyNumber_telexPartyNumber 3 +#define T_H225PartyNumber_privateNumber 4 +#define T_H225PartyNumber_nationalStandardPartyNumber 5 +#define T_H225PartyNumber_extElem1 6 + +typedef struct EXTERN H225PartyNumber { + int t; + union { + /* t = 1 */ + H225PublicPartyNumber *e164Number; + /* t = 2 */ + H225NumberDigits dataPartyNumber; + /* t = 3 */ + H225NumberDigits telexPartyNumber; + /* t = 4 */ + H225PrivatePartyNumber *privateNumber; + /* t = 5 */ + H225NumberDigits nationalStandardPartyNumber; + /* t = 6 */ + } u; +} H225PartyNumber; + +EXTERN int asn1PE_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue); + +EXTERN int asn1PD_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue); + +/**************************************************************/ +/* */ +/* ANSI_41_UIM_system_id */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225ANSI_41_UIM_system_id_sid 1 +#define T_H225ANSI_41_UIM_system_id_mid 2 +#define T_H225ANSI_41_UIM_system_id_extElem1 3 + +typedef struct EXTERN H225ANSI_41_UIM_system_id { + int t; + union { + /* t = 1 */ + ASN1IA5String sid; + /* t = 2 */ + ASN1IA5String mid; + /* t = 3 */ + } u; +} H225ANSI_41_UIM_system_id; + +EXTERN int asn1PE_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue); + +EXTERN int asn1PD_H225ANSI_41_UIM_system_id (OOCTXT* pctxt, H225ANSI_41_UIM_system_id* pvalue); + +/**************************************************************/ +/* */ +/* ANSI_41_UIM_systemMyTypeCode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ANSI_41_UIM_systemMyTypeCode { + ASN1UINT numocts; + ASN1OCTET data[1]; +} H225ANSI_41_UIM_systemMyTypeCode; + +EXTERN int asn1PE_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue); + +EXTERN int asn1PD_H225ANSI_41_UIM_systemMyTypeCode (OOCTXT* pctxt, H225ANSI_41_UIM_systemMyTypeCode* pvalue); + +/**************************************************************/ +/* */ +/* ANSI_41_UIM_systemAccessType */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ANSI_41_UIM_systemAccessType { + ASN1UINT numocts; + ASN1OCTET data[1]; +} H225ANSI_41_UIM_systemAccessType; + +EXTERN int asn1PE_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue); + +EXTERN int asn1PD_H225ANSI_41_UIM_systemAccessType (OOCTXT* pctxt, H225ANSI_41_UIM_systemAccessType* pvalue); + +/**************************************************************/ +/* */ +/* ANSI_41_UIM_qualificationInformationCode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ANSI_41_UIM_qualificationInformationCode { + ASN1UINT numocts; + ASN1OCTET data[1]; +} H225ANSI_41_UIM_qualificationInformationCode; + +EXTERN int asn1PE_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue); + +EXTERN int asn1PD_H225ANSI_41_UIM_qualificationInformationCode (OOCTXT* pctxt, H225ANSI_41_UIM_qualificationInformationCode* pvalue); + +/**************************************************************/ +/* */ +/* ANSI_41_UIM */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ANSI_41_UIM { + struct { + unsigned imsiPresent : 1; + unsigned minPresent : 1; + unsigned mdnPresent : 1; + unsigned msisdnPresent : 1; + unsigned esnPresent : 1; + unsigned mscidPresent : 1; + unsigned systemMyTypeCodePresent : 1; + unsigned systemAccessTypePresent : 1; + unsigned qualificationInformationCodePresent : 1; + unsigned sesnPresent : 1; + unsigned socPresent : 1; + } m; + ASN1IA5String imsi; + ASN1IA5String min; + ASN1IA5String mdn; + ASN1IA5String msisdn; + ASN1IA5String esn; + ASN1IA5String mscid; + H225ANSI_41_UIM_system_id system_id; + H225ANSI_41_UIM_systemMyTypeCode systemMyTypeCode; + H225ANSI_41_UIM_systemAccessType systemAccessType; + H225ANSI_41_UIM_qualificationInformationCode qualificationInformationCode; + ASN1IA5String sesn; + ASN1IA5String soc; +} H225ANSI_41_UIM; + +EXTERN int asn1PE_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue); + +EXTERN int asn1PD_H225ANSI_41_UIM (OOCTXT* pctxt, H225ANSI_41_UIM* pvalue); + +/**************************************************************/ +/* */ +/* GSM_UIM_tmsi */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GSM_UIM_tmsi { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H225GSM_UIM_tmsi; + +EXTERN int asn1PE_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue); + +EXTERN int asn1PD_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue); + +/**************************************************************/ +/* */ +/* GSM_UIM */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GSM_UIM { + struct { + unsigned imsiPresent : 1; + unsigned tmsiPresent : 1; + unsigned msisdnPresent : 1; + unsigned imeiPresent : 1; + unsigned hplmnPresent : 1; + unsigned vplmnPresent : 1; + } m; + ASN1IA5String imsi; + H225GSM_UIM_tmsi tmsi; + ASN1IA5String msisdn; + ASN1IA5String imei; + ASN1IA5String hplmn; + ASN1IA5String vplmn; +} H225GSM_UIM; + +EXTERN int asn1PE_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue); + +EXTERN int asn1PD_H225GSM_UIM (OOCTXT* pctxt, H225GSM_UIM* pvalue); + +/**************************************************************/ +/* */ +/* MobileUIM */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225MobileUIM_ansi_41_uim 1 +#define T_H225MobileUIM_gsm_uim 2 +#define T_H225MobileUIM_extElem1 3 + +typedef struct EXTERN H225MobileUIM { + int t; + union { + /* t = 1 */ + H225ANSI_41_UIM *ansi_41_uim; + /* t = 2 */ + H225GSM_UIM *gsm_uim; + /* t = 3 */ + } u; +} H225MobileUIM; + +EXTERN int asn1PE_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue); + +EXTERN int asn1PD_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue); + +/**************************************************************/ +/* */ +/* AliasAddress */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225AliasAddress_dialedDigits 1 +#define T_H225AliasAddress_h323_ID 2 +#define T_H225AliasAddress_url_ID 3 +#define T_H225AliasAddress_transportID 4 +#define T_H225AliasAddress_email_ID 5 +#define T_H225AliasAddress_partyNumber 6 +#define T_H225AliasAddress_mobileUIM 7 +#define T_H225AliasAddress_extElem1 8 + +typedef struct EXTERN H225AliasAddress { + int t; + union { + /* t = 1 */ + ASN1IA5String dialedDigits; + /* t = 2 */ + ASN1BMPString h323_ID; + /* t = 3 */ + ASN1IA5String url_ID; + /* t = 4 */ + H225TransportAddress *transportID; + /* t = 5 */ + ASN1IA5String email_ID; + /* t = 6 */ + H225PartyNumber *partyNumber; + /* t = 7 */ + H225MobileUIM *mobileUIM; + /* t = 8 */ + } u; +} H225AliasAddress; + +EXTERN int asn1PE_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue); + +EXTERN int asn1PD_H225AliasAddress (OOCTXT* pctxt, H225AliasAddress* pvalue); + +/**************************************************************/ +/* */ +/* Content_compound */ +/* */ +/**************************************************************/ + +/* List of H225EnumeratedParameter */ +typedef DList H225Content_compound; + +EXTERN int asn1PE_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue); + +EXTERN int asn1PD_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue); + +/**************************************************************/ +/* */ +/* Content_nested */ +/* */ +/**************************************************************/ + +/* List of H225GenericData */ +typedef DList H225Content_nested; + +EXTERN int asn1PE_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue); + +EXTERN int asn1PD_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue); + +/**************************************************************/ +/* */ +/* Content */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225Content_raw 1 +#define T_H225Content_text 2 +#define T_H225Content_unicode 3 +#define T_H225Content_bool_ 4 +#define T_H225Content_number8 5 +#define T_H225Content_number16 6 +#define T_H225Content_number32 7 +#define T_H225Content_id 8 +#define T_H225Content_alias 9 +#define T_H225Content_transport 10 +#define T_H225Content_compound 11 +#define T_H225Content_nested 12 +#define T_H225Content_extElem1 13 + +typedef struct EXTERN H225Content { + int t; + union { + /* t = 1 */ + ASN1DynOctStr *raw; + /* t = 2 */ + ASN1IA5String text; + /* t = 3 */ + ASN1BMPString unicode; + /* t = 4 */ + ASN1BOOL bool_; + /* t = 5 */ + ASN1UINT8 number8; + /* t = 6 */ + ASN1USINT number16; + /* t = 7 */ + ASN1UINT number32; + /* t = 8 */ + H225GenericIdentifier *id; + /* t = 9 */ + H225AliasAddress *alias; + /* t = 10 */ + H225TransportAddress *transport; + /* t = 11 */ + H225Content_compound *compound; + /* t = 12 */ + H225Content_nested *nested; + /* t = 13 */ + } u; +} H225Content; + +EXTERN int asn1PE_H225Content (OOCTXT* pctxt, H225Content* pvalue); + +EXTERN int asn1PD_H225Content (OOCTXT* pctxt, H225Content* pvalue); + +/**************************************************************/ +/* */ +/* EnumeratedParameter */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225EnumeratedParameter { + struct { + unsigned contentPresent : 1; + } m; + H225GenericIdentifier id; + H225Content content; +} H225EnumeratedParameter; + +EXTERN int asn1PE_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue); + +EXTERN int asn1PD_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue); + +/**************************************************************/ +/* */ +/* GenericData_parameters */ +/* */ +/**************************************************************/ + +/* List of H225EnumeratedParameter */ +typedef DList H225GenericData_parameters; + +EXTERN int asn1PE_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue); + +EXTERN int asn1PD_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue); + +/**************************************************************/ +/* */ +/* GenericData */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GenericData { + struct { + unsigned parametersPresent : 1; + } m; + H225GenericIdentifier id; + H225GenericData_parameters parameters; +} H225GenericData; + +EXTERN int asn1PE_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue); + +EXTERN int asn1PD_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue); + +/**************************************************************/ +/* */ +/* FeatureDescriptor */ +/* */ +/**************************************************************/ + +typedef H225GenericData H225FeatureDescriptor; + +EXTERN int asn1PE_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue); + +EXTERN int asn1PD_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* FastStartToken */ +/* */ +/**************************************************************/ + +typedef H235ClearToken H225FastStartToken; + +EXTERN int asn1PE_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue); + +EXTERN int asn1PD_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue); + +/**************************************************************/ +/* */ +/* EncodedFastStartToken */ +/* */ +/**************************************************************/ + +typedef ASN1OpenType H225EncodedFastStartToken; + +EXTERN int asn1PE_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken value); + +EXTERN int asn1PD_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken* pvalue); + +/**************************************************************/ +/* */ +/* H323_UserInformation_user_data_user_information */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323_UserInformation_user_data_user_information { + ASN1UINT numocts; + ASN1OCTET data[131]; +} H225H323_UserInformation_user_data_user_information; + +EXTERN int asn1PE_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue); + +EXTERN int asn1PD_H225H323_UserInformation_user_data_user_information (OOCTXT* pctxt, H225H323_UserInformation_user_data_user_information* pvalue); + +/**************************************************************/ +/* */ +/* EndpointType_set */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225EndpointType_set { + ASN1UINT numbits; + ASN1OCTET data[4]; +} H225EndpointType_set; + +EXTERN int asn1PE_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue); + +EXTERN int asn1PD_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue); + +/**************************************************************/ +/* */ +/* VendorIdentifier_productId */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225VendorIdentifier_productId { + ASN1UINT numocts; + ASN1OCTET data[256]; +} H225VendorIdentifier_productId; + +EXTERN int asn1PE_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue); + +EXTERN int asn1PD_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue); + +/**************************************************************/ +/* */ +/* VendorIdentifier_versionId */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225VendorIdentifier_versionId { + ASN1UINT numocts; + ASN1OCTET data[256]; +} H225VendorIdentifier_versionId; + +EXTERN int asn1PE_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue); + +EXTERN int asn1PD_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue); + +/**************************************************************/ +/* */ +/* CicInfo_cic_element */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CicInfo_cic_element { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H225CicInfo_cic_element; + +EXTERN int asn1PE_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue); + +EXTERN int asn1PD_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue); + +/**************************************************************/ +/* */ +/* CicInfo_pointCode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CicInfo_pointCode { + ASN1UINT numocts; + ASN1OCTET data[5]; +} H225CicInfo_pointCode; + +EXTERN int asn1PE_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue); + +EXTERN int asn1PD_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue); + +/**************************************************************/ +/* */ +/* CarrierInfo_carrierIdentificationCode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CarrierInfo_carrierIdentificationCode { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H225CarrierInfo_carrierIdentificationCode; + +EXTERN int asn1PE_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue); + +EXTERN int asn1PD_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue); + +/**************************************************************/ +/* */ +/* CallTerminationCause_releaseCompleteCauseIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallTerminationCause_releaseCompleteCauseIE { + ASN1UINT numocts; + ASN1OCTET data[32]; +} H225CallTerminationCause_releaseCompleteCauseIE; + +EXTERN int asn1PE_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue); + +EXTERN int asn1PD_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225AliasAddress */ +/* */ +/**************************************************************/ + +/* List of H225AliasAddress */ +typedef DList H225_SeqOfH225AliasAddress; + +EXTERN int asn1PE_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue); + +/**************************************************************/ +/* */ +/* VendorIdentifier */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225VendorIdentifier { + struct { + unsigned productIdPresent : 1; + unsigned versionIdPresent : 1; + unsigned enterpriseNumberPresent : 1; + } m; + H225H221NonStandard vendor; + H225VendorIdentifier_productId productId; + H225VendorIdentifier_versionId versionId; + ASN1OBJID enterpriseNumber; +} H225VendorIdentifier; + +EXTERN int asn1PE_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue); + +EXTERN int asn1PD_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* GatekeeperInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GatekeeperInfo { + struct { + unsigned nonStandardDataPresent : 1; + } m; + H225NonStandardParameter nonStandardData; +} H225GatekeeperInfo; + +EXTERN int asn1PE_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue); + +EXTERN int asn1PD_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue); + +/**************************************************************/ +/* */ +/* DataRate */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225DataRate { + struct { + unsigned nonStandardDataPresent : 1; + unsigned channelMultiplierPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225BandWidth channelRate; + ASN1USINT channelMultiplier; +} H225DataRate; + +EXTERN int asn1PE_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue); + +EXTERN int asn1PD_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225DataRate */ +/* */ +/**************************************************************/ + +/* List of H225DataRate */ +typedef DList H225_SeqOfH225DataRate; + +EXTERN int asn1PE_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue); + +/**************************************************************/ +/* */ +/* SupportedPrefix */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225SupportedPrefix { + struct { + unsigned nonStandardDataPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225AliasAddress prefix; +} H225SupportedPrefix; + +EXTERN int asn1PE_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue); + +EXTERN int asn1PD_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225SupportedPrefix */ +/* */ +/**************************************************************/ + +/* List of H225SupportedPrefix */ +typedef DList H225_SeqOfH225SupportedPrefix; + +EXTERN int asn1PE_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue); + +/**************************************************************/ +/* */ +/* H310Caps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H310Caps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225H310Caps; + +EXTERN int asn1PE_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue); + +EXTERN int asn1PD_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue); + +/**************************************************************/ +/* */ +/* H320Caps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H320Caps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225H320Caps; + +EXTERN int asn1PE_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue); + +EXTERN int asn1PD_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue); + +/**************************************************************/ +/* */ +/* H321Caps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H321Caps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225H321Caps; + +EXTERN int asn1PE_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue); + +EXTERN int asn1PD_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue); + +/**************************************************************/ +/* */ +/* H322Caps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H322Caps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225H322Caps; + +EXTERN int asn1PE_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue); + +EXTERN int asn1PD_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue); + +/**************************************************************/ +/* */ +/* H323Caps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323Caps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225H323Caps; + +EXTERN int asn1PE_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue); + +EXTERN int asn1PD_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue); + +/**************************************************************/ +/* */ +/* H324Caps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H324Caps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225H324Caps; + +EXTERN int asn1PE_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue); + +EXTERN int asn1PD_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue); + +/**************************************************************/ +/* */ +/* VoiceCaps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225VoiceCaps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225VoiceCaps; + +EXTERN int asn1PE_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue); + +EXTERN int asn1PD_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue); + +/**************************************************************/ +/* */ +/* T120OnlyCaps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225T120OnlyCaps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225T120OnlyCaps; + +EXTERN int asn1PE_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue); + +EXTERN int asn1PD_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue); + +/**************************************************************/ +/* */ +/* NonStandardProtocol */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225NonStandardProtocol { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225NonStandardProtocol; + +EXTERN int asn1PE_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue); + +EXTERN int asn1PD_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue); + +/**************************************************************/ +/* */ +/* T38FaxAnnexbOnlyCaps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225T38FaxAnnexbOnlyCaps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; + H245DataProtocolCapability t38FaxProtocol; + H245T38FaxProfile t38FaxProfile; +} H225T38FaxAnnexbOnlyCaps; + +EXTERN int asn1PE_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue); + +EXTERN int asn1PD_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue); + +/**************************************************************/ +/* */ +/* SIPCaps */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225SIPCaps { + struct { + unsigned nonStandardDataPresent : 1; + unsigned dataRatesSupportedPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225DataRate dataRatesSupported; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225SIPCaps; + +EXTERN int asn1PE_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue); + +EXTERN int asn1PD_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue); + +/**************************************************************/ +/* */ +/* SupportedProtocols */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225SupportedProtocols_nonStandardData 1 +#define T_H225SupportedProtocols_h310 2 +#define T_H225SupportedProtocols_h320 3 +#define T_H225SupportedProtocols_h321 4 +#define T_H225SupportedProtocols_h322 5 +#define T_H225SupportedProtocols_h323 6 +#define T_H225SupportedProtocols_h324 7 +#define T_H225SupportedProtocols_voice 8 +#define T_H225SupportedProtocols_t120_only 9 +#define T_H225SupportedProtocols_nonStandardProtocol 10 +#define T_H225SupportedProtocols_t38FaxAnnexbOnly 11 +#define T_H225SupportedProtocols_sip 12 +#define T_H225SupportedProtocols_extElem1 13 + +typedef struct EXTERN H225SupportedProtocols { + int t; + union { + /* t = 1 */ + H225NonStandardParameter *nonStandardData; + /* t = 2 */ + H225H310Caps *h310; + /* t = 3 */ + H225H320Caps *h320; + /* t = 4 */ + H225H321Caps *h321; + /* t = 5 */ + H225H322Caps *h322; + /* t = 6 */ + H225H323Caps *h323; + /* t = 7 */ + H225H324Caps *h324; + /* t = 8 */ + H225VoiceCaps *voice; + /* t = 9 */ + H225T120OnlyCaps *t120_only; + /* t = 10 */ + H225NonStandardProtocol *nonStandardProtocol; + /* t = 11 */ + H225T38FaxAnnexbOnlyCaps *t38FaxAnnexbOnly; + /* t = 12 */ + H225SIPCaps *sip; + /* t = 13 */ + } u; +} H225SupportedProtocols; + +EXTERN int asn1PE_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue); + +EXTERN int asn1PD_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225SupportedProtocols */ +/* */ +/**************************************************************/ + +/* List of H225SupportedProtocols */ +typedef DList H225_SeqOfH225SupportedProtocols; + +EXTERN int asn1PE_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue); + +/**************************************************************/ +/* */ +/* GatewayInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GatewayInfo { + struct { + unsigned protocolPresent : 1; + unsigned nonStandardDataPresent : 1; + } m; + H225_SeqOfH225SupportedProtocols protocol; + H225NonStandardParameter nonStandardData; +} H225GatewayInfo; + +EXTERN int asn1PE_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue); + +EXTERN int asn1PD_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue); + +/**************************************************************/ +/* */ +/* McuInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225McuInfo { + struct { + unsigned nonStandardDataPresent : 1; + unsigned protocolPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225SupportedProtocols protocol; +} H225McuInfo; + +EXTERN int asn1PE_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue); + +EXTERN int asn1PD_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue); + +/**************************************************************/ +/* */ +/* TerminalInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TerminalInfo { + struct { + unsigned nonStandardDataPresent : 1; + } m; + H225NonStandardParameter nonStandardData; +} H225TerminalInfo; + +EXTERN int asn1PE_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue); + +EXTERN int asn1PD_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue); + +/**************************************************************/ +/* */ +/* TunnelledProtocolAlternateIdentifier */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TunnelledProtocolAlternateIdentifier { + struct { + unsigned protocolVariantPresent : 1; + } m; + ASN1IA5String protocolType; + ASN1IA5String protocolVariant; +} H225TunnelledProtocolAlternateIdentifier; + +EXTERN int asn1PE_H225TunnelledProtocolAlternateIdentifier (OOCTXT* pctxt, H225TunnelledProtocolAlternateIdentifier* pvalue); + +EXTERN int asn1PD_H225TunnelledProtocolAlternateIdentifier (OOCTXT* pctxt, H225TunnelledProtocolAlternateIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* TunnelledProtocol_id */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225TunnelledProtocol_id_tunnelledProtocolObjectID 1 +#define T_H225TunnelledProtocol_id_tunnelledProtocolAlternateID 2 +#define T_H225TunnelledProtocol_id_extElem1 3 + +typedef struct EXTERN H225TunnelledProtocol_id { + int t; + union { + /* t = 1 */ + ASN1OBJID *tunnelledProtocolObjectID; + /* t = 2 */ + H225TunnelledProtocolAlternateIdentifier *tunnelledProtocolAlternateID; + /* t = 3 */ + } u; +} H225TunnelledProtocol_id; + +EXTERN int asn1PE_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue); + +EXTERN int asn1PD_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue); + +/**************************************************************/ +/* */ +/* TunnelledProtocol */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TunnelledProtocol { + struct { + unsigned subIdentifierPresent : 1; + } m; + H225TunnelledProtocol_id id; + ASN1IA5String subIdentifier; +} H225TunnelledProtocol; + +EXTERN int asn1PE_H225TunnelledProtocol (OOCTXT* pctxt, H225TunnelledProtocol* pvalue); + +EXTERN int asn1PD_H225TunnelledProtocol (OOCTXT* pctxt, H225TunnelledProtocol* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225TunnelledProtocol */ +/* */ +/**************************************************************/ + +/* List of H225TunnelledProtocol */ +typedef DList H225_SeqOfH225TunnelledProtocol; + +EXTERN int asn1PE_H225_SeqOfH225TunnelledProtocol (OOCTXT* pctxt, H225_SeqOfH225TunnelledProtocol* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225TunnelledProtocol (OOCTXT* pctxt, H225_SeqOfH225TunnelledProtocol* pvalue); + +/**************************************************************/ +/* */ +/* EndpointType */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225EndpointType { + struct { + unsigned nonStandardDataPresent : 1; + unsigned vendorPresent : 1; + unsigned gatekeeperPresent : 1; + unsigned gatewayPresent : 1; + unsigned mcuPresent : 1; + unsigned terminalPresent : 1; + unsigned setPresent : 1; + unsigned supportedTunnelledProtocolsPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225VendorIdentifier vendor; + H225GatekeeperInfo gatekeeper; + H225GatewayInfo gateway; + H225McuInfo mcu; + H225TerminalInfo terminal; + ASN1BOOL mc; + ASN1BOOL undefinedNode; + H225EndpointType_set set; + H225_SeqOfH225TunnelledProtocol supportedTunnelledProtocols; +} H225EndpointType; + +EXTERN int asn1PE_H225EndpointType (OOCTXT* pctxt, H225EndpointType* pvalue); + +EXTERN int asn1PD_H225EndpointType (OOCTXT* pctxt, H225EndpointType* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225CallReferenceValue */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225_SeqOfH225CallReferenceValue { + ASN1UINT n; + H225CallReferenceValue *elem; +} H225_SeqOfH225CallReferenceValue; + +EXTERN int asn1PE_H225_SeqOfH225CallReferenceValue (OOCTXT* pctxt, H225_SeqOfH225CallReferenceValue* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225CallReferenceValue (OOCTXT* pctxt, H225_SeqOfH225CallReferenceValue* pvalue); + +/**************************************************************/ +/* */ +/* Setup_UUIE_conferenceGoal */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225Setup_UUIE_conferenceGoal_create 1 +#define T_H225Setup_UUIE_conferenceGoal_join 2 +#define T_H225Setup_UUIE_conferenceGoal_invite 3 +#define T_H225Setup_UUIE_conferenceGoal_capability_negotiation 4 +#define T_H225Setup_UUIE_conferenceGoal_callIndependentSupplementaryService 5 +#define T_H225Setup_UUIE_conferenceGoal_extElem1 6 + +typedef struct EXTERN H225Setup_UUIE_conferenceGoal { + int t; +} H225Setup_UUIE_conferenceGoal; + +EXTERN int asn1PE_H225Setup_UUIE_conferenceGoal (OOCTXT* pctxt, H225Setup_UUIE_conferenceGoal* pvalue); + +EXTERN int asn1PD_H225Setup_UUIE_conferenceGoal (OOCTXT* pctxt, H225Setup_UUIE_conferenceGoal* pvalue); + +/**************************************************************/ +/* */ +/* Q954Details */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Q954Details { + ASN1BOOL conferenceCalling; + ASN1BOOL threePartyService; +} H225Q954Details; + +EXTERN int asn1PE_H225Q954Details (OOCTXT* pctxt, H225Q954Details* pvalue); + +EXTERN int asn1PD_H225Q954Details (OOCTXT* pctxt, H225Q954Details* pvalue); + +/**************************************************************/ +/* */ +/* QseriesOptions */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225QseriesOptions { + ASN1BOOL q932Full; + ASN1BOOL q951Full; + ASN1BOOL q952Full; + ASN1BOOL q953Full; + ASN1BOOL q955Full; + ASN1BOOL q956Full; + ASN1BOOL q957Full; + H225Q954Details q954Info; +} H225QseriesOptions; + +EXTERN int asn1PE_H225QseriesOptions (OOCTXT* pctxt, H225QseriesOptions* pvalue); + +EXTERN int asn1PD_H225QseriesOptions (OOCTXT* pctxt, H225QseriesOptions* pvalue); + +/**************************************************************/ +/* */ +/* CallType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225CallType_pointToPoint 1 +#define T_H225CallType_oneToN 2 +#define T_H225CallType_nToOne 3 +#define T_H225CallType_nToN 4 +#define T_H225CallType_extElem1 5 + +typedef struct EXTERN H225CallType { + int t; +} H225CallType; + +EXTERN int asn1PE_H225CallType (OOCTXT* pctxt, H225CallType* pvalue); + +EXTERN int asn1PD_H225CallType (OOCTXT* pctxt, H225CallType* pvalue); + +/**************************************************************/ +/* */ +/* CallIdentifier */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallIdentifier { + H225GloballyUniqueID guid; +} H225CallIdentifier; + +EXTERN int asn1PE_H225CallIdentifier (OOCTXT* pctxt, H225CallIdentifier* pvalue); + +EXTERN int asn1PD_H225CallIdentifier (OOCTXT* pctxt, H225CallIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* SecurityServiceMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225SecurityServiceMode_nonStandard 1 +#define T_H225SecurityServiceMode_none 2 +#define T_H225SecurityServiceMode_default_ 3 +#define T_H225SecurityServiceMode_extElem1 4 + +typedef struct EXTERN H225SecurityServiceMode { + int t; + union { + /* t = 1 */ + H225NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + } u; +} H225SecurityServiceMode; + +EXTERN int asn1PE_H225SecurityServiceMode (OOCTXT* pctxt, H225SecurityServiceMode* pvalue); + +EXTERN int asn1PD_H225SecurityServiceMode (OOCTXT* pctxt, H225SecurityServiceMode* pvalue); + +/**************************************************************/ +/* */ +/* SecurityCapabilities */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225SecurityCapabilities { + struct { + unsigned nonStandardPresent : 1; + } m; + H225NonStandardParameter nonStandard; + H225SecurityServiceMode encryption; + H225SecurityServiceMode authenticaton; + H225SecurityServiceMode integrity; +} H225SecurityCapabilities; + +EXTERN int asn1PE_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilities* pvalue); + +EXTERN int asn1PD_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilities* pvalue); + +/**************************************************************/ +/* */ +/* H245Security */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225H245Security_nonStandard 1 +#define T_H225H245Security_noSecurity 2 +#define T_H225H245Security_tls 3 +#define T_H225H245Security_ipsec 4 +#define T_H225H245Security_extElem1 5 + +typedef struct EXTERN H225H245Security { + int t; + union { + /* t = 1 */ + H225NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + H225SecurityCapabilities *tls; + /* t = 4 */ + H225SecurityCapabilities *ipsec; + /* t = 5 */ + } u; +} H225H245Security; + +EXTERN int asn1PE_H225H245Security (OOCTXT* pctxt, H225H245Security* pvalue); + +EXTERN int asn1PD_H225H245Security (OOCTXT* pctxt, H225H245Security* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225H245Security */ +/* */ +/**************************************************************/ + +/* List of H225H245Security */ +typedef DList H225_SeqOfH225H245Security; + +EXTERN int asn1PE_H225_SeqOfH225H245Security (OOCTXT* pctxt, H225_SeqOfH225H245Security* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225H245Security (OOCTXT* pctxt, H225_SeqOfH225H245Security* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225ClearToken */ +/* */ +/**************************************************************/ + +/* List of H235ClearToken */ +typedef DList H225_SeqOfH225ClearToken; + +EXTERN int asn1PE_H225_SeqOfH225ClearToken (OOCTXT* pctxt, H225_SeqOfH225ClearToken* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225ClearToken (OOCTXT* pctxt, H225_SeqOfH225ClearToken* pvalue); + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoEPPwdHash */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CryptoH323Token_cryptoEPPwdHash { + H225AliasAddress alias; + H235TimeStamp timeStamp; + H235HASHED token; +} H225CryptoH323Token_cryptoEPPwdHash; + +EXTERN int asn1PE_H225CryptoH323Token_cryptoEPPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPPwdHash* pvalue); + +EXTERN int asn1PD_H225CryptoH323Token_cryptoEPPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPPwdHash* pvalue); + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoGKPwdHash */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CryptoH323Token_cryptoGKPwdHash { + H225GatekeeperIdentifier gatekeeperId; + H235TimeStamp timeStamp; + H235HASHED token; +} H225CryptoH323Token_cryptoGKPwdHash; + +EXTERN int asn1PE_H225CryptoH323Token_cryptoGKPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKPwdHash* pvalue); + +EXTERN int asn1PD_H225CryptoH323Token_cryptoGKPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKPwdHash* pvalue); + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoEPCert */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CryptoH323Token_cryptoEPCert { + H235EncodedPwdCertToken toBeSigned; + ASN1OBJID algorithmOID; + H235Params paramS; + ASN1DynBitStr signature; +} H225CryptoH323Token_cryptoEPCert; + +EXTERN int asn1PE_H225CryptoH323Token_cryptoEPCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPCert* pvalue); + +EXTERN int asn1PD_H225CryptoH323Token_cryptoEPCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPCert* pvalue); + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoGKCert */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CryptoH323Token_cryptoGKCert { + H235EncodedPwdCertToken toBeSigned; + ASN1OBJID algorithmOID; + H235Params paramS; + ASN1DynBitStr signature; +} H225CryptoH323Token_cryptoGKCert; + +EXTERN int asn1PE_H225CryptoH323Token_cryptoGKCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKCert* pvalue); + +EXTERN int asn1PD_H225CryptoH323Token_cryptoGKCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKCert* pvalue); + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoFastStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CryptoH323Token_cryptoFastStart { + H225EncodedFastStartToken toBeSigned; + ASN1OBJID algorithmOID; + H235Params paramS; + ASN1DynBitStr signature; +} H225CryptoH323Token_cryptoFastStart; + +EXTERN int asn1PE_H225CryptoH323Token_cryptoFastStart (OOCTXT* pctxt, H225CryptoH323Token_cryptoFastStart* pvalue); + +EXTERN int asn1PD_H225CryptoH323Token_cryptoFastStart (OOCTXT* pctxt, H225CryptoH323Token_cryptoFastStart* pvalue); + +/**************************************************************/ +/* */ +/* CryptoH323Token */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225CryptoH323Token_cryptoEPPwdHash 1 +#define T_H225CryptoH323Token_cryptoGKPwdHash 2 +#define T_H225CryptoH323Token_cryptoEPPwdEncr 3 +#define T_H225CryptoH323Token_cryptoGKPwdEncr 4 +#define T_H225CryptoH323Token_cryptoEPCert 5 +#define T_H225CryptoH323Token_cryptoGKCert 6 +#define T_H225CryptoH323Token_cryptoFastStart 7 +#define T_H225CryptoH323Token_nestedcryptoToken 8 +#define T_H225CryptoH323Token_extElem1 9 + +typedef struct EXTERN H225CryptoH323Token { + int t; + union { + /* t = 1 */ + H225CryptoH323Token_cryptoEPPwdHash *cryptoEPPwdHash; + /* t = 2 */ + H225CryptoH323Token_cryptoGKPwdHash *cryptoGKPwdHash; + /* t = 3 */ + H235ENCRYPTED *cryptoEPPwdEncr; + /* t = 4 */ + H235ENCRYPTED *cryptoGKPwdEncr; + /* t = 5 */ + H225CryptoH323Token_cryptoEPCert *cryptoEPCert; + /* t = 6 */ + H225CryptoH323Token_cryptoGKCert *cryptoGKCert; + /* t = 7 */ + H225CryptoH323Token_cryptoFastStart *cryptoFastStart; + /* t = 8 */ + H235CryptoToken *nestedcryptoToken; + /* t = 9 */ + } u; +} H225CryptoH323Token; + +EXTERN int asn1PE_H225CryptoH323Token (OOCTXT* pctxt, H225CryptoH323Token* pvalue); + +EXTERN int asn1PD_H225CryptoH323Token (OOCTXT* pctxt, H225CryptoH323Token* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225CryptoH323Token */ +/* */ +/**************************************************************/ + +/* List of H225CryptoH323Token */ +typedef DList H225_SeqOfH225CryptoH323Token; + +EXTERN int asn1PE_H225_SeqOfH225CryptoH323Token (OOCTXT* pctxt, H225_SeqOfH225CryptoH323Token* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225CryptoH323Token (OOCTXT* pctxt, H225_SeqOfH225CryptoH323Token* pvalue); + +/**************************************************************/ +/* */ +/* Setup_UUIE_fastStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Setup_UUIE_fastStart { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225Setup_UUIE_fastStart; + +EXTERN int asn1PE_H225Setup_UUIE_fastStart (OOCTXT* pctxt, H225Setup_UUIE_fastStart* pvalue); + +EXTERN int asn1PD_H225Setup_UUIE_fastStart (OOCTXT* pctxt, H225Setup_UUIE_fastStart* pvalue); + +/**************************************************************/ +/* */ +/* ScnConnectionType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225ScnConnectionType_unknown 1 +#define T_H225ScnConnectionType_bChannel 2 +#define T_H225ScnConnectionType_hybrid2x64 3 +#define T_H225ScnConnectionType_hybrid384 4 +#define T_H225ScnConnectionType_hybrid1536 5 +#define T_H225ScnConnectionType_hybrid1920 6 +#define T_H225ScnConnectionType_multirate 7 +#define T_H225ScnConnectionType_extElem1 8 + +typedef struct EXTERN H225ScnConnectionType { + int t; +} H225ScnConnectionType; + +EXTERN int asn1PE_H225ScnConnectionType (OOCTXT* pctxt, H225ScnConnectionType* pvalue); + +EXTERN int asn1PD_H225ScnConnectionType (OOCTXT* pctxt, H225ScnConnectionType* pvalue); + +/**************************************************************/ +/* */ +/* ScnConnectionAggregation */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225ScnConnectionAggregation_auto_ 1 +#define T_H225ScnConnectionAggregation_none 2 +#define T_H225ScnConnectionAggregation_h221 3 +#define T_H225ScnConnectionAggregation_bonded_mode1 4 +#define T_H225ScnConnectionAggregation_bonded_mode2 5 +#define T_H225ScnConnectionAggregation_bonded_mode3 6 +#define T_H225ScnConnectionAggregation_extElem1 7 + +typedef struct EXTERN H225ScnConnectionAggregation { + int t; +} H225ScnConnectionAggregation; + +EXTERN int asn1PE_H225ScnConnectionAggregation (OOCTXT* pctxt, H225ScnConnectionAggregation* pvalue); + +EXTERN int asn1PD_H225ScnConnectionAggregation (OOCTXT* pctxt, H225ScnConnectionAggregation* pvalue); + +/**************************************************************/ +/* */ +/* Setup_UUIE_connectionParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Setup_UUIE_connectionParameters { + H225ScnConnectionType connectionType; + ASN1USINT numberOfScnConnections; + H225ScnConnectionAggregation connectionAggregation; +} H225Setup_UUIE_connectionParameters; + +EXTERN int asn1PE_H225Setup_UUIE_connectionParameters (OOCTXT* pctxt, H225Setup_UUIE_connectionParameters* pvalue); + +EXTERN int asn1PD_H225Setup_UUIE_connectionParameters (OOCTXT* pctxt, H225Setup_UUIE_connectionParameters* pvalue); + +/**************************************************************/ +/* */ +/* Setup_UUIE_language */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Setup_UUIE_language { + ASN1UINT n; + ASN1IA5String *elem; +} H225Setup_UUIE_language; + +EXTERN int asn1PE_H225Setup_UUIE_language (OOCTXT* pctxt, H225Setup_UUIE_language* pvalue); + +EXTERN int asn1PD_H225Setup_UUIE_language (OOCTXT* pctxt, H225Setup_UUIE_language* pvalue); + +/**************************************************************/ +/* */ +/* PresentationIndicator */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225PresentationIndicator_presentationAllowed 1 +#define T_H225PresentationIndicator_presentationRestricted 2 +#define T_H225PresentationIndicator_addressNotAvailable 3 +#define T_H225PresentationIndicator_extElem1 4 + +typedef struct EXTERN H225PresentationIndicator { + int t; +} H225PresentationIndicator; + +EXTERN int asn1PE_H225PresentationIndicator (OOCTXT* pctxt, H225PresentationIndicator* pvalue); + +EXTERN int asn1PD_H225PresentationIndicator (OOCTXT* pctxt, H225PresentationIndicator* pvalue); + +/**************************************************************/ +/* */ +/* CallCreditServiceControl_billingMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225CallCreditServiceControl_billingMode_credit 1 +#define T_H225CallCreditServiceControl_billingMode_debit 2 +#define T_H225CallCreditServiceControl_billingMode_extElem1 3 + +typedef struct EXTERN H225CallCreditServiceControl_billingMode { + int t; +} H225CallCreditServiceControl_billingMode; + +EXTERN int asn1PE_H225CallCreditServiceControl_billingMode (OOCTXT* pctxt, H225CallCreditServiceControl_billingMode* pvalue); + +EXTERN int asn1PD_H225CallCreditServiceControl_billingMode (OOCTXT* pctxt, H225CallCreditServiceControl_billingMode* pvalue); + +/**************************************************************/ +/* */ +/* CallCreditServiceControl_callStartingPoint */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225CallCreditServiceControl_callStartingPoint_alerting 1 +#define T_H225CallCreditServiceControl_callStartingPoint_connect 2 +#define T_H225CallCreditServiceControl_callStartingPoint_extElem1 3 + +typedef struct EXTERN H225CallCreditServiceControl_callStartingPoint { + int t; +} H225CallCreditServiceControl_callStartingPoint; + +EXTERN int asn1PE_H225CallCreditServiceControl_callStartingPoint (OOCTXT* pctxt, H225CallCreditServiceControl_callStartingPoint* pvalue); + +EXTERN int asn1PD_H225CallCreditServiceControl_callStartingPoint (OOCTXT* pctxt, H225CallCreditServiceControl_callStartingPoint* pvalue); + +/**************************************************************/ +/* */ +/* CallCreditServiceControl */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallCreditServiceControl { + struct { + unsigned amountStringPresent : 1; + unsigned billingModePresent : 1; + unsigned callDurationLimitPresent : 1; + unsigned enforceCallDurationLimitPresent : 1; + unsigned callStartingPointPresent : 1; + } m; + ASN1BMPString amountString; + H225CallCreditServiceControl_billingMode billingMode; + ASN1UINT callDurationLimit; + ASN1BOOL enforceCallDurationLimit; + H225CallCreditServiceControl_callStartingPoint callStartingPoint; +} H225CallCreditServiceControl; + +EXTERN int asn1PE_H225CallCreditServiceControl (OOCTXT* pctxt, H225CallCreditServiceControl* pvalue); + +EXTERN int asn1PD_H225CallCreditServiceControl (OOCTXT* pctxt, H225CallCreditServiceControl* pvalue); + +/**************************************************************/ +/* */ +/* ServiceControlDescriptor */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225ServiceControlDescriptor_url 1 +#define T_H225ServiceControlDescriptor_signal 2 +#define T_H225ServiceControlDescriptor_nonStandard 3 +#define T_H225ServiceControlDescriptor_callCreditServiceControl 4 +#define T_H225ServiceControlDescriptor_extElem1 5 + +typedef struct EXTERN H225ServiceControlDescriptor { + int t; + union { + /* t = 1 */ + ASN1IA5String url; + /* t = 2 */ + H225H248SignalsDescriptor *signal; + /* t = 3 */ + H225NonStandardParameter *nonStandard; + /* t = 4 */ + H225CallCreditServiceControl *callCreditServiceControl; + /* t = 5 */ + } u; +} H225ServiceControlDescriptor; + +EXTERN int asn1PE_H225ServiceControlDescriptor (OOCTXT* pctxt, H225ServiceControlDescriptor* pvalue); + +EXTERN int asn1PD_H225ServiceControlDescriptor (OOCTXT* pctxt, H225ServiceControlDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* ServiceControlSession_reason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225ServiceControlSession_reason_open 1 +#define T_H225ServiceControlSession_reason_refresh 2 +#define T_H225ServiceControlSession_reason_close 3 +#define T_H225ServiceControlSession_reason_extElem1 4 + +typedef struct EXTERN H225ServiceControlSession_reason { + int t; +} H225ServiceControlSession_reason; + +EXTERN int asn1PE_H225ServiceControlSession_reason (OOCTXT* pctxt, H225ServiceControlSession_reason* pvalue); + +EXTERN int asn1PD_H225ServiceControlSession_reason (OOCTXT* pctxt, H225ServiceControlSession_reason* pvalue); + +/**************************************************************/ +/* */ +/* ServiceControlSession */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ServiceControlSession { + struct { + unsigned contentsPresent : 1; + } m; + ASN1UINT8 sessionId; + H225ServiceControlDescriptor contents; + H225ServiceControlSession_reason reason; +} H225ServiceControlSession; + +EXTERN int asn1PE_H225ServiceControlSession (OOCTXT* pctxt, H225ServiceControlSession* pvalue); + +EXTERN int asn1PD_H225ServiceControlSession (OOCTXT* pctxt, H225ServiceControlSession* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225ServiceControlSession */ +/* */ +/**************************************************************/ + +/* List of H225ServiceControlSession */ +typedef DList H225_SeqOfH225ServiceControlSession; + +EXTERN int asn1PE_H225_SeqOfH225ServiceControlSession (OOCTXT* pctxt, H225_SeqOfH225ServiceControlSession* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225ServiceControlSession (OOCTXT* pctxt, H225_SeqOfH225ServiceControlSession* pvalue); + +/**************************************************************/ +/* */ +/* CarrierInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CarrierInfo { + struct { + unsigned carrierIdentificationCodePresent : 1; + unsigned carrierNamePresent : 1; + } m; + H225CarrierInfo_carrierIdentificationCode carrierIdentificationCode; + ASN1IA5String carrierName; +} H225CarrierInfo; + +EXTERN int asn1PE_H225CarrierInfo (OOCTXT* pctxt, H225CarrierInfo* pvalue); + +EXTERN int asn1PD_H225CarrierInfo (OOCTXT* pctxt, H225CarrierInfo* pvalue); + +/**************************************************************/ +/* */ +/* CallsAvailable */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallsAvailable { + struct { + unsigned groupPresent : 1; + unsigned carrierPresent : 1; + } m; + ASN1UINT calls; + ASN1IA5String group; + H225CarrierInfo carrier; +} H225CallsAvailable; + +EXTERN int asn1PE_H225CallsAvailable (OOCTXT* pctxt, H225CallsAvailable* pvalue); + +EXTERN int asn1PD_H225CallsAvailable (OOCTXT* pctxt, H225CallsAvailable* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225CallsAvailable */ +/* */ +/**************************************************************/ + +/* List of H225CallsAvailable */ +typedef DList H225_SeqOfH225CallsAvailable; + +EXTERN int asn1PE_H225_SeqOfH225CallsAvailable (OOCTXT* pctxt, H225_SeqOfH225CallsAvailable* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225CallsAvailable (OOCTXT* pctxt, H225_SeqOfH225CallsAvailable* pvalue); + +/**************************************************************/ +/* */ +/* CallCapacityInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallCapacityInfo { + struct { + unsigned voiceGwCallsAvailablePresent : 1; + unsigned h310GwCallsAvailablePresent : 1; + unsigned h320GwCallsAvailablePresent : 1; + unsigned h321GwCallsAvailablePresent : 1; + unsigned h322GwCallsAvailablePresent : 1; + unsigned h323GwCallsAvailablePresent : 1; + unsigned h324GwCallsAvailablePresent : 1; + unsigned t120OnlyGwCallsAvailablePresent : 1; + unsigned t38FaxAnnexbOnlyGwCallsAvailablePresent : 1; + unsigned terminalCallsAvailablePresent : 1; + unsigned mcuCallsAvailablePresent : 1; + unsigned sipGwCallsAvailablePresent : 1; + } m; + H225_SeqOfH225CallsAvailable voiceGwCallsAvailable; + H225_SeqOfH225CallsAvailable h310GwCallsAvailable; + H225_SeqOfH225CallsAvailable h320GwCallsAvailable; + H225_SeqOfH225CallsAvailable h321GwCallsAvailable; + H225_SeqOfH225CallsAvailable h322GwCallsAvailable; + H225_SeqOfH225CallsAvailable h323GwCallsAvailable; + H225_SeqOfH225CallsAvailable h324GwCallsAvailable; + H225_SeqOfH225CallsAvailable t120OnlyGwCallsAvailable; + H225_SeqOfH225CallsAvailable t38FaxAnnexbOnlyGwCallsAvailable; + H225_SeqOfH225CallsAvailable terminalCallsAvailable; + H225_SeqOfH225CallsAvailable mcuCallsAvailable; + H225_SeqOfH225CallsAvailable sipGwCallsAvailable; +} H225CallCapacityInfo; + +EXTERN int asn1PE_H225CallCapacityInfo (OOCTXT* pctxt, H225CallCapacityInfo* pvalue); + +EXTERN int asn1PD_H225CallCapacityInfo (OOCTXT* pctxt, H225CallCapacityInfo* pvalue); + +/**************************************************************/ +/* */ +/* CallCapacity */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallCapacity { + struct { + unsigned maximumCallCapacityPresent : 1; + unsigned currentCallCapacityPresent : 1; + } m; + H225CallCapacityInfo maximumCallCapacity; + H225CallCapacityInfo currentCallCapacity; +} H225CallCapacity; + +EXTERN int asn1PE_H225CallCapacity (OOCTXT* pctxt, H225CallCapacity* pvalue); + +EXTERN int asn1PD_H225CallCapacity (OOCTXT* pctxt, H225CallCapacity* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225CicInfo_cic_element */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225_SeqOfH225CicInfo_cic_element { + ASN1UINT n; + H225CicInfo_cic_element *elem; +} H225_SeqOfH225CicInfo_cic_element; + +EXTERN int asn1PE_H225_SeqOfH225CicInfo_cic_element (OOCTXT* pctxt, H225_SeqOfH225CicInfo_cic_element* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225CicInfo_cic_element (OOCTXT* pctxt, H225_SeqOfH225CicInfo_cic_element* pvalue); + +/**************************************************************/ +/* */ +/* CicInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CicInfo { + H225_SeqOfH225CicInfo_cic_element cic; + H225CicInfo_pointCode pointCode; +} H225CicInfo; + +EXTERN int asn1PE_H225CicInfo (OOCTXT* pctxt, H225CicInfo* pvalue); + +EXTERN int asn1PD_H225CicInfo (OOCTXT* pctxt, H225CicInfo* pvalue); + +/**************************************************************/ +/* */ +/* GroupID_member */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GroupID_member { + ASN1UINT n; + ASN1USINT *elem; +} H225GroupID_member; + +EXTERN int asn1PE_H225GroupID_member (OOCTXT* pctxt, H225GroupID_member* pvalue); + +EXTERN int asn1PD_H225GroupID_member (OOCTXT* pctxt, H225GroupID_member* pvalue); + +/**************************************************************/ +/* */ +/* GroupID */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GroupID { + struct { + unsigned memberPresent : 1; + } m; + H225GroupID_member member; + ASN1IA5String group; +} H225GroupID; + +EXTERN int asn1PE_H225GroupID (OOCTXT* pctxt, H225GroupID* pvalue); + +EXTERN int asn1PD_H225GroupID (OOCTXT* pctxt, H225GroupID* pvalue); + +/**************************************************************/ +/* */ +/* CircuitIdentifier */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CircuitIdentifier { + struct { + unsigned cicPresent : 1; + unsigned groupPresent : 1; + unsigned carrierPresent : 1; + } m; + H225CicInfo cic; + H225GroupID group; + H225CarrierInfo carrier; +} H225CircuitIdentifier; + +EXTERN int asn1PE_H225CircuitIdentifier (OOCTXT* pctxt, H225CircuitIdentifier* pvalue); + +EXTERN int asn1PD_H225CircuitIdentifier (OOCTXT* pctxt, H225CircuitIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225GenericData */ +/* */ +/**************************************************************/ + +/* List of H225GenericData */ +typedef DList H225_SeqOfH225GenericData; + +EXTERN int asn1PE_H225_SeqOfH225GenericData (OOCTXT* pctxt, H225_SeqOfH225GenericData* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225GenericData (OOCTXT* pctxt, H225_SeqOfH225GenericData* pvalue); + +/**************************************************************/ +/* */ +/* CircuitInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CircuitInfo { + struct { + unsigned sourceCircuitIDPresent : 1; + unsigned destinationCircuitIDPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225CircuitIdentifier sourceCircuitID; + H225CircuitIdentifier destinationCircuitID; + H225_SeqOfH225GenericData genericData; +} H225CircuitInfo; + +EXTERN int asn1PE_H225CircuitInfo (OOCTXT* pctxt, H225CircuitInfo* pvalue); + +EXTERN int asn1PD_H225CircuitInfo (OOCTXT* pctxt, H225CircuitInfo* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225FeatureDescriptor */ +/* */ +/**************************************************************/ + +/* List of H225FeatureDescriptor */ +typedef DList H225_SeqOfH225FeatureDescriptor; + +EXTERN int asn1PE_H225_SeqOfH225FeatureDescriptor (OOCTXT* pctxt, H225_SeqOfH225FeatureDescriptor* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225FeatureDescriptor (OOCTXT* pctxt, H225_SeqOfH225FeatureDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* Setup_UUIE_parallelH245Control */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Setup_UUIE_parallelH245Control { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225Setup_UUIE_parallelH245Control; + +EXTERN int asn1PE_H225Setup_UUIE_parallelH245Control (OOCTXT* pctxt, H225Setup_UUIE_parallelH245Control* pvalue); + +EXTERN int asn1PD_H225Setup_UUIE_parallelH245Control (OOCTXT* pctxt, H225Setup_UUIE_parallelH245Control* pvalue); + +/**************************************************************/ +/* */ +/* ExtendedAliasAddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ExtendedAliasAddress { + struct { + unsigned presentationIndicatorPresent : 1; + unsigned screeningIndicatorPresent : 1; + } m; + H225AliasAddress address; + H225PresentationIndicator presentationIndicator; + H225ScreeningIndicator screeningIndicator; +} H225ExtendedAliasAddress; + +EXTERN int asn1PE_H225ExtendedAliasAddress (OOCTXT* pctxt, H225ExtendedAliasAddress* pvalue); + +EXTERN int asn1PD_H225ExtendedAliasAddress (OOCTXT* pctxt, H225ExtendedAliasAddress* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225ExtendedAliasAddress */ +/* */ +/**************************************************************/ + +/* List of H225ExtendedAliasAddress */ +typedef DList H225_SeqOfH225ExtendedAliasAddress; + +EXTERN int asn1PE_H225_SeqOfH225ExtendedAliasAddress (OOCTXT* pctxt, H225_SeqOfH225ExtendedAliasAddress* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225ExtendedAliasAddress (OOCTXT* pctxt, H225_SeqOfH225ExtendedAliasAddress* pvalue); + +/**************************************************************/ +/* */ +/* Setup_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Setup_UUIE { + struct { + unsigned h245AddressPresent : 1; + unsigned sourceAddressPresent : 1; + unsigned destinationAddressPresent : 1; + unsigned destCallSignalAddressPresent : 1; + unsigned destExtraCallInfoPresent : 1; + unsigned destExtraCRVPresent : 1; + unsigned callServicesPresent : 1; + unsigned sourceCallSignalAddressPresent : 1; + unsigned remoteExtensionAddressPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned h245SecurityCapabilityPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned fastStartPresent : 1; + unsigned mediaWaitForConnectPresent : 1; + unsigned canOverlapSendPresent : 1; + unsigned endpointIdentifierPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned maintainConnectionPresent : 1; + unsigned connectionParametersPresent : 1; + unsigned languagePresent : 1; + unsigned presentationIndicatorPresent : 1; + unsigned screeningIndicatorPresent : 1; + unsigned serviceControlPresent : 1; + unsigned symmetricOperationRequiredPresent : 1; + unsigned capacityPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned desiredProtocolsPresent : 1; + unsigned neededFeaturesPresent : 1; + unsigned desiredFeaturesPresent : 1; + unsigned supportedFeaturesPresent : 1; + unsigned parallelH245ControlPresent : 1; + unsigned additionalSourceAddressesPresent : 1; + unsigned hopCountPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225TransportAddress h245Address; + H225_SeqOfH225AliasAddress sourceAddress; + H225EndpointType sourceInfo; + H225_SeqOfH225AliasAddress destinationAddress; + H225TransportAddress destCallSignalAddress; + H225_SeqOfH225AliasAddress destExtraCallInfo; + H225_SeqOfH225CallReferenceValue destExtraCRV; + ASN1BOOL activeMC; + H225ConferenceIdentifier conferenceID; + H225Setup_UUIE_conferenceGoal conferenceGoal; + H225QseriesOptions callServices; + H225CallType callType; + H225TransportAddress sourceCallSignalAddress; + H225AliasAddress remoteExtensionAddress; + H225CallIdentifier callIdentifier; + H225_SeqOfH225H245Security h245SecurityCapability; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225Setup_UUIE_fastStart fastStart; + ASN1BOOL mediaWaitForConnect; + ASN1BOOL canOverlapSend; + H225EndpointIdentifier endpointIdentifier; + ASN1BOOL multipleCalls; + ASN1BOOL maintainConnection; + H225Setup_UUIE_connectionParameters connectionParameters; + H225Setup_UUIE_language language; + H225PresentationIndicator presentationIndicator; + H225ScreeningIndicator screeningIndicator; + H225_SeqOfH225ServiceControlSession serviceControl; + H225CallCapacity capacity; + H225CircuitInfo circuitInfo; + H225_SeqOfH225SupportedProtocols desiredProtocols; + H225_SeqOfH225FeatureDescriptor neededFeatures; + H225_SeqOfH225FeatureDescriptor desiredFeatures; + H225_SeqOfH225FeatureDescriptor supportedFeatures; + H225Setup_UUIE_parallelH245Control parallelH245Control; + H225_SeqOfH225ExtendedAliasAddress additionalSourceAddresses; + ASN1UINT8 hopCount; +} H225Setup_UUIE; + +EXTERN int asn1PE_H225Setup_UUIE (OOCTXT* pctxt, H225Setup_UUIE* pvalue); + +EXTERN int asn1PD_H225Setup_UUIE (OOCTXT* pctxt, H225Setup_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* CallProceeding_UUIE_fastStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallProceeding_UUIE_fastStart { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225CallProceeding_UUIE_fastStart; + +EXTERN int asn1PE_H225CallProceeding_UUIE_fastStart (OOCTXT* pctxt, H225CallProceeding_UUIE_fastStart* pvalue); + +EXTERN int asn1PD_H225CallProceeding_UUIE_fastStart (OOCTXT* pctxt, H225CallProceeding_UUIE_fastStart* pvalue); + +/**************************************************************/ +/* */ +/* FeatureSet */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225FeatureSet { + struct { + unsigned neededFeaturesPresent : 1; + unsigned desiredFeaturesPresent : 1; + unsigned supportedFeaturesPresent : 1; + } m; + ASN1BOOL replacementFeatureSet; + H225_SeqOfH225FeatureDescriptor neededFeatures; + H225_SeqOfH225FeatureDescriptor desiredFeatures; + H225_SeqOfH225FeatureDescriptor supportedFeatures; +} H225FeatureSet; + +EXTERN int asn1PE_H225FeatureSet (OOCTXT* pctxt, H225FeatureSet* pvalue); + +EXTERN int asn1PD_H225FeatureSet (OOCTXT* pctxt, H225FeatureSet* pvalue); + +/**************************************************************/ +/* */ +/* CallProceeding_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallProceeding_UUIE { + struct { + unsigned h245AddressPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned h245SecurityModePresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned fastStartPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned maintainConnectionPresent : 1; + unsigned fastConnectRefusedPresent : 1; + unsigned featureSetPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225EndpointType destinationInfo; + H225TransportAddress h245Address; + H225CallIdentifier callIdentifier; + H225H245Security h245SecurityMode; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225CallProceeding_UUIE_fastStart fastStart; + ASN1BOOL multipleCalls; + ASN1BOOL maintainConnection; + H225FeatureSet featureSet; +} H225CallProceeding_UUIE; + +EXTERN int asn1PE_H225CallProceeding_UUIE (OOCTXT* pctxt, H225CallProceeding_UUIE* pvalue); + +EXTERN int asn1PD_H225CallProceeding_UUIE (OOCTXT* pctxt, H225CallProceeding_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* Connect_UUIE_fastStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Connect_UUIE_fastStart { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225Connect_UUIE_fastStart; + +EXTERN int asn1PE_H225Connect_UUIE_fastStart (OOCTXT* pctxt, H225Connect_UUIE_fastStart* pvalue); + +EXTERN int asn1PD_H225Connect_UUIE_fastStart (OOCTXT* pctxt, H225Connect_UUIE_fastStart* pvalue); + +/**************************************************************/ +/* */ +/* Connect_UUIE_language */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Connect_UUIE_language { + ASN1UINT n; + ASN1IA5String *elem; +} H225Connect_UUIE_language; + +EXTERN int asn1PE_H225Connect_UUIE_language (OOCTXT* pctxt, H225Connect_UUIE_language* pvalue); + +EXTERN int asn1PD_H225Connect_UUIE_language (OOCTXT* pctxt, H225Connect_UUIE_language* pvalue); + +/**************************************************************/ +/* */ +/* Connect_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Connect_UUIE { + struct { + unsigned h245AddressPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned h245SecurityModePresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned fastStartPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned maintainConnectionPresent : 1; + unsigned languagePresent : 1; + unsigned connectedAddressPresent : 1; + unsigned presentationIndicatorPresent : 1; + unsigned screeningIndicatorPresent : 1; + unsigned fastConnectRefusedPresent : 1; + unsigned serviceControlPresent : 1; + unsigned capacityPresent : 1; + unsigned featureSetPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225TransportAddress h245Address; + H225EndpointType destinationInfo; + H225ConferenceIdentifier conferenceID; + H225CallIdentifier callIdentifier; + H225H245Security h245SecurityMode; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225Connect_UUIE_fastStart fastStart; + ASN1BOOL multipleCalls; + ASN1BOOL maintainConnection; + H225Connect_UUIE_language language; + H225_SeqOfH225AliasAddress connectedAddress; + H225PresentationIndicator presentationIndicator; + H225ScreeningIndicator screeningIndicator; + H225_SeqOfH225ServiceControlSession serviceControl; + H225CallCapacity capacity; + H225FeatureSet featureSet; +} H225Connect_UUIE; + +EXTERN int asn1PE_H225Connect_UUIE (OOCTXT* pctxt, H225Connect_UUIE* pvalue); + +EXTERN int asn1PD_H225Connect_UUIE (OOCTXT* pctxt, H225Connect_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* Alerting_UUIE_fastStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Alerting_UUIE_fastStart { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225Alerting_UUIE_fastStart; + +EXTERN int asn1PE_H225Alerting_UUIE_fastStart (OOCTXT* pctxt, H225Alerting_UUIE_fastStart* pvalue); + +EXTERN int asn1PD_H225Alerting_UUIE_fastStart (OOCTXT* pctxt, H225Alerting_UUIE_fastStart* pvalue); + +/**************************************************************/ +/* */ +/* Alerting_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Alerting_UUIE { + struct { + unsigned h245AddressPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned h245SecurityModePresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned fastStartPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned maintainConnectionPresent : 1; + unsigned alertingAddressPresent : 1; + unsigned presentationIndicatorPresent : 1; + unsigned screeningIndicatorPresent : 1; + unsigned fastConnectRefusedPresent : 1; + unsigned serviceControlPresent : 1; + unsigned capacityPresent : 1; + unsigned featureSetPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225EndpointType destinationInfo; + H225TransportAddress h245Address; + H225CallIdentifier callIdentifier; + H225H245Security h245SecurityMode; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225Alerting_UUIE_fastStart fastStart; + ASN1BOOL multipleCalls; + ASN1BOOL maintainConnection; + H225_SeqOfH225AliasAddress alertingAddress; + H225PresentationIndicator presentationIndicator; + H225ScreeningIndicator screeningIndicator; + H225_SeqOfH225ServiceControlSession serviceControl; + H225CallCapacity capacity; + H225FeatureSet featureSet; +} H225Alerting_UUIE; + +EXTERN int asn1PE_H225Alerting_UUIE (OOCTXT* pctxt, H225Alerting_UUIE* pvalue); + +EXTERN int asn1PD_H225Alerting_UUIE (OOCTXT* pctxt, H225Alerting_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* Information_UUIE_fastStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Information_UUIE_fastStart { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225Information_UUIE_fastStart; + +EXTERN int asn1PE_H225Information_UUIE_fastStart (OOCTXT* pctxt, H225Information_UUIE_fastStart* pvalue); + +EXTERN int asn1PD_H225Information_UUIE_fastStart (OOCTXT* pctxt, H225Information_UUIE_fastStart* pvalue); + +/**************************************************************/ +/* */ +/* Information_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Information_UUIE { + struct { + unsigned callIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned fastStartPresent : 1; + unsigned fastConnectRefusedPresent : 1; + unsigned circuitInfoPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225CallIdentifier callIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225Information_UUIE_fastStart fastStart; + H225CircuitInfo circuitInfo; +} H225Information_UUIE; + +EXTERN int asn1PE_H225Information_UUIE (OOCTXT* pctxt, H225Information_UUIE* pvalue); + +EXTERN int asn1PD_H225Information_UUIE (OOCTXT* pctxt, H225Information_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* SecurityErrors */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225SecurityErrors_securityWrongSyncTime 1 +#define T_H225SecurityErrors_securityReplay 2 +#define T_H225SecurityErrors_securityWrongGeneralID 3 +#define T_H225SecurityErrors_securityWrongSendersID 4 +#define T_H225SecurityErrors_securityIntegrityFailed 5 +#define T_H225SecurityErrors_securityWrongOID 6 +#define T_H225SecurityErrors_securityDHmismatch 7 +#define T_H225SecurityErrors_securityCertificateExpired 8 +#define T_H225SecurityErrors_securityCertificateDateInvalid 9 +#define T_H225SecurityErrors_securityCertificateRevoked 10 +#define T_H225SecurityErrors_securityCertificateNotReadable 11 +#define T_H225SecurityErrors_securityCertificateSignatureInvalid 12 +#define T_H225SecurityErrors_securityCertificateMissing 13 +#define T_H225SecurityErrors_securityCertificateIncomplete 14 +#define T_H225SecurityErrors_securityUnsupportedCertificateAlgOID 15 +#define T_H225SecurityErrors_securityUnknownCA 16 +#define T_H225SecurityErrors_extElem1 17 + +typedef struct EXTERN H225SecurityErrors { + int t; +} H225SecurityErrors; + +EXTERN int asn1PE_H225SecurityErrors (OOCTXT* pctxt, H225SecurityErrors* pvalue); + +EXTERN int asn1PD_H225SecurityErrors (OOCTXT* pctxt, H225SecurityErrors* pvalue); + +/**************************************************************/ +/* */ +/* ReleaseCompleteReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225ReleaseCompleteReason_noBandwidth 1 +#define T_H225ReleaseCompleteReason_gatekeeperResources 2 +#define T_H225ReleaseCompleteReason_unreachableDestination 3 +#define T_H225ReleaseCompleteReason_destinationRejection 4 +#define T_H225ReleaseCompleteReason_invalidRevision 5 +#define T_H225ReleaseCompleteReason_noPermission 6 +#define T_H225ReleaseCompleteReason_unreachableGatekeeper 7 +#define T_H225ReleaseCompleteReason_gatewayResources 8 +#define T_H225ReleaseCompleteReason_badFormatAddress 9 +#define T_H225ReleaseCompleteReason_adaptiveBusy 10 +#define T_H225ReleaseCompleteReason_inConf 11 +#define T_H225ReleaseCompleteReason_undefinedReason 12 +#define T_H225ReleaseCompleteReason_facilityCallDeflection 13 +#define T_H225ReleaseCompleteReason_securityDenied 14 +#define T_H225ReleaseCompleteReason_calledPartyNotRegistered 15 +#define T_H225ReleaseCompleteReason_callerNotRegistered 16 +#define T_H225ReleaseCompleteReason_newConnectionNeeded 17 +#define T_H225ReleaseCompleteReason_nonStandardReason 18 +#define T_H225ReleaseCompleteReason_replaceWithConferenceInvite 19 +#define T_H225ReleaseCompleteReason_genericDataReason 20 +#define T_H225ReleaseCompleteReason_neededFeatureNotSupported 21 +#define T_H225ReleaseCompleteReason_tunnelledSignallingRejected 22 +#define T_H225ReleaseCompleteReason_invalidCID 23 +#define T_H225ReleaseCompleteReason_securityError 24 +#define T_H225ReleaseCompleteReason_hopCountExceeded 25 +#define T_H225ReleaseCompleteReason_extElem1 26 + +typedef struct EXTERN H225ReleaseCompleteReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + /* t = 9 */ + /* t = 10 */ + /* t = 11 */ + /* t = 12 */ + /* t = 13 */ + /* t = 14 */ + /* t = 15 */ + /* t = 16 */ + /* t = 17 */ + /* t = 18 */ + H225NonStandardParameter *nonStandardReason; + /* t = 19 */ + H225ConferenceIdentifier *replaceWithConferenceInvite; + /* t = 20 */ + /* t = 21 */ + /* t = 22 */ + /* t = 23 */ + /* t = 24 */ + H225SecurityErrors *securityError; + /* t = 25 */ + /* t = 26 */ + } u; +} H225ReleaseCompleteReason; + +EXTERN int asn1PE_H225ReleaseCompleteReason (OOCTXT* pctxt, H225ReleaseCompleteReason* pvalue); + +EXTERN int asn1PD_H225ReleaseCompleteReason (OOCTXT* pctxt, H225ReleaseCompleteReason* pvalue); + +/**************************************************************/ +/* */ +/* ReleaseComplete_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ReleaseComplete_UUIE { + struct { + unsigned reasonPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned busyAddressPresent : 1; + unsigned presentationIndicatorPresent : 1; + unsigned screeningIndicatorPresent : 1; + unsigned capacityPresent : 1; + unsigned serviceControlPresent : 1; + unsigned featureSetPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225ReleaseCompleteReason reason; + H225CallIdentifier callIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225_SeqOfH225AliasAddress busyAddress; + H225PresentationIndicator presentationIndicator; + H225ScreeningIndicator screeningIndicator; + H225CallCapacity capacity; + H225_SeqOfH225ServiceControlSession serviceControl; + H225FeatureSet featureSet; +} H225ReleaseComplete_UUIE; + +EXTERN int asn1PE_H225ReleaseComplete_UUIE (OOCTXT* pctxt, H225ReleaseComplete_UUIE* pvalue); + +EXTERN int asn1PD_H225ReleaseComplete_UUIE (OOCTXT* pctxt, H225ReleaseComplete_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* FacilityReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225FacilityReason_routeCallToGatekeeper 1 +#define T_H225FacilityReason_callForwarded 2 +#define T_H225FacilityReason_routeCallToMC 3 +#define T_H225FacilityReason_undefinedReason 4 +#define T_H225FacilityReason_conferenceListChoice 5 +#define T_H225FacilityReason_startH245 6 +#define T_H225FacilityReason_noH245 7 +#define T_H225FacilityReason_newTokens 8 +#define T_H225FacilityReason_featureSetUpdate 9 +#define T_H225FacilityReason_forwardedElements 10 +#define T_H225FacilityReason_transportedInformation 11 +#define T_H225FacilityReason_extElem1 12 + +typedef struct EXTERN H225FacilityReason { + int t; +} H225FacilityReason; + +EXTERN int asn1PE_H225FacilityReason (OOCTXT* pctxt, H225FacilityReason* pvalue); + +EXTERN int asn1PD_H225FacilityReason (OOCTXT* pctxt, H225FacilityReason* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceList */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ConferenceList { + struct { + unsigned conferenceIDPresent : 1; + unsigned conferenceAliasPresent : 1; + unsigned nonStandardDataPresent : 1; + } m; + H225ConferenceIdentifier conferenceID; + H225AliasAddress conferenceAlias; + H225NonStandardParameter nonStandardData; +} H225ConferenceList; + +EXTERN int asn1PE_H225ConferenceList (OOCTXT* pctxt, H225ConferenceList* pvalue); + +EXTERN int asn1PD_H225ConferenceList (OOCTXT* pctxt, H225ConferenceList* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225ConferenceList */ +/* */ +/**************************************************************/ + +/* List of H225ConferenceList */ +typedef DList H225_SeqOfH225ConferenceList; + +EXTERN int asn1PE_H225_SeqOfH225ConferenceList (OOCTXT* pctxt, H225_SeqOfH225ConferenceList* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225ConferenceList (OOCTXT* pctxt, H225_SeqOfH225ConferenceList* pvalue); + +/**************************************************************/ +/* */ +/* Facility_UUIE_fastStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Facility_UUIE_fastStart { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225Facility_UUIE_fastStart; + +EXTERN int asn1PE_H225Facility_UUIE_fastStart (OOCTXT* pctxt, H225Facility_UUIE_fastStart* pvalue); + +EXTERN int asn1PD_H225Facility_UUIE_fastStart (OOCTXT* pctxt, H225Facility_UUIE_fastStart* pvalue); + +/**************************************************************/ +/* */ +/* Facility_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Facility_UUIE { + struct { + unsigned alternativeAddressPresent : 1; + unsigned alternativeAliasAddressPresent : 1; + unsigned conferenceIDPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned destExtraCallInfoPresent : 1; + unsigned remoteExtensionAddressPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned conferencesPresent : 1; + unsigned h245AddressPresent : 1; + unsigned fastStartPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned maintainConnectionPresent : 1; + unsigned fastConnectRefusedPresent : 1; + unsigned serviceControlPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned featureSetPresent : 1; + unsigned destinationInfoPresent : 1; + unsigned h245SecurityModePresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225TransportAddress alternativeAddress; + H225_SeqOfH225AliasAddress alternativeAliasAddress; + H225ConferenceIdentifier conferenceID; + H225FacilityReason reason; + H225CallIdentifier callIdentifier; + H225_SeqOfH225AliasAddress destExtraCallInfo; + H225AliasAddress remoteExtensionAddress; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225_SeqOfH225ConferenceList conferences; + H225TransportAddress h245Address; + H225Facility_UUIE_fastStart fastStart; + ASN1BOOL multipleCalls; + ASN1BOOL maintainConnection; + H225_SeqOfH225ServiceControlSession serviceControl; + H225CircuitInfo circuitInfo; + H225FeatureSet featureSet; + H225EndpointType destinationInfo; + H225H245Security h245SecurityMode; +} H225Facility_UUIE; + +EXTERN int asn1PE_H225Facility_UUIE (OOCTXT* pctxt, H225Facility_UUIE* pvalue); + +EXTERN int asn1PD_H225Facility_UUIE (OOCTXT* pctxt, H225Facility_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* Progress_UUIE_fastStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Progress_UUIE_fastStart { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225Progress_UUIE_fastStart; + +EXTERN int asn1PE_H225Progress_UUIE_fastStart (OOCTXT* pctxt, H225Progress_UUIE_fastStart* pvalue); + +EXTERN int asn1PD_H225Progress_UUIE_fastStart (OOCTXT* pctxt, H225Progress_UUIE_fastStart* pvalue); + +/**************************************************************/ +/* */ +/* Progress_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Progress_UUIE { + struct { + unsigned h245AddressPresent : 1; + unsigned h245SecurityModePresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned fastStartPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned maintainConnectionPresent : 1; + unsigned fastConnectRefusedPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225EndpointType destinationInfo; + H225TransportAddress h245Address; + H225CallIdentifier callIdentifier; + H225H245Security h245SecurityMode; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225Progress_UUIE_fastStart fastStart; + ASN1BOOL multipleCalls; + ASN1BOOL maintainConnection; +} H225Progress_UUIE; + +EXTERN int asn1PE_H225Progress_UUIE (OOCTXT* pctxt, H225Progress_UUIE* pvalue); + +EXTERN int asn1PD_H225Progress_UUIE (OOCTXT* pctxt, H225Progress_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* Status_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Status_UUIE { + struct { + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225CallIdentifier callIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; +} H225Status_UUIE; + +EXTERN int asn1PE_H225Status_UUIE (OOCTXT* pctxt, H225Status_UUIE* pvalue); + +EXTERN int asn1PD_H225Status_UUIE (OOCTXT* pctxt, H225Status_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* StatusInquiry_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225StatusInquiry_UUIE { + struct { + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225CallIdentifier callIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; +} H225StatusInquiry_UUIE; + +EXTERN int asn1PE_H225StatusInquiry_UUIE (OOCTXT* pctxt, H225StatusInquiry_UUIE* pvalue); + +EXTERN int asn1PD_H225StatusInquiry_UUIE (OOCTXT* pctxt, H225StatusInquiry_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* SetupAcknowledge_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225SetupAcknowledge_UUIE { + struct { + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225CallIdentifier callIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; +} H225SetupAcknowledge_UUIE; + +EXTERN int asn1PE_H225SetupAcknowledge_UUIE (OOCTXT* pctxt, H225SetupAcknowledge_UUIE* pvalue); + +EXTERN int asn1PD_H225SetupAcknowledge_UUIE (OOCTXT* pctxt, H225SetupAcknowledge_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* Notify_UUIE */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Notify_UUIE { + struct { + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + } m; + H225ProtocolIdentifier protocolIdentifier; + H225CallIdentifier callIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; +} H225Notify_UUIE; + +EXTERN int asn1PE_H225Notify_UUIE (OOCTXT* pctxt, H225Notify_UUIE* pvalue); + +EXTERN int asn1PD_H225Notify_UUIE (OOCTXT* pctxt, H225Notify_UUIE* pvalue); + +/**************************************************************/ +/* */ +/* H323_UU_PDU_h323_message_body */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225H323_UU_PDU_h323_message_body_setup 1 +#define T_H225H323_UU_PDU_h323_message_body_callProceeding 2 +#define T_H225H323_UU_PDU_h323_message_body_connect 3 +#define T_H225H323_UU_PDU_h323_message_body_alerting 4 +#define T_H225H323_UU_PDU_h323_message_body_information 5 +#define T_H225H323_UU_PDU_h323_message_body_releaseComplete 6 +#define T_H225H323_UU_PDU_h323_message_body_facility 7 +#define T_H225H323_UU_PDU_h323_message_body_progress 8 +#define T_H225H323_UU_PDU_h323_message_body_empty 9 +#define T_H225H323_UU_PDU_h323_message_body_status 10 +#define T_H225H323_UU_PDU_h323_message_body_statusInquiry 11 +#define T_H225H323_UU_PDU_h323_message_body_setupAcknowledge 12 +#define T_H225H323_UU_PDU_h323_message_body_notify 13 +#define T_H225H323_UU_PDU_h323_message_body_extElem1 14 + +typedef struct EXTERN H225H323_UU_PDU_h323_message_body { + int t; + union { + /* t = 1 */ + H225Setup_UUIE *setup; + /* t = 2 */ + H225CallProceeding_UUIE *callProceeding; + /* t = 3 */ + H225Connect_UUIE *connect; + /* t = 4 */ + H225Alerting_UUIE *alerting; + /* t = 5 */ + H225Information_UUIE *information; + /* t = 6 */ + H225ReleaseComplete_UUIE *releaseComplete; + /* t = 7 */ + H225Facility_UUIE *facility; + /* t = 8 */ + H225Progress_UUIE *progress; + /* t = 9 */ + /* t = 10 */ + H225Status_UUIE *status; + /* t = 11 */ + H225StatusInquiry_UUIE *statusInquiry; + /* t = 12 */ + H225SetupAcknowledge_UUIE *setupAcknowledge; + /* t = 13 */ + H225Notify_UUIE *notify; + /* t = 14 */ + } u; +} H225H323_UU_PDU_h323_message_body; + +EXTERN int asn1PE_H225H323_UU_PDU_h323_message_body (OOCTXT* pctxt, H225H323_UU_PDU_h323_message_body* pvalue); + +EXTERN int asn1PD_H225H323_UU_PDU_h323_message_body (OOCTXT* pctxt, H225H323_UU_PDU_h323_message_body* pvalue); + +/**************************************************************/ +/* */ +/* H323_UU_PDU_h4501SupplementaryService */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323_UU_PDU_h4501SupplementaryService { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225H323_UU_PDU_h4501SupplementaryService; + +EXTERN int asn1PE_H225H323_UU_PDU_h4501SupplementaryService (OOCTXT* pctxt, H225H323_UU_PDU_h4501SupplementaryService* pvalue); + +EXTERN int asn1PD_H225H323_UU_PDU_h4501SupplementaryService (OOCTXT* pctxt, H225H323_UU_PDU_h4501SupplementaryService* pvalue); + +/**************************************************************/ +/* */ +/* H323_UU_PDU_h245Control */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323_UU_PDU_h245Control { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225H323_UU_PDU_h245Control; + +EXTERN int asn1PE_H225H323_UU_PDU_h245Control (OOCTXT* pctxt, H225H323_UU_PDU_h245Control* pvalue); + +EXTERN int asn1PD_H225H323_UU_PDU_h245Control (OOCTXT* pctxt, H225H323_UU_PDU_h245Control* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225NonStandardParameter */ +/* */ +/**************************************************************/ + +/* List of H225NonStandardParameter */ +typedef DList H225_SeqOfH225NonStandardParameter; + +EXTERN int asn1PE_H225_SeqOfH225NonStandardParameter (OOCTXT* pctxt, H225_SeqOfH225NonStandardParameter* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225NonStandardParameter (OOCTXT* pctxt, H225_SeqOfH225NonStandardParameter* pvalue); + +/**************************************************************/ +/* */ +/* CallLinkage */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallLinkage { + struct { + unsigned globalCallIdPresent : 1; + unsigned threadIdPresent : 1; + } m; + H225GloballyUniqueID globalCallId; + H225GloballyUniqueID threadId; +} H225CallLinkage; + +EXTERN int asn1PE_H225CallLinkage (OOCTXT* pctxt, H225CallLinkage* pvalue); + +EXTERN int asn1PD_H225CallLinkage (OOCTXT* pctxt, H225CallLinkage* pvalue); + +/**************************************************************/ +/* */ +/* H323_UU_PDU_tunnelledSignallingMessage_messageContent */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323_UU_PDU_tunnelledSignallingMessage_messageContent { + ASN1UINT n; + ASN1DynOctStr *elem; +} H225H323_UU_PDU_tunnelledSignallingMessage_messageContent; + +EXTERN int asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage_messageContent* pvalue); + +EXTERN int asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage_messageContent* pvalue); + +/**************************************************************/ +/* */ +/* H323_UU_PDU_tunnelledSignallingMessage */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323_UU_PDU_tunnelledSignallingMessage { + struct { + unsigned tunnellingRequiredPresent : 1; + unsigned nonStandardDataPresent : 1; + } m; + H225TunnelledProtocol tunnelledProtocolID; + H225H323_UU_PDU_tunnelledSignallingMessage_messageContent messageContent; + H225NonStandardParameter nonStandardData; +} H225H323_UU_PDU_tunnelledSignallingMessage; + +EXTERN int asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage* pvalue); + +EXTERN int asn1PD_H225H323_UU_PDU_tunnelledSignallingMessage (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage* pvalue); + +/**************************************************************/ +/* */ +/* StimulusControl */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225StimulusControl { + struct { + unsigned nonStandardPresent : 1; + unsigned isTextPresent : 1; + unsigned h248MessagePresent : 1; + } m; + H225NonStandardParameter nonStandard; + ASN1DynOctStr h248Message; +} H225StimulusControl; + +EXTERN int asn1PE_H225StimulusControl (OOCTXT* pctxt, H225StimulusControl* pvalue); + +EXTERN int asn1PD_H225StimulusControl (OOCTXT* pctxt, H225StimulusControl* pvalue); + +/**************************************************************/ +/* */ +/* H323_UU_PDU */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323_UU_PDU { + struct { + unsigned nonStandardDataPresent : 1; + unsigned h4501SupplementaryServicePresent : 1; + unsigned h245TunnelingPresent : 1; + unsigned h245ControlPresent : 1; + unsigned nonStandardControlPresent : 1; + unsigned callLinkagePresent : 1; + unsigned tunnelledSignallingMessagePresent : 1; + unsigned provisionalRespToH245TunnelingPresent : 1; + unsigned stimulusControlPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225H323_UU_PDU_h323_message_body h323_message_body; + H225NonStandardParameter nonStandardData; + H225H323_UU_PDU_h4501SupplementaryService h4501SupplementaryService; + ASN1BOOL h245Tunneling; + H225H323_UU_PDU_h245Control h245Control; + H225_SeqOfH225NonStandardParameter nonStandardControl; + H225CallLinkage callLinkage; + H225H323_UU_PDU_tunnelledSignallingMessage tunnelledSignallingMessage; + H225StimulusControl stimulusControl; + H225_SeqOfH225GenericData genericData; +} H225H323_UU_PDU; + +EXTERN int asn1PE_H225H323_UU_PDU (OOCTXT* pctxt, H225H323_UU_PDU* pvalue); + +EXTERN int asn1PD_H225H323_UU_PDU (OOCTXT* pctxt, H225H323_UU_PDU* pvalue); + +/**************************************************************/ +/* */ +/* H323_UserInformation_user_data */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323_UserInformation_user_data { + ASN1UINT8 protocol_discriminator; + H225H323_UserInformation_user_data_user_information user_information; +} H225H323_UserInformation_user_data; + +EXTERN int asn1PE_H225H323_UserInformation_user_data (OOCTXT* pctxt, H225H323_UserInformation_user_data* pvalue); + +EXTERN int asn1PD_H225H323_UserInformation_user_data (OOCTXT* pctxt, H225H323_UserInformation_user_data* pvalue); + +/**************************************************************/ +/* */ +/* H323_UserInformation */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225H323_UserInformation { + struct { + unsigned user_dataPresent : 1; + } m; + H225H323_UU_PDU h323_uu_pdu; + H225H323_UserInformation_user_data user_data; +} H225H323_UserInformation; + +EXTERN int asn1PE_H225H323_UserInformation (OOCTXT* pctxt, H225H323_UserInformation* pvalue); + +EXTERN int asn1PD_H225H323_UserInformation (OOCTXT* pctxt, H225H323_UserInformation* pvalue); + +/**************************************************************/ +/* */ +/* AddressPattern_range */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225AddressPattern_range { + H225PartyNumber startOfRange; + H225PartyNumber endOfRange; +} H225AddressPattern_range; + +EXTERN int asn1PE_H225AddressPattern_range (OOCTXT* pctxt, H225AddressPattern_range* pvalue); + +EXTERN int asn1PD_H225AddressPattern_range (OOCTXT* pctxt, H225AddressPattern_range* pvalue); + +/**************************************************************/ +/* */ +/* AddressPattern */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225AddressPattern_wildcard 1 +#define T_H225AddressPattern_range 2 +#define T_H225AddressPattern_extElem1 3 + +typedef struct EXTERN H225AddressPattern { + int t; + union { + /* t = 1 */ + H225AliasAddress *wildcard; + /* t = 2 */ + H225AddressPattern_range *range; + /* t = 3 */ + } u; +} H225AddressPattern; + +EXTERN int asn1PE_H225AddressPattern (OOCTXT* pctxt, H225AddressPattern* pvalue); + +EXTERN int asn1PD_H225AddressPattern (OOCTXT* pctxt, H225AddressPattern* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225TransportAddress */ +/* */ +/**************************************************************/ + +/* List of H225TransportAddress */ +typedef DList H225_SeqOfH225TransportAddress; + +EXTERN int asn1PE_H225_SeqOfH225TransportAddress (OOCTXT* pctxt, H225_SeqOfH225TransportAddress* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225TransportAddress (OOCTXT* pctxt, H225_SeqOfH225TransportAddress* pvalue); + +/**************************************************************/ +/* */ +/* AlternateTransportAddresses */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225AlternateTransportAddresses { + struct { + unsigned annexEPresent : 1; + unsigned sctpPresent : 1; + } m; + H225_SeqOfH225TransportAddress annexE; + H225_SeqOfH225TransportAddress sctp; +} H225AlternateTransportAddresses; + +EXTERN int asn1PE_H225AlternateTransportAddresses (OOCTXT* pctxt, H225AlternateTransportAddresses* pvalue); + +EXTERN int asn1PD_H225AlternateTransportAddresses (OOCTXT* pctxt, H225AlternateTransportAddresses* pvalue); + +/**************************************************************/ +/* */ +/* Endpoint */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225Endpoint { + struct { + unsigned nonStandardDataPresent : 1; + unsigned aliasAddressPresent : 1; + unsigned callSignalAddressPresent : 1; + unsigned rasAddressPresent : 1; + unsigned endpointTypePresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned priorityPresent : 1; + unsigned remoteExtensionAddressPresent : 1; + unsigned destExtraCallInfoPresent : 1; + unsigned alternateTransportAddressesPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned featureSetPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225AliasAddress aliasAddress; + H225_SeqOfH225TransportAddress callSignalAddress; + H225_SeqOfH225TransportAddress rasAddress; + H225EndpointType endpointType; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + ASN1UINT8 priority; + H225_SeqOfH225AliasAddress remoteExtensionAddress; + H225_SeqOfH225AliasAddress destExtraCallInfo; + H225AlternateTransportAddresses alternateTransportAddresses; + H225CircuitInfo circuitInfo; + H225FeatureSet featureSet; +} H225Endpoint; + +EXTERN int asn1PE_H225Endpoint (OOCTXT* pctxt, H225Endpoint* pvalue); + +EXTERN int asn1PD_H225Endpoint (OOCTXT* pctxt, H225Endpoint* pvalue); + +/**************************************************************/ +/* */ +/* UseSpecifiedTransport */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225UseSpecifiedTransport_tcp 1 +#define T_H225UseSpecifiedTransport_annexE 2 +#define T_H225UseSpecifiedTransport_sctp 3 +#define T_H225UseSpecifiedTransport_extElem1 4 + +typedef struct EXTERN H225UseSpecifiedTransport { + int t; +} H225UseSpecifiedTransport; + +EXTERN int asn1PE_H225UseSpecifiedTransport (OOCTXT* pctxt, H225UseSpecifiedTransport* pvalue); + +EXTERN int asn1PD_H225UseSpecifiedTransport (OOCTXT* pctxt, H225UseSpecifiedTransport* pvalue); + +/**************************************************************/ +/* */ +/* AlternateGK */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225AlternateGK { + struct { + unsigned gatekeeperIdentifierPresent : 1; + } m; + H225TransportAddress rasAddress; + H225GatekeeperIdentifier gatekeeperIdentifier; + ASN1BOOL needToRegister; + ASN1UINT8 priority; +} H225AlternateGK; + +EXTERN int asn1PE_H225AlternateGK (OOCTXT* pctxt, H225AlternateGK* pvalue); + +EXTERN int asn1PD_H225AlternateGK (OOCTXT* pctxt, H225AlternateGK* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225AlternateGK */ +/* */ +/**************************************************************/ + +/* List of H225AlternateGK */ +typedef DList H225_SeqOfH225AlternateGK; + +EXTERN int asn1PE_H225_SeqOfH225AlternateGK (OOCTXT* pctxt, H225_SeqOfH225AlternateGK* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225AlternateGK (OOCTXT* pctxt, H225_SeqOfH225AlternateGK* pvalue); + +/**************************************************************/ +/* */ +/* AltGKInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225AltGKInfo { + H225_SeqOfH225AlternateGK alternateGatekeeper; + ASN1BOOL altGKisPermanent; +} H225AltGKInfo; + +EXTERN int asn1PE_H225AltGKInfo (OOCTXT* pctxt, H225AltGKInfo* pvalue); + +EXTERN int asn1PD_H225AltGKInfo (OOCTXT* pctxt, H225AltGKInfo* pvalue); + +/**************************************************************/ +/* */ +/* SecurityErrors2 */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225SecurityErrors2_securityWrongSyncTime 1 +#define T_H225SecurityErrors2_securityReplay 2 +#define T_H225SecurityErrors2_securityWrongGeneralID 3 +#define T_H225SecurityErrors2_securityWrongSendersID 4 +#define T_H225SecurityErrors2_securityIntegrityFailed 5 +#define T_H225SecurityErrors2_securityWrongOID 6 +#define T_H225SecurityErrors2_extElem1 7 + +typedef struct EXTERN H225SecurityErrors2 { + int t; +} H225SecurityErrors2; + +EXTERN int asn1PE_H225SecurityErrors2 (OOCTXT* pctxt, H225SecurityErrors2* pvalue); + +EXTERN int asn1PD_H225SecurityErrors2 (OOCTXT* pctxt, H225SecurityErrors2* pvalue); + +/**************************************************************/ +/* */ +/* EncryptIntAlg */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225EncryptIntAlg_nonStandard 1 +#define T_H225EncryptIntAlg_isoAlgorithm 2 +#define T_H225EncryptIntAlg_extElem1 3 + +typedef struct EXTERN H225EncryptIntAlg { + int t; + union { + /* t = 1 */ + H225NonStandardParameter *nonStandard; + /* t = 2 */ + ASN1OBJID *isoAlgorithm; + /* t = 3 */ + } u; +} H225EncryptIntAlg; + +EXTERN int asn1PE_H225EncryptIntAlg (OOCTXT* pctxt, H225EncryptIntAlg* pvalue); + +EXTERN int asn1PD_H225EncryptIntAlg (OOCTXT* pctxt, H225EncryptIntAlg* pvalue); + +/**************************************************************/ +/* */ +/* NonIsoIntegrityMechanism */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225NonIsoIntegrityMechanism_hMAC_MD5 1 +#define T_H225NonIsoIntegrityMechanism_hMAC_iso10118_2_s 2 +#define T_H225NonIsoIntegrityMechanism_hMAC_iso10118_2_l 3 +#define T_H225NonIsoIntegrityMechanism_hMAC_iso10118_3 4 +#define T_H225NonIsoIntegrityMechanism_extElem1 5 + +typedef struct EXTERN H225NonIsoIntegrityMechanism { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H225EncryptIntAlg *hMAC_iso10118_2_s; + /* t = 3 */ + H225EncryptIntAlg *hMAC_iso10118_2_l; + /* t = 4 */ + ASN1OBJID *hMAC_iso10118_3; + /* t = 5 */ + } u; +} H225NonIsoIntegrityMechanism; + +EXTERN int asn1PE_H225NonIsoIntegrityMechanism (OOCTXT* pctxt, H225NonIsoIntegrityMechanism* pvalue); + +EXTERN int asn1PD_H225NonIsoIntegrityMechanism (OOCTXT* pctxt, H225NonIsoIntegrityMechanism* pvalue); + +/**************************************************************/ +/* */ +/* IntegrityMechanism */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225IntegrityMechanism_nonStandard 1 +#define T_H225IntegrityMechanism_digSig 2 +#define T_H225IntegrityMechanism_iso9797 3 +#define T_H225IntegrityMechanism_nonIsoIM 4 +#define T_H225IntegrityMechanism_extElem1 5 + +typedef struct EXTERN H225IntegrityMechanism { + int t; + union { + /* t = 1 */ + H225NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + ASN1OBJID *iso9797; + /* t = 4 */ + H225NonIsoIntegrityMechanism *nonIsoIM; + /* t = 5 */ + } u; +} H225IntegrityMechanism; + +EXTERN int asn1PE_H225IntegrityMechanism (OOCTXT* pctxt, H225IntegrityMechanism* pvalue); + +EXTERN int asn1PD_H225IntegrityMechanism (OOCTXT* pctxt, H225IntegrityMechanism* pvalue); + +/**************************************************************/ +/* */ +/* ICV */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ICV { + ASN1OBJID algorithmOID; + ASN1DynBitStr icv; +} H225ICV; + +EXTERN int asn1PE_H225ICV (OOCTXT* pctxt, H225ICV* pvalue); + +EXTERN int asn1PD_H225ICV (OOCTXT* pctxt, H225ICV* pvalue); + +/**************************************************************/ +/* */ +/* CapacityReportingCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CapacityReportingCapability { + ASN1BOOL canReportCallCapacity; +} H225CapacityReportingCapability; + +EXTERN int asn1PE_H225CapacityReportingCapability (OOCTXT* pctxt, H225CapacityReportingCapability* pvalue); + +EXTERN int asn1PD_H225CapacityReportingCapability (OOCTXT* pctxt, H225CapacityReportingCapability* pvalue); + +/**************************************************************/ +/* */ +/* CapacityReportingSpecification_when */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CapacityReportingSpecification_when { + struct { + unsigned callStartPresent : 1; + unsigned callEndPresent : 1; + } m; + ASN1OCTET __dummy__; +} H225CapacityReportingSpecification_when; + +EXTERN int asn1PE_H225CapacityReportingSpecification_when (OOCTXT* pctxt, H225CapacityReportingSpecification_when* pvalue); + +EXTERN int asn1PD_H225CapacityReportingSpecification_when (OOCTXT* pctxt, H225CapacityReportingSpecification_when* pvalue); + +/**************************************************************/ +/* */ +/* CapacityReportingSpecification */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CapacityReportingSpecification { + H225CapacityReportingSpecification_when when; +} H225CapacityReportingSpecification; + +EXTERN int asn1PE_H225CapacityReportingSpecification (OOCTXT* pctxt, H225CapacityReportingSpecification* pvalue); + +EXTERN int asn1PD_H225CapacityReportingSpecification (OOCTXT* pctxt, H225CapacityReportingSpecification* pvalue); + +/**************************************************************/ +/* */ +/* RasUsageInfoTypes */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RasUsageInfoTypes { + struct { + unsigned startTimePresent : 1; + unsigned endTimePresent : 1; + unsigned terminationCausePresent : 1; + } m; + H225_SeqOfH225NonStandardParameter nonStandardUsageTypes; +} H225RasUsageInfoTypes; + +EXTERN int asn1PE_H225RasUsageInfoTypes (OOCTXT* pctxt, H225RasUsageInfoTypes* pvalue); + +EXTERN int asn1PD_H225RasUsageInfoTypes (OOCTXT* pctxt, H225RasUsageInfoTypes* pvalue); + +/**************************************************************/ +/* */ +/* RasUsageSpecification_when */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RasUsageSpecification_when { + struct { + unsigned startPresent : 1; + unsigned endPresent : 1; + unsigned inIrrPresent : 1; + } m; + ASN1OCTET __dummy__; +} H225RasUsageSpecification_when; + +EXTERN int asn1PE_H225RasUsageSpecification_when (OOCTXT* pctxt, H225RasUsageSpecification_when* pvalue); + +EXTERN int asn1PD_H225RasUsageSpecification_when (OOCTXT* pctxt, H225RasUsageSpecification_when* pvalue); + +/**************************************************************/ +/* */ +/* RasUsageSpecification_callStartingPoint */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RasUsageSpecification_callStartingPoint { + struct { + unsigned alertingPresent : 1; + unsigned connectPresent : 1; + } m; + ASN1OCTET __dummy__; +} H225RasUsageSpecification_callStartingPoint; + +EXTERN int asn1PE_H225RasUsageSpecification_callStartingPoint (OOCTXT* pctxt, H225RasUsageSpecification_callStartingPoint* pvalue); + +EXTERN int asn1PD_H225RasUsageSpecification_callStartingPoint (OOCTXT* pctxt, H225RasUsageSpecification_callStartingPoint* pvalue); + +/**************************************************************/ +/* */ +/* RasUsageSpecification */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RasUsageSpecification { + struct { + unsigned callStartingPointPresent : 1; + } m; + H225RasUsageSpecification_when when; + H225RasUsageSpecification_callStartingPoint callStartingPoint; + H225RasUsageInfoTypes required; +} H225RasUsageSpecification; + +EXTERN int asn1PE_H225RasUsageSpecification (OOCTXT* pctxt, H225RasUsageSpecification* pvalue); + +EXTERN int asn1PD_H225RasUsageSpecification (OOCTXT* pctxt, H225RasUsageSpecification* pvalue); + +/**************************************************************/ +/* */ +/* RasUsageInformation */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RasUsageInformation { + struct { + unsigned alertingTimePresent : 1; + unsigned connectTimePresent : 1; + unsigned endTimePresent : 1; + } m; + H225_SeqOfH225NonStandardParameter nonStandardUsageFields; + H235TimeStamp alertingTime; + H235TimeStamp connectTime; + H235TimeStamp endTime; +} H225RasUsageInformation; + +EXTERN int asn1PE_H225RasUsageInformation (OOCTXT* pctxt, H225RasUsageInformation* pvalue); + +EXTERN int asn1PD_H225RasUsageInformation (OOCTXT* pctxt, H225RasUsageInformation* pvalue); + +/**************************************************************/ +/* */ +/* CallTerminationCause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225CallTerminationCause_releaseCompleteReason 1 +#define T_H225CallTerminationCause_releaseCompleteCauseIE 2 +#define T_H225CallTerminationCause_extElem1 3 + +typedef struct EXTERN H225CallTerminationCause { + int t; + union { + /* t = 1 */ + H225ReleaseCompleteReason *releaseCompleteReason; + /* t = 2 */ + H225CallTerminationCause_releaseCompleteCauseIE *releaseCompleteCauseIE; + /* t = 3 */ + } u; +} H225CallTerminationCause; + +EXTERN int asn1PE_H225CallTerminationCause (OOCTXT* pctxt, H225CallTerminationCause* pvalue); + +EXTERN int asn1PD_H225CallTerminationCause (OOCTXT* pctxt, H225CallTerminationCause* pvalue); + +/**************************************************************/ +/* */ +/* TransportChannelInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225TransportChannelInfo { + struct { + unsigned sendAddressPresent : 1; + unsigned recvAddressPresent : 1; + } m; + H225TransportAddress sendAddress; + H225TransportAddress recvAddress; +} H225TransportChannelInfo; + +EXTERN int asn1PE_H225TransportChannelInfo (OOCTXT* pctxt, H225TransportChannelInfo* pvalue); + +EXTERN int asn1PD_H225TransportChannelInfo (OOCTXT* pctxt, H225TransportChannelInfo* pvalue); + +/**************************************************************/ +/* */ +/* BandwidthDetails */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225BandwidthDetails { + ASN1BOOL sender; + ASN1BOOL multicast; + H225BandWidth bandwidth; + H225TransportChannelInfo rtcpAddresses; +} H225BandwidthDetails; + +EXTERN int asn1PE_H225BandwidthDetails (OOCTXT* pctxt, H225BandwidthDetails* pvalue); + +EXTERN int asn1PD_H225BandwidthDetails (OOCTXT* pctxt, H225BandwidthDetails* pvalue); + +/**************************************************************/ +/* */ +/* CallCreditCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225CallCreditCapability { + struct { + unsigned canDisplayAmountStringPresent : 1; + unsigned canEnforceDurationLimitPresent : 1; + } m; + ASN1BOOL canDisplayAmountString; + ASN1BOOL canEnforceDurationLimit; +} H225CallCreditCapability; + +EXTERN int asn1PE_H225CallCreditCapability (OOCTXT* pctxt, H225CallCreditCapability* pvalue); + +EXTERN int asn1PD_H225CallCreditCapability (OOCTXT* pctxt, H225CallCreditCapability* pvalue); + +/**************************************************************/ +/* */ +/* RTPSession_associatedSessionIds */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RTPSession_associatedSessionIds { + ASN1UINT n; + ASN1UINT8 *elem; +} H225RTPSession_associatedSessionIds; + +EXTERN int asn1PE_H225RTPSession_associatedSessionIds (OOCTXT* pctxt, H225RTPSession_associatedSessionIds* pvalue); + +EXTERN int asn1PD_H225RTPSession_associatedSessionIds (OOCTXT* pctxt, H225RTPSession_associatedSessionIds* pvalue); + +/**************************************************************/ +/* */ +/* RTPSession */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RTPSession { + struct { + unsigned multicastPresent : 1; + unsigned bandwidthPresent : 1; + } m; + H225TransportChannelInfo rtpAddress; + H225TransportChannelInfo rtcpAddress; + ASN1PrintableString cname; + ASN1UINT ssrc; + ASN1UINT8 sessionId; + H225RTPSession_associatedSessionIds associatedSessionIds; + H225BandWidth bandwidth; +} H225RTPSession; + +EXTERN int asn1PE_H225RTPSession (OOCTXT* pctxt, H225RTPSession* pvalue); + +EXTERN int asn1PD_H225RTPSession (OOCTXT* pctxt, H225RTPSession* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225Endpoint */ +/* */ +/**************************************************************/ + +/* List of H225Endpoint */ +typedef DList H225_SeqOfH225Endpoint; + +EXTERN int asn1PE_H225_SeqOfH225Endpoint (OOCTXT* pctxt, H225_SeqOfH225Endpoint* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225Endpoint (OOCTXT* pctxt, H225_SeqOfH225Endpoint* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225AuthenticationMechanism */ +/* */ +/**************************************************************/ + +/* List of H235AuthenticationMechanism */ +typedef DList H225_SeqOfH225AuthenticationMechanism; + +EXTERN int asn1PE_H225_SeqOfH225AuthenticationMechanism (OOCTXT* pctxt, H225_SeqOfH225AuthenticationMechanism* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225AuthenticationMechanism (OOCTXT* pctxt, H225_SeqOfH225AuthenticationMechanism* pvalue); + +/**************************************************************/ +/* */ +/* GatekeeperRequest_algorithmOIDs */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GatekeeperRequest_algorithmOIDs { + ASN1UINT n; + ASN1OBJID *elem; +} H225GatekeeperRequest_algorithmOIDs; + +EXTERN int asn1PE_H225GatekeeperRequest_algorithmOIDs (OOCTXT* pctxt, H225GatekeeperRequest_algorithmOIDs* pvalue); + +EXTERN int asn1PD_H225GatekeeperRequest_algorithmOIDs (OOCTXT* pctxt, H225GatekeeperRequest_algorithmOIDs* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225IntegrityMechanism */ +/* */ +/**************************************************************/ + +/* List of H225IntegrityMechanism */ +typedef DList H225_SeqOfH225IntegrityMechanism; + +EXTERN int asn1PE_H225_SeqOfH225IntegrityMechanism (OOCTXT* pctxt, H225_SeqOfH225IntegrityMechanism* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225IntegrityMechanism (OOCTXT* pctxt, H225_SeqOfH225IntegrityMechanism* pvalue); + +/**************************************************************/ +/* */ +/* GatekeeperRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GatekeeperRequest { + struct { + unsigned nonStandardDataPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned callServicesPresent : 1; + unsigned endpointAliasPresent : 1; + unsigned alternateEndpointsPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned authenticationCapabilityPresent : 1; + unsigned algorithmOIDsPresent : 1; + unsigned integrityPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned supportsAltGKPresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ProtocolIdentifier protocolIdentifier; + H225NonStandardParameter nonStandardData; + H225TransportAddress rasAddress; + H225EndpointType endpointType; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225QseriesOptions callServices; + H225_SeqOfH225AliasAddress endpointAlias; + H225_SeqOfH225Endpoint alternateEndpoints; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225_SeqOfH225AuthenticationMechanism authenticationCapability; + H225GatekeeperRequest_algorithmOIDs algorithmOIDs; + H225_SeqOfH225IntegrityMechanism integrity; + H225ICV integrityCheckValue; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225GatekeeperRequest; + +EXTERN int asn1PE_H225GatekeeperRequest (OOCTXT* pctxt, H225GatekeeperRequest* pvalue); + +EXTERN int asn1PD_H225GatekeeperRequest (OOCTXT* pctxt, H225GatekeeperRequest* pvalue); + +/**************************************************************/ +/* */ +/* GatekeeperConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GatekeeperConfirm { + struct { + unsigned nonStandardDataPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned alternateGatekeeperPresent : 1; + unsigned authenticationModePresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned algorithmOIDPresent : 1; + unsigned integrityPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ProtocolIdentifier protocolIdentifier; + H225NonStandardParameter nonStandardData; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225TransportAddress rasAddress; + H225_SeqOfH225AlternateGK alternateGatekeeper; + H235AuthenticationMechanism authenticationMode; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + ASN1OBJID algorithmOID; + H225_SeqOfH225IntegrityMechanism integrity; + H225ICV integrityCheckValue; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225GatekeeperConfirm; + +EXTERN int asn1PE_H225GatekeeperConfirm (OOCTXT* pctxt, H225GatekeeperConfirm* pvalue); + +EXTERN int asn1PD_H225GatekeeperConfirm (OOCTXT* pctxt, H225GatekeeperConfirm* pvalue); + +/**************************************************************/ +/* */ +/* GatekeeperRejectReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225GatekeeperRejectReason_resourceUnavailable 1 +#define T_H225GatekeeperRejectReason_terminalExcluded 2 +#define T_H225GatekeeperRejectReason_invalidRevision 3 +#define T_H225GatekeeperRejectReason_undefinedReason 4 +#define T_H225GatekeeperRejectReason_securityDenial 5 +#define T_H225GatekeeperRejectReason_genericDataReason 6 +#define T_H225GatekeeperRejectReason_neededFeatureNotSupported 7 +#define T_H225GatekeeperRejectReason_securityError 8 +#define T_H225GatekeeperRejectReason_extElem1 9 + +typedef struct EXTERN H225GatekeeperRejectReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + H225SecurityErrors *securityError; + /* t = 9 */ + } u; +} H225GatekeeperRejectReason; + +EXTERN int asn1PE_H225GatekeeperRejectReason (OOCTXT* pctxt, H225GatekeeperRejectReason* pvalue); + +EXTERN int asn1PD_H225GatekeeperRejectReason (OOCTXT* pctxt, H225GatekeeperRejectReason* pvalue); + +/**************************************************************/ +/* */ +/* GatekeeperReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225GatekeeperReject { + struct { + unsigned nonStandardDataPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned altGKInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ProtocolIdentifier protocolIdentifier; + H225NonStandardParameter nonStandardData; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225GatekeeperRejectReason rejectReason; + H225AltGKInfo altGKInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225GatekeeperReject; + +EXTERN int asn1PE_H225GatekeeperReject (OOCTXT* pctxt, H225GatekeeperReject* pvalue); + +EXTERN int asn1PD_H225GatekeeperReject (OOCTXT* pctxt, H225GatekeeperReject* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225AddressPattern */ +/* */ +/**************************************************************/ + +/* List of H225AddressPattern */ +typedef DList H225_SeqOfH225AddressPattern; + +EXTERN int asn1PE_H225_SeqOfH225AddressPattern (OOCTXT* pctxt, H225_SeqOfH225AddressPattern* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225AddressPattern (OOCTXT* pctxt, H225_SeqOfH225AddressPattern* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225H248PackagesDescriptor */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225_SeqOfH225H248PackagesDescriptor { + ASN1UINT n; + H225H248PackagesDescriptor *elem; +} H225_SeqOfH225H248PackagesDescriptor; + +EXTERN int asn1PE_H225_SeqOfH225H248PackagesDescriptor (OOCTXT* pctxt, H225_SeqOfH225H248PackagesDescriptor* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225H248PackagesDescriptor (OOCTXT* pctxt, H225_SeqOfH225H248PackagesDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* RegistrationRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RegistrationRequest { + struct { + unsigned nonStandardDataPresent : 1; + unsigned terminalAliasPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned alternateEndpointsPresent : 1; + unsigned timeToLivePresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned keepAlivePresent : 1; + unsigned endpointIdentifierPresent : 1; + unsigned willSupplyUUIEsPresent : 1; + unsigned maintainConnectionPresent : 1; + unsigned alternateTransportAddressesPresent : 1; + unsigned additiveRegistrationPresent : 1; + unsigned terminalAliasPatternPresent : 1; + unsigned supportsAltGKPresent : 1; + unsigned usageReportingCapabilityPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned supportedH248PackagesPresent : 1; + unsigned callCreditCapabilityPresent : 1; + unsigned capacityReportingCapabilityPresent : 1; + unsigned capacityPresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + unsigned restartPresent : 1; + unsigned supportsACFSequencesPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ProtocolIdentifier protocolIdentifier; + H225NonStandardParameter nonStandardData; + ASN1BOOL discoveryComplete; + H225_SeqOfH225TransportAddress callSignalAddress; + H225_SeqOfH225TransportAddress rasAddress; + H225EndpointType terminalType; + H225_SeqOfH225AliasAddress terminalAlias; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225VendorIdentifier endpointVendor; + H225_SeqOfH225Endpoint alternateEndpoints; + H225TimeToLive timeToLive; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + ASN1BOOL keepAlive; + H225EndpointIdentifier endpointIdentifier; + ASN1BOOL willSupplyUUIEs; + ASN1BOOL maintainConnection; + H225AlternateTransportAddresses alternateTransportAddresses; + H225_SeqOfH225AddressPattern terminalAliasPattern; + H225RasUsageInfoTypes usageReportingCapability; + ASN1BOOL multipleCalls; + H225_SeqOfH225H248PackagesDescriptor supportedH248Packages; + H225CallCreditCapability callCreditCapability; + H225CapacityReportingCapability capacityReportingCapability; + H225CallCapacity capacity; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225RegistrationRequest; + +EXTERN int asn1PE_H225RegistrationRequest (OOCTXT* pctxt, H225RegistrationRequest* pvalue); + +EXTERN int asn1PD_H225RegistrationRequest (OOCTXT* pctxt, H225RegistrationRequest* pvalue); + +/**************************************************************/ +/* */ +/* RegistrationConfirm_preGrantedARQ */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RegistrationConfirm_preGrantedARQ { + struct { + unsigned irrFrequencyInCallPresent : 1; + unsigned totalBandwidthRestrictionPresent : 1; + unsigned alternateTransportAddressesPresent : 1; + unsigned useSpecifiedTransportPresent : 1; + } m; + ASN1BOOL makeCall; + ASN1BOOL useGKCallSignalAddressToMakeCall; + ASN1BOOL answerCall; + ASN1BOOL useGKCallSignalAddressToAnswer; + ASN1USINT irrFrequencyInCall; + H225BandWidth totalBandwidthRestriction; + H225AlternateTransportAddresses alternateTransportAddresses; + H225UseSpecifiedTransport useSpecifiedTransport; +} H225RegistrationConfirm_preGrantedARQ; + +EXTERN int asn1PE_H225RegistrationConfirm_preGrantedARQ (OOCTXT* pctxt, H225RegistrationConfirm_preGrantedARQ* pvalue); + +EXTERN int asn1PD_H225RegistrationConfirm_preGrantedARQ (OOCTXT* pctxt, H225RegistrationConfirm_preGrantedARQ* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225RasUsageSpecification */ +/* */ +/**************************************************************/ + +/* List of H225RasUsageSpecification */ +typedef DList H225_SeqOfH225RasUsageSpecification; + +EXTERN int asn1PE_H225_SeqOfH225RasUsageSpecification (OOCTXT* pctxt, H225_SeqOfH225RasUsageSpecification* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225RasUsageSpecification (OOCTXT* pctxt, H225_SeqOfH225RasUsageSpecification* pvalue); + +/**************************************************************/ +/* */ +/* RegistrationConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RegistrationConfirm { + struct { + unsigned nonStandardDataPresent : 1; + unsigned terminalAliasPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned alternateGatekeeperPresent : 1; + unsigned timeToLivePresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned willRespondToIRRPresent : 1; + unsigned preGrantedARQPresent : 1; + unsigned maintainConnectionPresent : 1; + unsigned serviceControlPresent : 1; + unsigned supportsAdditiveRegistrationPresent : 1; + unsigned terminalAliasPatternPresent : 1; + unsigned supportedPrefixesPresent : 1; + unsigned usageSpecPresent : 1; + unsigned featureServerAliasPresent : 1; + unsigned capacityReportingSpecPresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ProtocolIdentifier protocolIdentifier; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225TransportAddress callSignalAddress; + H225_SeqOfH225AliasAddress terminalAlias; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225EndpointIdentifier endpointIdentifier; + H225_SeqOfH225AlternateGK alternateGatekeeper; + H225TimeToLive timeToLive; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + ASN1BOOL willRespondToIRR; + H225RegistrationConfirm_preGrantedARQ preGrantedARQ; + ASN1BOOL maintainConnection; + H225_SeqOfH225ServiceControlSession serviceControl; + H225_SeqOfH225AddressPattern terminalAliasPattern; + H225_SeqOfH225SupportedPrefix supportedPrefixes; + H225_SeqOfH225RasUsageSpecification usageSpec; + H225AliasAddress featureServerAlias; + H225CapacityReportingSpecification capacityReportingSpec; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225RegistrationConfirm; + +EXTERN int asn1PE_H225RegistrationConfirm (OOCTXT* pctxt, H225RegistrationConfirm* pvalue); + +EXTERN int asn1PD_H225RegistrationConfirm (OOCTXT* pctxt, H225RegistrationConfirm* pvalue); + +/**************************************************************/ +/* */ +/* RegistrationRejectReason_invalidTerminalAliases */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RegistrationRejectReason_invalidTerminalAliases { + struct { + unsigned terminalAliasPresent : 1; + unsigned terminalAliasPatternPresent : 1; + unsigned supportedPrefixesPresent : 1; + } m; + H225_SeqOfH225AliasAddress terminalAlias; + H225_SeqOfH225AddressPattern terminalAliasPattern; + H225_SeqOfH225SupportedPrefix supportedPrefixes; +} H225RegistrationRejectReason_invalidTerminalAliases; + +EXTERN int asn1PE_H225RegistrationRejectReason_invalidTerminalAliases (OOCTXT* pctxt, H225RegistrationRejectReason_invalidTerminalAliases* pvalue); + +EXTERN int asn1PD_H225RegistrationRejectReason_invalidTerminalAliases (OOCTXT* pctxt, H225RegistrationRejectReason_invalidTerminalAliases* pvalue); + +/**************************************************************/ +/* */ +/* RegistrationRejectReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225RegistrationRejectReason_discoveryRequired 1 +#define T_H225RegistrationRejectReason_invalidRevision 2 +#define T_H225RegistrationRejectReason_invalidCallSignalAddress 3 +#define T_H225RegistrationRejectReason_invalidRASAddress 4 +#define T_H225RegistrationRejectReason_duplicateAlias 5 +#define T_H225RegistrationRejectReason_invalidTerminalType 6 +#define T_H225RegistrationRejectReason_undefinedReason 7 +#define T_H225RegistrationRejectReason_transportNotSupported 8 +#define T_H225RegistrationRejectReason_transportQOSNotSupported 9 +#define T_H225RegistrationRejectReason_resourceUnavailable 10 +#define T_H225RegistrationRejectReason_invalidAlias 11 +#define T_H225RegistrationRejectReason_securityDenial 12 +#define T_H225RegistrationRejectReason_fullRegistrationRequired 13 +#define T_H225RegistrationRejectReason_additiveRegistrationNotSupported 14 +#define T_H225RegistrationRejectReason_invalidTerminalAliases 15 +#define T_H225RegistrationRejectReason_genericDataReason 16 +#define T_H225RegistrationRejectReason_neededFeatureNotSupported 17 +#define T_H225RegistrationRejectReason_securityError 18 +#define T_H225RegistrationRejectReason_extElem1 19 + +typedef struct EXTERN H225RegistrationRejectReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + H225_SeqOfH225AliasAddress *duplicateAlias; + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + /* t = 9 */ + /* t = 10 */ + /* t = 11 */ + /* t = 12 */ + /* t = 13 */ + /* t = 14 */ + /* t = 15 */ + H225RegistrationRejectReason_invalidTerminalAliases *invalidTerminalAliases; + /* t = 16 */ + /* t = 17 */ + /* t = 18 */ + H225SecurityErrors *securityError; + /* t = 19 */ + } u; +} H225RegistrationRejectReason; + +EXTERN int asn1PE_H225RegistrationRejectReason (OOCTXT* pctxt, H225RegistrationRejectReason* pvalue); + +EXTERN int asn1PD_H225RegistrationRejectReason (OOCTXT* pctxt, H225RegistrationRejectReason* pvalue); + +/**************************************************************/ +/* */ +/* RegistrationReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RegistrationReject { + struct { + unsigned nonStandardDataPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned altGKInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ProtocolIdentifier protocolIdentifier; + H225NonStandardParameter nonStandardData; + H225RegistrationRejectReason rejectReason; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225AltGKInfo altGKInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225RegistrationReject; + +EXTERN int asn1PE_H225RegistrationReject (OOCTXT* pctxt, H225RegistrationReject* pvalue); + +EXTERN int asn1PD_H225RegistrationReject (OOCTXT* pctxt, H225RegistrationReject* pvalue); + +/**************************************************************/ +/* */ +/* UnregRequestReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225UnregRequestReason_reregistrationRequired 1 +#define T_H225UnregRequestReason_ttlExpired 2 +#define T_H225UnregRequestReason_securityDenial 3 +#define T_H225UnregRequestReason_undefinedReason 4 +#define T_H225UnregRequestReason_maintenance 5 +#define T_H225UnregRequestReason_securityError 6 +#define T_H225UnregRequestReason_extElem1 7 + +typedef struct EXTERN H225UnregRequestReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + H225SecurityErrors2 *securityError; + /* t = 7 */ + } u; +} H225UnregRequestReason; + +EXTERN int asn1PE_H225UnregRequestReason (OOCTXT* pctxt, H225UnregRequestReason* pvalue); + +EXTERN int asn1PD_H225UnregRequestReason (OOCTXT* pctxt, H225UnregRequestReason* pvalue); + +/**************************************************************/ +/* */ +/* UnregistrationRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225UnregistrationRequest { + struct { + unsigned endpointAliasPresent : 1; + unsigned nonStandardDataPresent : 1; + unsigned endpointIdentifierPresent : 1; + unsigned alternateEndpointsPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned reasonPresent : 1; + unsigned endpointAliasPatternPresent : 1; + unsigned supportedPrefixesPresent : 1; + unsigned alternateGatekeeperPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225_SeqOfH225TransportAddress callSignalAddress; + H225_SeqOfH225AliasAddress endpointAlias; + H225NonStandardParameter nonStandardData; + H225EndpointIdentifier endpointIdentifier; + H225_SeqOfH225Endpoint alternateEndpoints; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225UnregRequestReason reason; + H225_SeqOfH225AddressPattern endpointAliasPattern; + H225_SeqOfH225SupportedPrefix supportedPrefixes; + H225_SeqOfH225AlternateGK alternateGatekeeper; + H225_SeqOfH225GenericData genericData; +} H225UnregistrationRequest; + +EXTERN int asn1PE_H225UnregistrationRequest (OOCTXT* pctxt, H225UnregistrationRequest* pvalue); + +EXTERN int asn1PD_H225UnregistrationRequest (OOCTXT* pctxt, H225UnregistrationRequest* pvalue); + +/**************************************************************/ +/* */ +/* UnregistrationConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225UnregistrationConfirm { + struct { + unsigned nonStandardDataPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225_SeqOfH225GenericData genericData; +} H225UnregistrationConfirm; + +EXTERN int asn1PE_H225UnregistrationConfirm (OOCTXT* pctxt, H225UnregistrationConfirm* pvalue); + +EXTERN int asn1PD_H225UnregistrationConfirm (OOCTXT* pctxt, H225UnregistrationConfirm* pvalue); + +/**************************************************************/ +/* */ +/* UnregRejectReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225UnregRejectReason_notCurrentlyRegistered 1 +#define T_H225UnregRejectReason_callInProgress 2 +#define T_H225UnregRejectReason_undefinedReason 3 +#define T_H225UnregRejectReason_permissionDenied 4 +#define T_H225UnregRejectReason_securityDenial 5 +#define T_H225UnregRejectReason_securityError 6 +#define T_H225UnregRejectReason_extElem1 7 + +typedef struct EXTERN H225UnregRejectReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + H225SecurityErrors2 *securityError; + /* t = 7 */ + } u; +} H225UnregRejectReason; + +EXTERN int asn1PE_H225UnregRejectReason (OOCTXT* pctxt, H225UnregRejectReason* pvalue); + +EXTERN int asn1PD_H225UnregRejectReason (OOCTXT* pctxt, H225UnregRejectReason* pvalue); + +/**************************************************************/ +/* */ +/* UnregistrationReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225UnregistrationReject { + struct { + unsigned nonStandardDataPresent : 1; + unsigned altGKInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225UnregRejectReason rejectReason; + H225NonStandardParameter nonStandardData; + H225AltGKInfo altGKInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225_SeqOfH225GenericData genericData; +} H225UnregistrationReject; + +EXTERN int asn1PE_H225UnregistrationReject (OOCTXT* pctxt, H225UnregistrationReject* pvalue); + +EXTERN int asn1PD_H225UnregistrationReject (OOCTXT* pctxt, H225UnregistrationReject* pvalue); + +/**************************************************************/ +/* */ +/* CallModel */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225CallModel_direct 1 +#define T_H225CallModel_gatekeeperRouted 2 +#define T_H225CallModel_extElem1 3 + +typedef struct EXTERN H225CallModel { + int t; +} H225CallModel; + +EXTERN int asn1PE_H225CallModel (OOCTXT* pctxt, H225CallModel* pvalue); + +EXTERN int asn1PD_H225CallModel (OOCTXT* pctxt, H225CallModel* pvalue); + +/**************************************************************/ +/* */ +/* TransportQOS */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225TransportQOS_endpointControlled 1 +#define T_H225TransportQOS_gatekeeperControlled 2 +#define T_H225TransportQOS_noControl 3 +#define T_H225TransportQOS_extElem1 4 + +typedef struct EXTERN H225TransportQOS { + int t; +} H225TransportQOS; + +EXTERN int asn1PE_H225TransportQOS (OOCTXT* pctxt, H225TransportQOS* pvalue); + +EXTERN int asn1PD_H225TransportQOS (OOCTXT* pctxt, H225TransportQOS* pvalue); + +/**************************************************************/ +/* */ +/* AdmissionRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225AdmissionRequest { + struct { + unsigned callModelPresent : 1; + unsigned destinationInfoPresent : 1; + unsigned destCallSignalAddressPresent : 1; + unsigned destExtraCallInfoPresent : 1; + unsigned srcCallSignalAddressPresent : 1; + unsigned nonStandardDataPresent : 1; + unsigned callServicesPresent : 1; + unsigned canMapAliasPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned srcAlternativesPresent : 1; + unsigned destAlternativesPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned transportQOSPresent : 1; + unsigned willSupplyUUIEsPresent : 1; + unsigned callLinkagePresent : 1; + unsigned gatewayDataRatePresent : 1; + unsigned capacityPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned desiredProtocolsPresent : 1; + unsigned desiredTunnelledProtocolPresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + unsigned canMapSrcAliasPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225CallType callType; + H225CallModel callModel; + H225EndpointIdentifier endpointIdentifier; + H225_SeqOfH225AliasAddress destinationInfo; + H225TransportAddress destCallSignalAddress; + H225_SeqOfH225AliasAddress destExtraCallInfo; + H225_SeqOfH225AliasAddress srcInfo; + H225TransportAddress srcCallSignalAddress; + H225BandWidth bandWidth; + H225CallReferenceValue callReferenceValue; + H225NonStandardParameter nonStandardData; + H225QseriesOptions callServices; + H225ConferenceIdentifier conferenceID; + ASN1BOOL activeMC; + ASN1BOOL answerCall; + ASN1BOOL canMapAlias; + H225CallIdentifier callIdentifier; + H225_SeqOfH225Endpoint srcAlternatives; + H225_SeqOfH225Endpoint destAlternatives; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225TransportQOS transportQOS; + ASN1BOOL willSupplyUUIEs; + H225CallLinkage callLinkage; + H225DataRate gatewayDataRate; + H225CallCapacity capacity; + H225CircuitInfo circuitInfo; + H225_SeqOfH225SupportedProtocols desiredProtocols; + H225TunnelledProtocol desiredTunnelledProtocol; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; + ASN1BOOL canMapSrcAlias; +} H225AdmissionRequest; + +EXTERN int asn1PE_H225AdmissionRequest (OOCTXT* pctxt, H225AdmissionRequest* pvalue); + +EXTERN int asn1PD_H225AdmissionRequest (OOCTXT* pctxt, H225AdmissionRequest* pvalue); + +/**************************************************************/ +/* */ +/* UUIEsRequested */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225UUIEsRequested { + struct { + unsigned statusPresent : 1; + unsigned statusInquiryPresent : 1; + unsigned setupAcknowledgePresent : 1; + unsigned notifyPresent : 1; + } m; + ASN1BOOL setup; + ASN1BOOL callProceeding; + ASN1BOOL connect; + ASN1BOOL alerting; + ASN1BOOL information; + ASN1BOOL releaseComplete; + ASN1BOOL facility; + ASN1BOOL progress; + ASN1BOOL empty; + ASN1BOOL status; + ASN1BOOL statusInquiry; + ASN1BOOL setupAcknowledge; + ASN1BOOL notify; +} H225UUIEsRequested; + +EXTERN int asn1PE_H225UUIEsRequested (OOCTXT* pctxt, H225UUIEsRequested* pvalue); + +EXTERN int asn1PD_H225UUIEsRequested (OOCTXT* pctxt, H225UUIEsRequested* pvalue); + +/**************************************************************/ +/* */ +/* AdmissionConfirm_language */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225AdmissionConfirm_language { + ASN1UINT n; + ASN1IA5String *elem; +} H225AdmissionConfirm_language; + +EXTERN int asn1PE_H225AdmissionConfirm_language (OOCTXT* pctxt, H225AdmissionConfirm_language* pvalue); + +EXTERN int asn1PD_H225AdmissionConfirm_language (OOCTXT* pctxt, H225AdmissionConfirm_language* pvalue); + +/**************************************************************/ +/* */ +/* AdmissionConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225AdmissionConfirm { + struct { + unsigned irrFrequencyPresent : 1; + unsigned nonStandardDataPresent : 1; + unsigned destinationInfoPresent : 1; + unsigned destExtraCallInfoPresent : 1; + unsigned destinationTypePresent : 1; + unsigned remoteExtensionAddressPresent : 1; + unsigned alternateEndpointsPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned transportQOSPresent : 1; + unsigned willRespondToIRRPresent : 1; + unsigned uuiesRequestedPresent : 1; + unsigned languagePresent : 1; + unsigned alternateTransportAddressesPresent : 1; + unsigned useSpecifiedTransportPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned usageSpecPresent : 1; + unsigned supportedProtocolsPresent : 1; + unsigned serviceControlPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + unsigned modifiedSrcInfoPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225BandWidth bandWidth; + H225CallModel callModel; + H225TransportAddress destCallSignalAddress; + ASN1USINT irrFrequency; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225AliasAddress destinationInfo; + H225_SeqOfH225AliasAddress destExtraCallInfo; + H225EndpointType destinationType; + H225_SeqOfH225AliasAddress remoteExtensionAddress; + H225_SeqOfH225Endpoint alternateEndpoints; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225TransportQOS transportQOS; + ASN1BOOL willRespondToIRR; + H225UUIEsRequested uuiesRequested; + H225AdmissionConfirm_language language; + H225AlternateTransportAddresses alternateTransportAddresses; + H225UseSpecifiedTransport useSpecifiedTransport; + H225CircuitInfo circuitInfo; + H225_SeqOfH225RasUsageSpecification usageSpec; + H225_SeqOfH225SupportedProtocols supportedProtocols; + H225_SeqOfH225ServiceControlSession serviceControl; + ASN1BOOL multipleCalls; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; + H225_SeqOfH225AliasAddress modifiedSrcInfo; +} H225AdmissionConfirm; + +EXTERN int asn1PE_H225AdmissionConfirm (OOCTXT* pctxt, H225AdmissionConfirm* pvalue); + +EXTERN int asn1PD_H225AdmissionConfirm (OOCTXT* pctxt, H225AdmissionConfirm* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225PartyNumber */ +/* */ +/**************************************************************/ + +/* List of H225PartyNumber */ +typedef DList H225_SeqOfH225PartyNumber; + +EXTERN int asn1PE_H225_SeqOfH225PartyNumber (OOCTXT* pctxt, H225_SeqOfH225PartyNumber* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225PartyNumber (OOCTXT* pctxt, H225_SeqOfH225PartyNumber* pvalue); + +/**************************************************************/ +/* */ +/* AdmissionRejectReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225AdmissionRejectReason_calledPartyNotRegistered 1 +#define T_H225AdmissionRejectReason_invalidPermission 2 +#define T_H225AdmissionRejectReason_requestDenied 3 +#define T_H225AdmissionRejectReason_undefinedReason 4 +#define T_H225AdmissionRejectReason_callerNotRegistered 5 +#define T_H225AdmissionRejectReason_routeCallToGatekeeper 6 +#define T_H225AdmissionRejectReason_invalidEndpointIdentifier 7 +#define T_H225AdmissionRejectReason_resourceUnavailable 8 +#define T_H225AdmissionRejectReason_securityDenial 9 +#define T_H225AdmissionRejectReason_qosControlNotSupported 10 +#define T_H225AdmissionRejectReason_incompleteAddress 11 +#define T_H225AdmissionRejectReason_aliasesInconsistent 12 +#define T_H225AdmissionRejectReason_routeCallToSCN 13 +#define T_H225AdmissionRejectReason_exceedsCallCapacity 14 +#define T_H225AdmissionRejectReason_collectDestination 15 +#define T_H225AdmissionRejectReason_collectPIN 16 +#define T_H225AdmissionRejectReason_genericDataReason 17 +#define T_H225AdmissionRejectReason_neededFeatureNotSupported 18 +#define T_H225AdmissionRejectReason_securityErrors 19 +#define T_H225AdmissionRejectReason_securityDHmismatch 20 +#define T_H225AdmissionRejectReason_noRouteToDestination 21 +#define T_H225AdmissionRejectReason_unallocatedNumber 22 +#define T_H225AdmissionRejectReason_extElem1 23 + +typedef struct EXTERN H225AdmissionRejectReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + /* t = 9 */ + /* t = 10 */ + /* t = 11 */ + /* t = 12 */ + /* t = 13 */ + H225_SeqOfH225PartyNumber *routeCallToSCN; + /* t = 14 */ + /* t = 15 */ + /* t = 16 */ + /* t = 17 */ + /* t = 18 */ + /* t = 19 */ + H225SecurityErrors2 *securityErrors; + /* t = 20 */ + /* t = 21 */ + /* t = 22 */ + /* t = 23 */ + } u; +} H225AdmissionRejectReason; + +EXTERN int asn1PE_H225AdmissionRejectReason (OOCTXT* pctxt, H225AdmissionRejectReason* pvalue); + +EXTERN int asn1PD_H225AdmissionRejectReason (OOCTXT* pctxt, H225AdmissionRejectReason* pvalue); + +/**************************************************************/ +/* */ +/* AdmissionReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225AdmissionReject { + struct { + unsigned nonStandardDataPresent : 1; + unsigned altGKInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned callSignalAddressPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned serviceControlPresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225AdmissionRejectReason rejectReason; + H225NonStandardParameter nonStandardData; + H225AltGKInfo altGKInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225_SeqOfH225TransportAddress callSignalAddress; + H225ICV integrityCheckValue; + H225_SeqOfH225ServiceControlSession serviceControl; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225AdmissionReject; + +EXTERN int asn1PE_H225AdmissionReject (OOCTXT* pctxt, H225AdmissionReject* pvalue); + +EXTERN int asn1PD_H225AdmissionReject (OOCTXT* pctxt, H225AdmissionReject* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225BandwidthDetails */ +/* */ +/**************************************************************/ + +/* List of H225BandwidthDetails */ +typedef DList H225_SeqOfH225BandwidthDetails; + +EXTERN int asn1PE_H225_SeqOfH225BandwidthDetails (OOCTXT* pctxt, H225_SeqOfH225BandwidthDetails* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225BandwidthDetails (OOCTXT* pctxt, H225_SeqOfH225BandwidthDetails* pvalue); + +/**************************************************************/ +/* */ +/* BandwidthRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225BandwidthRequest { + struct { + unsigned callTypePresent : 1; + unsigned nonStandardDataPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned answeredCallPresent : 1; + unsigned callLinkagePresent : 1; + unsigned capacityPresent : 1; + unsigned usageInformationPresent : 1; + unsigned bandwidthDetailsPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225EndpointIdentifier endpointIdentifier; + H225ConferenceIdentifier conferenceID; + H225CallReferenceValue callReferenceValue; + H225CallType callType; + H225BandWidth bandWidth; + H225NonStandardParameter nonStandardData; + H225CallIdentifier callIdentifier; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + ASN1BOOL answeredCall; + H225CallLinkage callLinkage; + H225CallCapacity capacity; + H225RasUsageInformation usageInformation; + H225_SeqOfH225BandwidthDetails bandwidthDetails; + H225_SeqOfH225GenericData genericData; +} H225BandwidthRequest; + +EXTERN int asn1PE_H225BandwidthRequest (OOCTXT* pctxt, H225BandwidthRequest* pvalue); + +EXTERN int asn1PD_H225BandwidthRequest (OOCTXT* pctxt, H225BandwidthRequest* pvalue); + +/**************************************************************/ +/* */ +/* BandwidthConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225BandwidthConfirm { + struct { + unsigned nonStandardDataPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned capacityPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225BandWidth bandWidth; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225CallCapacity capacity; + H225_SeqOfH225GenericData genericData; +} H225BandwidthConfirm; + +EXTERN int asn1PE_H225BandwidthConfirm (OOCTXT* pctxt, H225BandwidthConfirm* pvalue); + +EXTERN int asn1PD_H225BandwidthConfirm (OOCTXT* pctxt, H225BandwidthConfirm* pvalue); + +/**************************************************************/ +/* */ +/* BandRejectReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225BandRejectReason_notBound 1 +#define T_H225BandRejectReason_invalidConferenceID 2 +#define T_H225BandRejectReason_invalidPermission 3 +#define T_H225BandRejectReason_insufficientResources 4 +#define T_H225BandRejectReason_invalidRevision 5 +#define T_H225BandRejectReason_undefinedReason 6 +#define T_H225BandRejectReason_securityDenial 7 +#define T_H225BandRejectReason_securityError 8 +#define T_H225BandRejectReason_extElem1 9 + +typedef struct EXTERN H225BandRejectReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + H225SecurityErrors2 *securityError; + /* t = 9 */ + } u; +} H225BandRejectReason; + +EXTERN int asn1PE_H225BandRejectReason (OOCTXT* pctxt, H225BandRejectReason* pvalue); + +EXTERN int asn1PD_H225BandRejectReason (OOCTXT* pctxt, H225BandRejectReason* pvalue); + +/**************************************************************/ +/* */ +/* BandwidthReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225BandwidthReject { + struct { + unsigned nonStandardDataPresent : 1; + unsigned altGKInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225BandRejectReason rejectReason; + H225BandWidth allowedBandWidth; + H225NonStandardParameter nonStandardData; + H225AltGKInfo altGKInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225_SeqOfH225GenericData genericData; +} H225BandwidthReject; + +EXTERN int asn1PE_H225BandwidthReject (OOCTXT* pctxt, H225BandwidthReject* pvalue); + +EXTERN int asn1PD_H225BandwidthReject (OOCTXT* pctxt, H225BandwidthReject* pvalue); + +/**************************************************************/ +/* */ +/* DisengageReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225DisengageReason_forcedDrop 1 +#define T_H225DisengageReason_normalDrop 2 +#define T_H225DisengageReason_undefinedReason 3 +#define T_H225DisengageReason_extElem1 4 + +typedef struct EXTERN H225DisengageReason { + int t; +} H225DisengageReason; + +EXTERN int asn1PE_H225DisengageReason (OOCTXT* pctxt, H225DisengageReason* pvalue); + +EXTERN int asn1PD_H225DisengageReason (OOCTXT* pctxt, H225DisengageReason* pvalue); + +/**************************************************************/ +/* */ +/* DisengageRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225DisengageRequest { + struct { + unsigned nonStandardDataPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned answeredCallPresent : 1; + unsigned callLinkagePresent : 1; + unsigned capacityPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned usageInformationPresent : 1; + unsigned terminationCausePresent : 1; + unsigned serviceControlPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225EndpointIdentifier endpointIdentifier; + H225ConferenceIdentifier conferenceID; + H225CallReferenceValue callReferenceValue; + H225DisengageReason disengageReason; + H225NonStandardParameter nonStandardData; + H225CallIdentifier callIdentifier; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + ASN1BOOL answeredCall; + H225CallLinkage callLinkage; + H225CallCapacity capacity; + H225CircuitInfo circuitInfo; + H225RasUsageInformation usageInformation; + H225CallTerminationCause terminationCause; + H225_SeqOfH225ServiceControlSession serviceControl; + H225_SeqOfH225GenericData genericData; +} H225DisengageRequest; + +EXTERN int asn1PE_H225DisengageRequest (OOCTXT* pctxt, H225DisengageRequest* pvalue); + +EXTERN int asn1PD_H225DisengageRequest (OOCTXT* pctxt, H225DisengageRequest* pvalue); + +/**************************************************************/ +/* */ +/* DisengageConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225DisengageConfirm { + struct { + unsigned nonStandardDataPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned capacityPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned usageInformationPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225CallCapacity capacity; + H225CircuitInfo circuitInfo; + H225RasUsageInformation usageInformation; + H225_SeqOfH225GenericData genericData; +} H225DisengageConfirm; + +EXTERN int asn1PE_H225DisengageConfirm (OOCTXT* pctxt, H225DisengageConfirm* pvalue); + +EXTERN int asn1PD_H225DisengageConfirm (OOCTXT* pctxt, H225DisengageConfirm* pvalue); + +/**************************************************************/ +/* */ +/* DisengageRejectReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225DisengageRejectReason_notRegistered 1 +#define T_H225DisengageRejectReason_requestToDropOther 2 +#define T_H225DisengageRejectReason_securityDenial 3 +#define T_H225DisengageRejectReason_securityError 4 +#define T_H225DisengageRejectReason_extElem1 5 + +typedef struct EXTERN H225DisengageRejectReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + H225SecurityErrors2 *securityError; + /* t = 5 */ + } u; +} H225DisengageRejectReason; + +EXTERN int asn1PE_H225DisengageRejectReason (OOCTXT* pctxt, H225DisengageRejectReason* pvalue); + +EXTERN int asn1PD_H225DisengageRejectReason (OOCTXT* pctxt, H225DisengageRejectReason* pvalue); + +/**************************************************************/ +/* */ +/* DisengageReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225DisengageReject { + struct { + unsigned nonStandardDataPresent : 1; + unsigned altGKInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225DisengageRejectReason rejectReason; + H225NonStandardParameter nonStandardData; + H225AltGKInfo altGKInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225_SeqOfH225GenericData genericData; +} H225DisengageReject; + +EXTERN int asn1PE_H225DisengageReject (OOCTXT* pctxt, H225DisengageReject* pvalue); + +EXTERN int asn1PD_H225DisengageReject (OOCTXT* pctxt, H225DisengageReject* pvalue); + +/**************************************************************/ +/* */ +/* LocationRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225LocationRequest { + struct { + unsigned endpointIdentifierPresent : 1; + unsigned nonStandardDataPresent : 1; + unsigned sourceInfoPresent : 1; + unsigned canMapAliasPresent : 1; + unsigned gatekeeperIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned desiredProtocolsPresent : 1; + unsigned desiredTunnelledProtocolPresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + unsigned hopCountPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned bandWidthPresent : 1; + unsigned sourceEndpointInfoPresent : 1; + unsigned canMapSrcAliasPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225EndpointIdentifier endpointIdentifier; + H225_SeqOfH225AliasAddress destinationInfo; + H225NonStandardParameter nonStandardData; + H225TransportAddress replyAddress; + H225_SeqOfH225AliasAddress sourceInfo; + ASN1BOOL canMapAlias; + H225GatekeeperIdentifier gatekeeperIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225_SeqOfH225SupportedProtocols desiredProtocols; + H225TunnelledProtocol desiredTunnelledProtocol; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; + ASN1UINT8 hopCount; + H225CircuitInfo circuitInfo; + H225CallIdentifier callIdentifier; + H225BandWidth bandWidth; + H225_SeqOfH225AliasAddress sourceEndpointInfo; + ASN1BOOL canMapSrcAlias; +} H225LocationRequest; + +EXTERN int asn1PE_H225LocationRequest (OOCTXT* pctxt, H225LocationRequest* pvalue); + +EXTERN int asn1PD_H225LocationRequest (OOCTXT* pctxt, H225LocationRequest* pvalue); + +/**************************************************************/ +/* */ +/* LocationConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225LocationConfirm { + struct { + unsigned nonStandardDataPresent : 1; + unsigned destinationInfoPresent : 1; + unsigned destExtraCallInfoPresent : 1; + unsigned destinationTypePresent : 1; + unsigned remoteExtensionAddressPresent : 1; + unsigned alternateEndpointsPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned alternateTransportAddressesPresent : 1; + unsigned supportedProtocolsPresent : 1; + unsigned multipleCallsPresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + unsigned circuitInfoPresent : 1; + unsigned serviceControlPresent : 1; + unsigned modifiedSrcInfoPresent : 1; + unsigned bandWidthPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225TransportAddress callSignalAddress; + H225TransportAddress rasAddress; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225AliasAddress destinationInfo; + H225_SeqOfH225AliasAddress destExtraCallInfo; + H225EndpointType destinationType; + H225_SeqOfH225AliasAddress remoteExtensionAddress; + H225_SeqOfH225Endpoint alternateEndpoints; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225AlternateTransportAddresses alternateTransportAddresses; + H225_SeqOfH225SupportedProtocols supportedProtocols; + ASN1BOOL multipleCalls; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; + H225CircuitInfo circuitInfo; + H225_SeqOfH225ServiceControlSession serviceControl; + H225_SeqOfH225AliasAddress modifiedSrcInfo; + H225BandWidth bandWidth; +} H225LocationConfirm; + +EXTERN int asn1PE_H225LocationConfirm (OOCTXT* pctxt, H225LocationConfirm* pvalue); + +EXTERN int asn1PD_H225LocationConfirm (OOCTXT* pctxt, H225LocationConfirm* pvalue); + +/**************************************************************/ +/* */ +/* LocationRejectReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225LocationRejectReason_notRegistered 1 +#define T_H225LocationRejectReason_invalidPermission 2 +#define T_H225LocationRejectReason_requestDenied 3 +#define T_H225LocationRejectReason_undefinedReason 4 +#define T_H225LocationRejectReason_securityDenial 5 +#define T_H225LocationRejectReason_aliasesInconsistent 6 +#define T_H225LocationRejectReason_routeCalltoSCN 7 +#define T_H225LocationRejectReason_resourceUnavailable 8 +#define T_H225LocationRejectReason_genericDataReason 9 +#define T_H225LocationRejectReason_neededFeatureNotSupported 10 +#define T_H225LocationRejectReason_hopCountExceeded 11 +#define T_H225LocationRejectReason_incompleteAddress 12 +#define T_H225LocationRejectReason_securityError 13 +#define T_H225LocationRejectReason_securityDHmismatch 14 +#define T_H225LocationRejectReason_noRouteToDestination 15 +#define T_H225LocationRejectReason_unallocatedNumber 16 +#define T_H225LocationRejectReason_extElem1 17 + +typedef struct EXTERN H225LocationRejectReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + H225_SeqOfH225PartyNumber *routeCalltoSCN; + /* t = 8 */ + /* t = 9 */ + /* t = 10 */ + /* t = 11 */ + /* t = 12 */ + /* t = 13 */ + H225SecurityErrors2 *securityError; + /* t = 14 */ + /* t = 15 */ + /* t = 16 */ + /* t = 17 */ + } u; +} H225LocationRejectReason; + +EXTERN int asn1PE_H225LocationRejectReason (OOCTXT* pctxt, H225LocationRejectReason* pvalue); + +EXTERN int asn1PD_H225LocationRejectReason (OOCTXT* pctxt, H225LocationRejectReason* pvalue); + +/**************************************************************/ +/* */ +/* LocationReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225LocationReject { + struct { + unsigned nonStandardDataPresent : 1; + unsigned altGKInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + unsigned serviceControlPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225LocationRejectReason rejectReason; + H225NonStandardParameter nonStandardData; + H225AltGKInfo altGKInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; + H225_SeqOfH225ServiceControlSession serviceControl; +} H225LocationReject; + +EXTERN int asn1PE_H225LocationReject (OOCTXT* pctxt, H225LocationReject* pvalue); + +EXTERN int asn1PD_H225LocationReject (OOCTXT* pctxt, H225LocationReject* pvalue); + +/**************************************************************/ +/* */ +/* InfoRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225InfoRequest { + struct { + unsigned nonStandardDataPresent : 1; + unsigned replyAddressPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned uuiesRequestedPresent : 1; + unsigned callLinkagePresent : 1; + unsigned usageInfoRequestedPresent : 1; + unsigned segmentedResponseSupportedPresent : 1; + unsigned nextSegmentRequestedPresent : 1; + unsigned capacityInfoRequestedPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225CallReferenceValue callReferenceValue; + H225NonStandardParameter nonStandardData; + H225TransportAddress replyAddress; + H225CallIdentifier callIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225UUIEsRequested uuiesRequested; + H225CallLinkage callLinkage; + H225RasUsageInfoTypes usageInfoRequested; + ASN1USINT nextSegmentRequested; + H225_SeqOfH225GenericData genericData; +} H225InfoRequest; + +EXTERN int asn1PE_H225InfoRequest (OOCTXT* pctxt, H225InfoRequest* pvalue); + +EXTERN int asn1PD_H225InfoRequest (OOCTXT* pctxt, H225InfoRequest* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225RTPSession */ +/* */ +/**************************************************************/ + +/* List of H225RTPSession */ +typedef DList H225_SeqOfH225RTPSession; + +EXTERN int asn1PE_H225_SeqOfH225RTPSession (OOCTXT* pctxt, H225_SeqOfH225RTPSession* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225RTPSession (OOCTXT* pctxt, H225_SeqOfH225RTPSession* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225TransportChannelInfo */ +/* */ +/**************************************************************/ + +/* List of H225TransportChannelInfo */ +typedef DList H225_SeqOfH225TransportChannelInfo; + +EXTERN int asn1PE_H225_SeqOfH225TransportChannelInfo (OOCTXT* pctxt, H225_SeqOfH225TransportChannelInfo* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225TransportChannelInfo (OOCTXT* pctxt, H225_SeqOfH225TransportChannelInfo* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225ConferenceIdentifier */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225_SeqOfH225ConferenceIdentifier { + ASN1UINT n; + H225ConferenceIdentifier *elem; +} H225_SeqOfH225ConferenceIdentifier; + +EXTERN int asn1PE_H225_SeqOfH225ConferenceIdentifier (OOCTXT* pctxt, H225_SeqOfH225ConferenceIdentifier* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225ConferenceIdentifier (OOCTXT* pctxt, H225_SeqOfH225ConferenceIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* InfoRequestResponse_perCallInfo_element_pdu_element */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225InfoRequestResponse_perCallInfo_element_pdu_element { + H225H323_UU_PDU h323pdu; + ASN1BOOL sent; +} H225InfoRequestResponse_perCallInfo_element_pdu_element; + +EXTERN int asn1PE_H225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue); + +EXTERN int asn1PD_H225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_el */ +/* */ +/**************************************************************/ + +/* List of H225InfoRequestResponse_perCallInfo_element_pdu_element */ +typedef DList H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element; + +EXTERN int asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue); + +/**************************************************************/ +/* */ +/* InfoRequestResponse_perCallInfo_element */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225InfoRequestResponse_perCallInfo_element { + struct { + unsigned nonStandardDataPresent : 1; + unsigned originatorPresent : 1; + unsigned audioPresent : 1; + unsigned videoPresent : 1; + unsigned dataPresent : 1; + unsigned callIdentifierPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned substituteConfIDsPresent : 1; + unsigned pduPresent : 1; + unsigned callLinkagePresent : 1; + unsigned usageInformationPresent : 1; + unsigned circuitInfoPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225CallReferenceValue callReferenceValue; + H225ConferenceIdentifier conferenceID; + ASN1BOOL originator; + H225_SeqOfH225RTPSession audio; + H225_SeqOfH225RTPSession video; + H225_SeqOfH225TransportChannelInfo data; + H225TransportChannelInfo h245; + H225TransportChannelInfo callSignaling; + H225CallType callType; + H225BandWidth bandWidth; + H225CallModel callModel; + H225CallIdentifier callIdentifier; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225_SeqOfH225ConferenceIdentifier substituteConfIDs; + H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element pdu; + H225CallLinkage callLinkage; + H225RasUsageInformation usageInformation; + H225CircuitInfo circuitInfo; +} H225InfoRequestResponse_perCallInfo_element; + +EXTERN int asn1PE_H225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element* pvalue); + +EXTERN int asn1PD_H225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225InfoRequestResponse_perCallInfo_element */ +/* */ +/**************************************************************/ + +/* List of H225InfoRequestResponse_perCallInfo_element */ +typedef DList H225_SeqOfH225InfoRequestResponse_perCallInfo_element; + +EXTERN int asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element* pvalue); + +/**************************************************************/ +/* */ +/* InfoRequestResponseStatus */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225InfoRequestResponseStatus_complete 1 +#define T_H225InfoRequestResponseStatus_incomplete 2 +#define T_H225InfoRequestResponseStatus_segment 3 +#define T_H225InfoRequestResponseStatus_invalidCall 4 +#define T_H225InfoRequestResponseStatus_extElem1 5 + +typedef struct EXTERN H225InfoRequestResponseStatus { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + ASN1USINT segment; + /* t = 4 */ + /* t = 5 */ + } u; +} H225InfoRequestResponseStatus; + +EXTERN int asn1PE_H225InfoRequestResponseStatus (OOCTXT* pctxt, H225InfoRequestResponseStatus* pvalue); + +EXTERN int asn1PD_H225InfoRequestResponseStatus (OOCTXT* pctxt, H225InfoRequestResponseStatus* pvalue); + +/**************************************************************/ +/* */ +/* InfoRequestResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225InfoRequestResponse { + struct { + unsigned nonStandardDataPresent : 1; + unsigned endpointAliasPresent : 1; + unsigned perCallInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned needResponsePresent : 1; + unsigned capacityPresent : 1; + unsigned irrStatusPresent : 1; + unsigned unsolicitedPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225NonStandardParameter nonStandardData; + H225RequestSeqNum requestSeqNum; + H225EndpointType endpointType; + H225EndpointIdentifier endpointIdentifier; + H225TransportAddress rasAddress; + H225_SeqOfH225TransportAddress callSignalAddress; + H225_SeqOfH225AliasAddress endpointAlias; + H225_SeqOfH225InfoRequestResponse_perCallInfo_element perCallInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + ASN1BOOL needResponse; + H225CallCapacity capacity; + H225InfoRequestResponseStatus irrStatus; + ASN1BOOL unsolicited; + H225_SeqOfH225GenericData genericData; +} H225InfoRequestResponse; + +EXTERN int asn1PE_H225InfoRequestResponse (OOCTXT* pctxt, H225InfoRequestResponse* pvalue); + +EXTERN int asn1PD_H225InfoRequestResponse (OOCTXT* pctxt, H225InfoRequestResponse* pvalue); + +/**************************************************************/ +/* */ +/* NonStandardMessage */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225NonStandardMessage { + struct { + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225NonStandardMessage; + +EXTERN int asn1PE_H225NonStandardMessage (OOCTXT* pctxt, H225NonStandardMessage* pvalue); + +EXTERN int asn1PD_H225NonStandardMessage (OOCTXT* pctxt, H225NonStandardMessage* pvalue); + +/**************************************************************/ +/* */ +/* UnknownMessageResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225UnknownMessageResponse { + struct { + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned messageNotUnderstoodPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + ASN1DynOctStr messageNotUnderstood; +} H225UnknownMessageResponse; + +EXTERN int asn1PE_H225UnknownMessageResponse (OOCTXT* pctxt, H225UnknownMessageResponse* pvalue); + +EXTERN int asn1PD_H225UnknownMessageResponse (OOCTXT* pctxt, H225UnknownMessageResponse* pvalue); + +/**************************************************************/ +/* */ +/* RequestInProgress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225RequestInProgress { + struct { + unsigned nonStandardDataPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + ASN1USINT delay; +} H225RequestInProgress; + +EXTERN int asn1PE_H225RequestInProgress (OOCTXT* pctxt, H225RequestInProgress* pvalue); + +EXTERN int asn1PD_H225RequestInProgress (OOCTXT* pctxt, H225RequestInProgress* pvalue); + +/**************************************************************/ +/* */ +/* ResourcesAvailableIndicate */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ResourcesAvailableIndicate { + struct { + unsigned nonStandardDataPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned capacityPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ProtocolIdentifier protocolIdentifier; + H225NonStandardParameter nonStandardData; + H225EndpointIdentifier endpointIdentifier; + H225_SeqOfH225SupportedProtocols protocols; + ASN1BOOL almostOutOfResources; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225CallCapacity capacity; + H225_SeqOfH225GenericData genericData; +} H225ResourcesAvailableIndicate; + +EXTERN int asn1PE_H225ResourcesAvailableIndicate (OOCTXT* pctxt, H225ResourcesAvailableIndicate* pvalue); + +EXTERN int asn1PD_H225ResourcesAvailableIndicate (OOCTXT* pctxt, H225ResourcesAvailableIndicate* pvalue); + +/**************************************************************/ +/* */ +/* ResourcesAvailableConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ResourcesAvailableConfirm { + struct { + unsigned nonStandardDataPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ProtocolIdentifier protocolIdentifier; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225_SeqOfH225GenericData genericData; +} H225ResourcesAvailableConfirm; + +EXTERN int asn1PE_H225ResourcesAvailableConfirm (OOCTXT* pctxt, H225ResourcesAvailableConfirm* pvalue); + +EXTERN int asn1PD_H225ResourcesAvailableConfirm (OOCTXT* pctxt, H225ResourcesAvailableConfirm* pvalue); + +/**************************************************************/ +/* */ +/* InfoRequestAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225InfoRequestAck { + struct { + unsigned nonStandardDataPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; +} H225InfoRequestAck; + +EXTERN int asn1PE_H225InfoRequestAck (OOCTXT* pctxt, H225InfoRequestAck* pvalue); + +EXTERN int asn1PD_H225InfoRequestAck (OOCTXT* pctxt, H225InfoRequestAck* pvalue); + +/**************************************************************/ +/* */ +/* InfoRequestNakReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225InfoRequestNakReason_notRegistered 1 +#define T_H225InfoRequestNakReason_securityDenial 2 +#define T_H225InfoRequestNakReason_undefinedReason 3 +#define T_H225InfoRequestNakReason_securityError 4 +#define T_H225InfoRequestNakReason_extElem1 5 + +typedef struct EXTERN H225InfoRequestNakReason { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + H225SecurityErrors2 *securityError; + /* t = 5 */ + } u; +} H225InfoRequestNakReason; + +EXTERN int asn1PE_H225InfoRequestNakReason (OOCTXT* pctxt, H225InfoRequestNakReason* pvalue); + +EXTERN int asn1PD_H225InfoRequestNakReason (OOCTXT* pctxt, H225InfoRequestNakReason* pvalue); + +/**************************************************************/ +/* */ +/* InfoRequestNak */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225InfoRequestNak { + struct { + unsigned nonStandardDataPresent : 1; + unsigned altGKInfoPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225NonStandardParameter nonStandardData; + H225InfoRequestNakReason nakReason; + H225AltGKInfo altGKInfo; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; +} H225InfoRequestNak; + +EXTERN int asn1PE_H225InfoRequestNak (OOCTXT* pctxt, H225InfoRequestNak* pvalue); + +EXTERN int asn1PD_H225InfoRequestNak (OOCTXT* pctxt, H225InfoRequestNak* pvalue); + +/**************************************************************/ +/* */ +/* ServiceControlIndication_callSpecific */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ServiceControlIndication_callSpecific { + H225CallIdentifier callIdentifier; + H225ConferenceIdentifier conferenceID; + ASN1BOOL answeredCall; +} H225ServiceControlIndication_callSpecific; + +EXTERN int asn1PE_H225ServiceControlIndication_callSpecific (OOCTXT* pctxt, H225ServiceControlIndication_callSpecific* pvalue); + +EXTERN int asn1PD_H225ServiceControlIndication_callSpecific (OOCTXT* pctxt, H225ServiceControlIndication_callSpecific* pvalue); + +/**************************************************************/ +/* */ +/* ServiceControlIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ServiceControlIndication { + struct { + unsigned nonStandardDataPresent : 1; + unsigned endpointIdentifierPresent : 1; + unsigned callSpecificPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ServiceControlSession serviceControl; + H225EndpointIdentifier endpointIdentifier; + H225ServiceControlIndication_callSpecific callSpecific; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225ServiceControlIndication; + +EXTERN int asn1PE_H225ServiceControlIndication (OOCTXT* pctxt, H225ServiceControlIndication* pvalue); + +EXTERN int asn1PD_H225ServiceControlIndication (OOCTXT* pctxt, H225ServiceControlIndication* pvalue); + +/**************************************************************/ +/* */ +/* ServiceControlResponse_result */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225ServiceControlResponse_result_started 1 +#define T_H225ServiceControlResponse_result_failed 2 +#define T_H225ServiceControlResponse_result_stopped 3 +#define T_H225ServiceControlResponse_result_notAvailable 4 +#define T_H225ServiceControlResponse_result_neededFeatureNotSupported 5 +#define T_H225ServiceControlResponse_result_extElem1 6 + +typedef struct EXTERN H225ServiceControlResponse_result { + int t; +} H225ServiceControlResponse_result; + +EXTERN int asn1PE_H225ServiceControlResponse_result (OOCTXT* pctxt, H225ServiceControlResponse_result* pvalue); + +EXTERN int asn1PD_H225ServiceControlResponse_result (OOCTXT* pctxt, H225ServiceControlResponse_result* pvalue); + +/**************************************************************/ +/* */ +/* ServiceControlResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H225ServiceControlResponse { + struct { + unsigned resultPresent : 1; + unsigned nonStandardDataPresent : 1; + unsigned tokensPresent : 1; + unsigned cryptoTokensPresent : 1; + unsigned integrityCheckValuePresent : 1; + unsigned featureSetPresent : 1; + unsigned genericDataPresent : 1; + } m; + H225RequestSeqNum requestSeqNum; + H225ServiceControlResponse_result result; + H225NonStandardParameter nonStandardData; + H225_SeqOfH225ClearToken tokens; + H225_SeqOfH225CryptoH323Token cryptoTokens; + H225ICV integrityCheckValue; + H225FeatureSet featureSet; + H225_SeqOfH225GenericData genericData; +} H225ServiceControlResponse; + +EXTERN int asn1PE_H225ServiceControlResponse (OOCTXT* pctxt, H225ServiceControlResponse* pvalue); + +EXTERN int asn1PD_H225ServiceControlResponse (OOCTXT* pctxt, H225ServiceControlResponse* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH225AdmissionConfirm */ +/* */ +/**************************************************************/ + +/* List of H225AdmissionConfirm */ +typedef DList H225_SeqOfH225AdmissionConfirm; + +EXTERN int asn1PE_H225_SeqOfH225AdmissionConfirm (OOCTXT* pctxt, H225_SeqOfH225AdmissionConfirm* pvalue); + +EXTERN int asn1PD_H225_SeqOfH225AdmissionConfirm (OOCTXT* pctxt, H225_SeqOfH225AdmissionConfirm* pvalue); + +/**************************************************************/ +/* */ +/* RasMessage */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H225RasMessage_gatekeeperRequest 1 +#define T_H225RasMessage_gatekeeperConfirm 2 +#define T_H225RasMessage_gatekeeperReject 3 +#define T_H225RasMessage_registrationRequest 4 +#define T_H225RasMessage_registrationConfirm 5 +#define T_H225RasMessage_registrationReject 6 +#define T_H225RasMessage_unregistrationRequest 7 +#define T_H225RasMessage_unregistrationConfirm 8 +#define T_H225RasMessage_unregistrationReject 9 +#define T_H225RasMessage_admissionRequest 10 +#define T_H225RasMessage_admissionConfirm 11 +#define T_H225RasMessage_admissionReject 12 +#define T_H225RasMessage_bandwidthRequest 13 +#define T_H225RasMessage_bandwidthConfirm 14 +#define T_H225RasMessage_bandwidthReject 15 +#define T_H225RasMessage_disengageRequest 16 +#define T_H225RasMessage_disengageConfirm 17 +#define T_H225RasMessage_disengageReject 18 +#define T_H225RasMessage_locationRequest 19 +#define T_H225RasMessage_locationConfirm 20 +#define T_H225RasMessage_locationReject 21 +#define T_H225RasMessage_infoRequest 22 +#define T_H225RasMessage_infoRequestResponse 23 +#define T_H225RasMessage_nonStandardMessage 24 +#define T_H225RasMessage_unknownMessageResponse 25 +#define T_H225RasMessage_requestInProgress 26 +#define T_H225RasMessage_resourcesAvailableIndicate 27 +#define T_H225RasMessage_resourcesAvailableConfirm 28 +#define T_H225RasMessage_infoRequestAck 29 +#define T_H225RasMessage_infoRequestNak 30 +#define T_H225RasMessage_serviceControlIndication 31 +#define T_H225RasMessage_serviceControlResponse 32 +#define T_H225RasMessage_admissionConfirmSequence 33 +#define T_H225RasMessage_extElem1 34 + +typedef struct EXTERN H225RasMessage { + int t; + union { + /* t = 1 */ + H225GatekeeperRequest *gatekeeperRequest; + /* t = 2 */ + H225GatekeeperConfirm *gatekeeperConfirm; + /* t = 3 */ + H225GatekeeperReject *gatekeeperReject; + /* t = 4 */ + H225RegistrationRequest *registrationRequest; + /* t = 5 */ + H225RegistrationConfirm *registrationConfirm; + /* t = 6 */ + H225RegistrationReject *registrationReject; + /* t = 7 */ + H225UnregistrationRequest *unregistrationRequest; + /* t = 8 */ + H225UnregistrationConfirm *unregistrationConfirm; + /* t = 9 */ + H225UnregistrationReject *unregistrationReject; + /* t = 10 */ + H225AdmissionRequest *admissionRequest; + /* t = 11 */ + H225AdmissionConfirm *admissionConfirm; + /* t = 12 */ + H225AdmissionReject *admissionReject; + /* t = 13 */ + H225BandwidthRequest *bandwidthRequest; + /* t = 14 */ + H225BandwidthConfirm *bandwidthConfirm; + /* t = 15 */ + H225BandwidthReject *bandwidthReject; + /* t = 16 */ + H225DisengageRequest *disengageRequest; + /* t = 17 */ + H225DisengageConfirm *disengageConfirm; + /* t = 18 */ + H225DisengageReject *disengageReject; + /* t = 19 */ + H225LocationRequest *locationRequest; + /* t = 20 */ + H225LocationConfirm *locationConfirm; + /* t = 21 */ + H225LocationReject *locationReject; + /* t = 22 */ + H225InfoRequest *infoRequest; + /* t = 23 */ + H225InfoRequestResponse *infoRequestResponse; + /* t = 24 */ + H225NonStandardMessage *nonStandardMessage; + /* t = 25 */ + H225UnknownMessageResponse *unknownMessageResponse; + /* t = 26 */ + H225RequestInProgress *requestInProgress; + /* t = 27 */ + H225ResourcesAvailableIndicate *resourcesAvailableIndicate; + /* t = 28 */ + H225ResourcesAvailableConfirm *resourcesAvailableConfirm; + /* t = 29 */ + H225InfoRequestAck *infoRequestAck; + /* t = 30 */ + H225InfoRequestNak *infoRequestNak; + /* t = 31 */ + H225ServiceControlIndication *serviceControlIndication; + /* t = 32 */ + H225ServiceControlResponse *serviceControlResponse; + /* t = 33 */ + H225_SeqOfH225AdmissionConfirm *admissionConfirmSequence; + /* t = 34 */ + } u; +} H225RasMessage; + +EXTERN int asn1PE_H225RasMessage (OOCTXT* pctxt, H225RasMessage* pvalue); + +EXTERN int asn1PD_H225RasMessage (OOCTXT* pctxt, H225RasMessage* pvalue); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/h323/H323-MESSAGESDec.c b/addons/ooh323c/src/h323/H323-MESSAGESDec.c new file mode 100644 index 000000000..2f8700b66 --- /dev/null +++ b/addons/ooh323c/src/h323/H323-MESSAGESDec.c @@ -0,0 +1,27199 @@ +/* + * 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; + + /* 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; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + ASN1BOOL extbit; + + /* 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; + + /* 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; + ASN1BOOL extbit; + + /* 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; + 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); +} + diff --git a/addons/ooh323c/src/h323/H323-MESSAGESEnc.c b/addons/ooh323c/src/h323/H323-MESSAGESEnc.c new file mode 100644 index 000000000..62a2cd006 --- /dev/null +++ b/addons/ooh323c/src/h323/H323-MESSAGESEnc.c @@ -0,0 +1,22596 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#include "ooasn1.h" +#include "H323-MESSAGES.h" + +/**************************************************************/ +/* */ +/* ScreeningIndicator */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ScreeningIndicator (OOCTXT* pctxt, H225ScreeningIndicator value) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1BOOL extbit; + + extbit = 0; + + switch (value) { + case userProvidedNotScreened: ui = 0; break; + case userProvidedVerifiedAndPassed: ui = 1; break; + case userProvidedVerifiedAndFailed: ui = 2; break; + case networkProvided: ui = 3; break; + default: ui = value; extbit = 1; + } + + /* extension bit */ + + encodeBit (pctxt, extbit); + + if (extbit) { + stat = encodeSmallNonNegWholeNumber (pctxt, ui); + } + else { + stat = encodeConsUnsigned (pctxt, ui, 0, 3); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NumberDigits */ +/* */ +/**************************************************************/ + +extern EXTERN const char* gs_H323_MESSAGES_NumberDigits_CharSet; + +EXTERN int asn1PE_H225NumberDigits (OOCTXT* pctxt, H225NumberDigits value) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeConstrainedStringEx (pctxt, value, gs_H323_MESSAGES_NumberDigits_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TBCD_STRING */ +/* */ +/**************************************************************/ + +extern EXTERN const char* gs_H323_MESSAGES_TBCD_STRING_CharSet; + +EXTERN int asn1PE_H225TBCD_STRING (OOCTXT* pctxt, H225TBCD_STRING value) +{ + int stat = ASN_OK; + + stat = encodeConstrainedStringEx (pctxt, value, gs_H323_MESSAGES_TBCD_STRING_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* GloballyUniqueID */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GloballyUniqueID (OOCTXT* pctxt, H225GloballyUniqueID* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ConferenceIdentifier (OOCTXT* pctxt, H225ConferenceIdentifier* pvalue) +{ + int stat = ASN_OK; + + stat = asn1PE_H225GloballyUniqueID (pctxt, pvalue); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestSeqNum */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RequestSeqNum (OOCTXT* pctxt, H225RequestSeqNum value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 1U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* GatekeeperIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GatekeeperIdentifier (OOCTXT* pctxt, H225GatekeeperIdentifier value) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBMPString (pctxt, value, 0); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* BandWidth */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225BandWidth (OOCTXT* pctxt, H225BandWidth value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallReferenceValue */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallReferenceValue (OOCTXT* pctxt, H225CallReferenceValue value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EndpointIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225EndpointIdentifier (OOCTXT* pctxt, H225EndpointIdentifier value) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBMPString (pctxt, value, 0); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ProtocolIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ProtocolIdentifier (OOCTXT* pctxt, H225ProtocolIdentifier value) +{ + int stat = ASN_OK; + + stat = encodeObjectIdentifier (pctxt, &value); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TimeToLive */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TimeToLive (OOCTXT* pctxt, H225TimeToLive value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H248PackagesDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H248PackagesDescriptor (OOCTXT* pctxt, H225H248PackagesDescriptor value) +{ + int stat = ASN_OK; + + stat = encodeOctetString (pctxt, value.numocts, value.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H248SignalsDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H248SignalsDescriptor (OOCTXT* pctxt, H225H248SignalsDescriptor value) +{ + int stat = ASN_OK; + + stat = encodeOctetString (pctxt, value.numocts, value.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* GenericIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GenericIdentifier (OOCTXT* pctxt, H225GenericIdentifier* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* standard */ + case 1: + if ( (pvalue->u.standard >= 0 && pvalue->u.standard <= 16383) ) { + extbit = 0; + } + else extbit = 1; + + /* extension bit */ + + encodeBit (pctxt, extbit); + + if (extbit) { + stat = encodeUnconsInteger (pctxt, pvalue->u.standard); + if (stat != ASN_OK) return stat; + } + else { + stat = encodeConsInteger (pctxt, pvalue->u.standard, 0, 16383); + if (stat != ASN_OK) return stat; + } + break; + + /* oid */ + case 2: + stat = encodeObjectIdentifier (pctxt, pvalue->u.oid); + if (stat != ASN_OK) return stat; + break; + + /* nonStandard */ + case 3: + stat = asn1PE_H225GloballyUniqueID (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipAddress_ip */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipAddress_ip (OOCTXT* pctxt, H225TransportAddress_ipAddress_ip* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipAddress (OOCTXT* pctxt, H225TransportAddress_ipAddress* pvalue) +{ + int stat = ASN_OK; + + /* encode ip */ + + stat = asn1PE_H225TransportAddress_ipAddress_ip (pctxt, &pvalue->ip); + if (stat != ASN_OK) return stat; + + /* encode port */ + + stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipSourceRoute_ip */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_ip (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_ip* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipSourceRoute_route_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_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 = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225TransportAddress_ipSourceRoute_route_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (OOCTXT* pctxt, H225_SeqOfH225TransportAddress_ipSourceRoute_route_element* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipSourceRoute_routing */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipSourceRoute_routing (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute_routing* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* strict */ + case 1: + /* NULL */ + break; + + /* loose */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipSourceRoute */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipSourceRoute (OOCTXT* pctxt, H225TransportAddress_ipSourceRoute* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode ip */ + + stat = asn1PE_H225TransportAddress_ipSourceRoute_ip (pctxt, &pvalue->ip); + if (stat != ASN_OK) return stat; + + /* encode port */ + + stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode route */ + + stat = asn1PE_H225_SeqOfH225TransportAddress_ipSourceRoute_route_element (pctxt, &pvalue->route); + if (stat != ASN_OK) return stat; + + /* encode routing */ + + stat = asn1PE_H225TransportAddress_ipSourceRoute_routing (pctxt, &pvalue->routing); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipxAddress_node */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipxAddress_node (OOCTXT* pctxt, H225TransportAddress_ipxAddress_node* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipxAddress_netnum */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipxAddress_netnum (OOCTXT* pctxt, H225TransportAddress_ipxAddress_netnum* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipxAddress_port */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipxAddress_port (OOCTXT* pctxt, H225TransportAddress_ipxAddress_port* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ipxAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ipxAddress (OOCTXT* pctxt, H225TransportAddress_ipxAddress* pvalue) +{ + int stat = ASN_OK; + + /* encode node */ + + stat = asn1PE_H225TransportAddress_ipxAddress_node (pctxt, &pvalue->node); + if (stat != ASN_OK) return stat; + + /* encode netnum */ + + stat = asn1PE_H225TransportAddress_ipxAddress_netnum (pctxt, &pvalue->netnum); + if (stat != ASN_OK) return stat; + + /* encode port */ + + stat = asn1PE_H225TransportAddress_ipxAddress_port (pctxt, &pvalue->port); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ip6Address_ip */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ip6Address_ip (OOCTXT* pctxt, H225TransportAddress_ip6Address_ip* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_ip6Address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_ip6Address (OOCTXT* pctxt, H225TransportAddress_ip6Address* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode ip */ + + stat = asn1PE_H225TransportAddress_ip6Address_ip (pctxt, &pvalue->ip); + if (stat != ASN_OK) return stat; + + /* encode port */ + + stat = encodeConsUnsigned (pctxt, pvalue->port, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_netBios */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_netBios (OOCTXT* pctxt, H225TransportAddress_netBios* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress_nsap */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress_nsap (OOCTXT* pctxt, H225TransportAddress_nsap* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H221NonStandard */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H221NonStandard (OOCTXT* pctxt, H225H221NonStandard* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode t35CountryCode */ + + stat = encodeConsUnsigned (pctxt, pvalue->t35CountryCode, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode t35Extension */ + + stat = encodeConsUnsigned (pctxt, pvalue->t35Extension, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode manufacturerCode */ + + stat = encodeConsUnsigned (pctxt, pvalue->manufacturerCode, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225NonStandardIdentifier (OOCTXT* pctxt, H225NonStandardIdentifier* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* object */ + case 1: + stat = encodeObjectIdentifier (pctxt, pvalue->u.object); + if (stat != ASN_OK) return stat; + break; + + /* h221NonStandard */ + case 2: + stat = asn1PE_H225H221NonStandard (pctxt, pvalue->u.h221NonStandard); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225NonStandardParameter (OOCTXT* pctxt, H225NonStandardParameter* pvalue) +{ + int stat = ASN_OK; + + /* encode nonStandardIdentifier */ + + stat = asn1PE_H225NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier); + if (stat != ASN_OK) return stat; + + /* encode data */ + + stat = encodeOctetString (pctxt, pvalue->data.numocts, pvalue->data.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportAddress (OOCTXT* pctxt, H225TransportAddress* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 7); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* ipAddress */ + case 1: + stat = asn1PE_H225TransportAddress_ipAddress (pctxt, pvalue->u.ipAddress); + if (stat != ASN_OK) return stat; + break; + + /* ipSourceRoute */ + case 2: + stat = asn1PE_H225TransportAddress_ipSourceRoute (pctxt, pvalue->u.ipSourceRoute); + if (stat != ASN_OK) return stat; + break; + + /* ipxAddress */ + case 3: + stat = asn1PE_H225TransportAddress_ipxAddress (pctxt, pvalue->u.ipxAddress); + if (stat != ASN_OK) return stat; + break; + + /* ip6Address */ + case 4: + stat = asn1PE_H225TransportAddress_ip6Address (pctxt, pvalue->u.ip6Address); + if (stat != ASN_OK) return stat; + break; + + /* netBios */ + case 5: + stat = asn1PE_H225TransportAddress_netBios (pctxt, pvalue->u.netBios); + if (stat != ASN_OK) return stat; + break; + + /* nsap */ + case 6: + stat = asn1PE_H225TransportAddress_nsap (pctxt, pvalue->u.nsap); + if (stat != ASN_OK) return stat; + break; + + /* nonStandardAddress */ + case 7: + stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandardAddress); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* PublicTypeOfNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225PublicTypeOfNumber (OOCTXT* pctxt, H225PublicTypeOfNumber* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unknown */ + case 1: + /* NULL */ + break; + + /* internationalNumber */ + case 2: + /* NULL */ + break; + + /* nationalNumber */ + case 3: + /* NULL */ + break; + + /* networkSpecificNumber */ + case 4: + /* NULL */ + break; + + /* subscriberNumber */ + case 5: + /* NULL */ + break; + + /* abbreviatedNumber */ + case 6: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* PublicPartyNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225PublicPartyNumber (OOCTXT* pctxt, H225PublicPartyNumber* pvalue) +{ + int stat = ASN_OK; + + /* encode publicTypeOfNumber */ + + stat = asn1PE_H225PublicTypeOfNumber (pctxt, &pvalue->publicTypeOfNumber); + if (stat != ASN_OK) return stat; + + /* encode publicNumberDigits */ + + stat = asn1PE_H225NumberDigits (pctxt, pvalue->publicNumberDigits); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* PrivateTypeOfNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225PrivateTypeOfNumber (OOCTXT* pctxt, H225PrivateTypeOfNumber* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unknown */ + case 1: + /* NULL */ + break; + + /* level2RegionalNumber */ + case 2: + /* NULL */ + break; + + /* level1RegionalNumber */ + case 3: + /* NULL */ + break; + + /* pISNSpecificNumber */ + case 4: + /* NULL */ + break; + + /* localNumber */ + case 5: + /* NULL */ + break; + + /* abbreviatedNumber */ + case 6: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* PrivatePartyNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225PrivatePartyNumber (OOCTXT* pctxt, H225PrivatePartyNumber* pvalue) +{ + int stat = ASN_OK; + + /* encode privateTypeOfNumber */ + + stat = asn1PE_H225PrivateTypeOfNumber (pctxt, &pvalue->privateTypeOfNumber); + if (stat != ASN_OK) return stat; + + /* encode privateNumberDigits */ + + stat = asn1PE_H225NumberDigits (pctxt, pvalue->privateNumberDigits); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* PartyNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225PartyNumber (OOCTXT* pctxt, H225PartyNumber* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* e164Number */ + case 1: + stat = asn1PE_H225PublicPartyNumber (pctxt, pvalue->u.e164Number); + if (stat != ASN_OK) return stat; + break; + + /* dataPartyNumber */ + case 2: + stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.dataPartyNumber); + if (stat != ASN_OK) return stat; + break; + + /* telexPartyNumber */ + case 3: + stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.telexPartyNumber); + if (stat != ASN_OK) return stat; + break; + + /* privateNumber */ + case 4: + stat = asn1PE_H225PrivatePartyNumber (pctxt, pvalue->u.privateNumber); + if (stat != ASN_OK) return stat; + break; + + /* nationalStandardPartyNumber */ + case 5: + stat = asn1PE_H225NumberDigits (pctxt, pvalue->u.nationalStandardPartyNumber); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + 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 asn1PE_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; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* sid */ + case 1: + addSizeConstraint (pctxt, &sid_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->u.sid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_sid_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + break; + + /* mid */ + case 2: + addSizeConstraint (pctxt, &mid_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->u.mid, gs_H323_MESSAGES_ANSI_41_UIM_system_id_mid_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ANSI_41_UIM_systemMyTypeCode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_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 = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ANSI_41_UIM_systemAccessType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_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 = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ANSI_41_UIM_qualificationInformationCode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_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 = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + 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 asn1PE_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; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.imsiPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.minPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mdnPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.msisdnPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.esnPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mscidPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.systemMyTypeCodePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.systemAccessTypePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qualificationInformationCodePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sesnPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.socPresent); + + /* encode imsi */ + + if (pvalue->m.imsiPresent) { + addSizeConstraint (pctxt, &imsi_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->imsi, gs_H323_MESSAGES_ANSI_41_UIM_imsi_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode min */ + + if (pvalue->m.minPresent) { + addSizeConstraint (pctxt, &min_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->min, gs_H323_MESSAGES_ANSI_41_UIM_min_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode mdn */ + + if (pvalue->m.mdnPresent) { + addSizeConstraint (pctxt, &mdn_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->mdn, gs_H323_MESSAGES_ANSI_41_UIM_mdn_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode msisdn */ + + if (pvalue->m.msisdnPresent) { + addSizeConstraint (pctxt, &msisdn_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->msisdn, gs_H323_MESSAGES_ANSI_41_UIM_msisdn_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode esn */ + + if (pvalue->m.esnPresent) { + addSizeConstraint (pctxt, &esn_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->esn, gs_H323_MESSAGES_ANSI_41_UIM_esn_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode mscid */ + + if (pvalue->m.mscidPresent) { + addSizeConstraint (pctxt, &mscid_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->mscid, gs_H323_MESSAGES_ANSI_41_UIM_mscid_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode system_id */ + + stat = asn1PE_H225ANSI_41_UIM_system_id (pctxt, &pvalue->system_id); + if (stat != ASN_OK) return stat; + + /* encode systemMyTypeCode */ + + if (pvalue->m.systemMyTypeCodePresent) { + stat = asn1PE_H225ANSI_41_UIM_systemMyTypeCode (pctxt, &pvalue->systemMyTypeCode); + if (stat != ASN_OK) return stat; + } + + /* encode systemAccessType */ + + if (pvalue->m.systemAccessTypePresent) { + stat = asn1PE_H225ANSI_41_UIM_systemAccessType (pctxt, &pvalue->systemAccessType); + if (stat != ASN_OK) return stat; + } + + /* encode qualificationInformationCode */ + + if (pvalue->m.qualificationInformationCodePresent) { + stat = asn1PE_H225ANSI_41_UIM_qualificationInformationCode (pctxt, &pvalue->qualificationInformationCode); + if (stat != ASN_OK) return stat; + } + + /* encode sesn */ + + if (pvalue->m.sesnPresent) { + addSizeConstraint (pctxt, &sesn_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->sesn, gs_H323_MESSAGES_ANSI_41_UIM_sesn_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode soc */ + + if (pvalue->m.socPresent) { + addSizeConstraint (pctxt, &soc_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->soc, gs_H323_MESSAGES_ANSI_41_UIM_soc_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GSM_UIM_tmsi */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GSM_UIM_tmsi (OOCTXT* pctxt, H225GSM_UIM_tmsi* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + 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 asn1PE_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; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.imsiPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tmsiPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.msisdnPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.imeiPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.hplmnPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.vplmnPresent); + + /* encode imsi */ + + if (pvalue->m.imsiPresent) { + addSizeConstraint (pctxt, &imsi_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->imsi, gs_H323_MESSAGES_GSM_UIM_imsi_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode tmsi */ + + if (pvalue->m.tmsiPresent) { + stat = asn1PE_H225GSM_UIM_tmsi (pctxt, &pvalue->tmsi); + if (stat != ASN_OK) return stat; + } + + /* encode msisdn */ + + if (pvalue->m.msisdnPresent) { + addSizeConstraint (pctxt, &msisdn_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->msisdn, gs_H323_MESSAGES_GSM_UIM_msisdn_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode imei */ + + if (pvalue->m.imeiPresent) { + addSizeConstraint (pctxt, &imei_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->imei, gs_H323_MESSAGES_GSM_UIM_imei_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode hplmn */ + + if (pvalue->m.hplmnPresent) { + addSizeConstraint (pctxt, &hplmn_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->hplmn, gs_H323_MESSAGES_GSM_UIM_hplmn_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + /* encode vplmn */ + + if (pvalue->m.vplmnPresent) { + addSizeConstraint (pctxt, &vplmn_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->vplmn, gs_H323_MESSAGES_GSM_UIM_vplmn_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MobileUIM */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225MobileUIM (OOCTXT* pctxt, H225MobileUIM* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* ansi_41_uim */ + case 1: + stat = asn1PE_H225ANSI_41_UIM (pctxt, pvalue->u.ansi_41_uim); + if (stat != ASN_OK) return stat; + break; + + /* gsm_uim */ + case 2: + stat = asn1PE_H225GSM_UIM (pctxt, pvalue->u.gsm_uim); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AliasAddress */ +/* */ +/**************************************************************/ + +extern EXTERN const char* gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet; + +EXTERN int asn1PE_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; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* dialedDigits */ + case 1: + addSizeConstraint (pctxt, &dialedDigits_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->u.dialedDigits, gs_H323_MESSAGES_AliasAddress_dialedDigits_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + break; + + /* h323_ID */ + case 2: + addSizeConstraint (pctxt, &h323_ID_lsize1); + + stat = encodeBMPString (pctxt, pvalue->u.h323_ID, 0); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* url_ID */ + case 3: + addSizeConstraint (&lctxt, &url_ID_lsize1); + + stat = encodeConstrainedStringEx (&lctxt, pvalue->u.url_ID, 0, 8, 7, 7); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* transportID */ + case 4: + stat = asn1PE_H225TransportAddress (&lctxt, pvalue->u.transportID); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* email_ID */ + case 5: + addSizeConstraint (&lctxt, &email_ID_lsize1); + + stat = encodeConstrainedStringEx (&lctxt, pvalue->u.email_ID, 0, 8, 7, 7); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* partyNumber */ + case 6: + stat = asn1PE_H225PartyNumber (&lctxt, pvalue->u.partyNumber); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* mobileUIM */ + case 7: + stat = asn1PE_H225MobileUIM (&lctxt, pvalue->u.mobileUIM); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Content_compound */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Content_compound (OOCTXT* pctxt, H225Content_compound* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H225EnumeratedParameter (pctxt, (H225EnumeratedParameter*)((H225EnumeratedParameter*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Content_nested */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Content_nested (OOCTXT* pctxt, H225Content_nested* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H225GenericData (pctxt, (H225GenericData*)((H225GenericData*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Content */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Content (OOCTXT* pctxt, H225Content* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 12); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 11); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* raw */ + case 1: + stat = encodeOctetString (pctxt, pvalue->u.raw->numocts, pvalue->u.raw->data); + if (stat != ASN_OK) return stat; + break; + + /* text */ + case 2: + stat = encodeConstrainedStringEx (pctxt, pvalue->u.text, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + break; + + /* unicode */ + case 3: + stat = encodeBMPString (pctxt, pvalue->u.unicode, 0); + if (stat != ASN_OK) return stat; + break; + + /* bool_ */ + case 4: + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->u.bool_); + if (stat != ASN_OK) return stat; + break; + + /* number8 */ + case 5: + stat = encodeConsUnsigned (pctxt, pvalue->u.number8, 0U, 255U); + if (stat != ASN_OK) return stat; + + break; + + /* number16 */ + case 6: + stat = encodeConsUnsigned (pctxt, pvalue->u.number16, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* number32 */ + case 7: + stat = encodeConsUnsigned (pctxt, pvalue->u.number32, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + break; + + /* id */ + case 8: + stat = asn1PE_H225GenericIdentifier (pctxt, pvalue->u.id); + if (stat != ASN_OK) return stat; + break; + + /* alias */ + case 9: + stat = asn1PE_H225AliasAddress (pctxt, pvalue->u.alias); + if (stat != ASN_OK) return stat; + break; + + /* transport */ + case 10: + stat = asn1PE_H225TransportAddress (pctxt, pvalue->u.transport); + if (stat != ASN_OK) return stat; + break; + + /* compound */ + case 11: + stat = asn1PE_H225Content_compound (pctxt, pvalue->u.compound); + if (stat != ASN_OK) return stat; + break; + + /* nested */ + case 12: + stat = asn1PE_H225Content_nested (pctxt, pvalue->u.nested); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 13); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnumeratedParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225EnumeratedParameter (OOCTXT* pctxt, H225EnumeratedParameter* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.contentPresent); + + /* encode id */ + + stat = asn1PE_H225GenericIdentifier (pctxt, &pvalue->id); + if (stat != ASN_OK) return stat; + + /* encode content */ + + if (pvalue->m.contentPresent) { + stat = asn1PE_H225Content (pctxt, &pvalue->content); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GenericData_parameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GenericData_parameters (OOCTXT* pctxt, H225GenericData_parameters* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 512, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H225EnumeratedParameter (pctxt, ((H225EnumeratedParameter*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GenericData */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GenericData (OOCTXT* pctxt, H225GenericData* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.parametersPresent); + + /* encode id */ + + stat = asn1PE_H225GenericIdentifier (pctxt, &pvalue->id); + if (stat != ASN_OK) return stat; + + /* encode parameters */ + + if (pvalue->m.parametersPresent) { + stat = asn1PE_H225GenericData_parameters (pctxt, &pvalue->parameters); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FeatureDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225FeatureDescriptor (OOCTXT* pctxt, H225FeatureDescriptor* pvalue) +{ + int stat = ASN_OK; + + stat = asn1PE_H225GenericData (pctxt, pvalue); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FastStartToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225FastStartToken (OOCTXT* pctxt, H225FastStartToken* pvalue) +{ + int stat = ASN_OK; + + stat = asn1PE_H235ClearToken (pctxt, pvalue); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncodedFastStartToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225EncodedFastStartToken (OOCTXT* pctxt, H225EncodedFastStartToken value) +{ + int stat = ASN_OK; + + stat = encodeOpenType (pctxt, value.numocts, value.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UserInformation_user_data_user_information */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_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 = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EndpointType_set */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225EndpointType_set (OOCTXT* pctxt, H225EndpointType_set* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 32, 32, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VendorIdentifier_productId */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225VendorIdentifier_productId (OOCTXT* pctxt, H225VendorIdentifier_productId* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VendorIdentifier_versionId */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225VendorIdentifier_versionId (OOCTXT* pctxt, H225VendorIdentifier_versionId* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CicInfo_cic_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CicInfo_cic_element (OOCTXT* pctxt, H225CicInfo_cic_element* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 2, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CicInfo_pointCode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CicInfo_pointCode (OOCTXT* pctxt, H225CicInfo_pointCode* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 2, 5, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CarrierInfo_carrierIdentificationCode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CarrierInfo_carrierIdentificationCode (OOCTXT* pctxt, H225CarrierInfo_carrierIdentificationCode* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 3, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallTerminationCause_releaseCompleteCauseIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallTerminationCause_releaseCompleteCauseIE (OOCTXT* pctxt, H225CallTerminationCause_releaseCompleteCauseIE* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 2, 32, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225AliasAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225AliasAddress (OOCTXT* pctxt, H225_SeqOfH225AliasAddress* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225AliasAddress (pctxt, ((H225AliasAddress*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VendorIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225VendorIdentifier (OOCTXT* pctxt, H225VendorIdentifier* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.enterpriseNumberPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.productIdPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.versionIdPresent); + + /* encode vendor */ + + stat = asn1PE_H225H221NonStandard (pctxt, &pvalue->vendor); + if (stat != ASN_OK) return stat; + + /* encode productId */ + + if (pvalue->m.productIdPresent) { + stat = asn1PE_H225VendorIdentifier_productId (pctxt, &pvalue->productId); + if (stat != ASN_OK) return stat; + } + + /* encode versionId */ + + if (pvalue->m.versionIdPresent) { + stat = asn1PE_H225VendorIdentifier_versionId (pctxt, &pvalue->versionId); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.enterpriseNumberPresent); + /* encode extension elements */ + + if (pvalue->m.enterpriseNumberPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeObjectIdentifier (&lctxt, &pvalue->enterpriseNumber); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GatekeeperInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GatekeeperInfo (OOCTXT* pctxt, H225GatekeeperInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataRate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225DataRate (OOCTXT* pctxt, H225DataRate* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.channelMultiplierPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode channelRate */ + + stat = asn1PE_H225BandWidth (pctxt, pvalue->channelRate); + if (stat != ASN_OK) return stat; + + /* encode channelMultiplier */ + + if (pvalue->m.channelMultiplierPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->channelMultiplier, 1U, 256U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225DataRate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225DataRate (OOCTXT* pctxt, H225_SeqOfH225DataRate* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225DataRate (pctxt, ((H225DataRate*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SupportedPrefix */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225SupportedPrefix (OOCTXT* pctxt, H225SupportedPrefix* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode prefix */ + + stat = asn1PE_H225AliasAddress (pctxt, &pvalue->prefix); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225SupportedPrefix */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225SupportedPrefix (OOCTXT* pctxt, H225_SeqOfH225SupportedPrefix* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225SupportedPrefix (pctxt, ((H225SupportedPrefix*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H310Caps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H310Caps (OOCTXT* pctxt, H225H310Caps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent || + pvalue->m.supportedPrefixesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + /* encode extension elements */ + + if (pvalue->m.dataRatesSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H320Caps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H320Caps (OOCTXT* pctxt, H225H320Caps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent || + pvalue->m.supportedPrefixesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + /* encode extension elements */ + + if (pvalue->m.dataRatesSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H321Caps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H321Caps (OOCTXT* pctxt, H225H321Caps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent || + pvalue->m.supportedPrefixesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + /* encode extension elements */ + + if (pvalue->m.dataRatesSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H322Caps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H322Caps (OOCTXT* pctxt, H225H322Caps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent || + pvalue->m.supportedPrefixesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + /* encode extension elements */ + + if (pvalue->m.dataRatesSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323Caps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323Caps (OOCTXT* pctxt, H225H323Caps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent || + pvalue->m.supportedPrefixesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + /* encode extension elements */ + + if (pvalue->m.dataRatesSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H324Caps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H324Caps (OOCTXT* pctxt, H225H324Caps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent || + pvalue->m.supportedPrefixesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + /* encode extension elements */ + + if (pvalue->m.dataRatesSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VoiceCaps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225VoiceCaps (OOCTXT* pctxt, H225VoiceCaps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent || + pvalue->m.supportedPrefixesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + /* encode extension elements */ + + if (pvalue->m.dataRatesSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* T120OnlyCaps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225T120OnlyCaps (OOCTXT* pctxt, H225T120OnlyCaps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.dataRatesSupportedPresent || + pvalue->m.supportedPrefixesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + /* encode extension elements */ + + if (pvalue->m.dataRatesSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225DataRate (&lctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardProtocol */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225NonStandardProtocol (OOCTXT* pctxt, H225NonStandardProtocol* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode dataRatesSupported */ + + if (pvalue->m.dataRatesSupportedPresent) { + stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return stat; + } + + /* encode supportedPrefixes */ + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* T38FaxAnnexbOnlyCaps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225T38FaxAnnexbOnlyCaps (OOCTXT* pctxt, H225T38FaxAnnexbOnlyCaps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode dataRatesSupported */ + + if (pvalue->m.dataRatesSupportedPresent) { + stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return stat; + } + + /* encode supportedPrefixes */ + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return stat; + + /* encode t38FaxProtocol */ + + stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol); + if (stat != ASN_OK) return stat; + + /* encode t38FaxProfile */ + + stat = asn1PE_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* SIPCaps */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225SIPCaps (OOCTXT* pctxt, H225SIPCaps* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataRatesSupportedPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode dataRatesSupported */ + + if (pvalue->m.dataRatesSupportedPresent) { + stat = asn1PE_H225_SeqOfH225DataRate (pctxt, &pvalue->dataRatesSupported); + if (stat != ASN_OK) return stat; + } + + /* encode supportedPrefixes */ + + if (pvalue->m.supportedPrefixesPresent) { + stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SupportedProtocols */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225SupportedProtocols (OOCTXT* pctxt, H225SupportedProtocols* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 9); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 8); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandardData */ + case 1: + stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandardData); + if (stat != ASN_OK) return stat; + break; + + /* h310 */ + case 2: + stat = asn1PE_H225H310Caps (pctxt, pvalue->u.h310); + if (stat != ASN_OK) return stat; + break; + + /* h320 */ + case 3: + stat = asn1PE_H225H320Caps (pctxt, pvalue->u.h320); + if (stat != ASN_OK) return stat; + break; + + /* h321 */ + case 4: + stat = asn1PE_H225H321Caps (pctxt, pvalue->u.h321); + if (stat != ASN_OK) return stat; + break; + + /* h322 */ + case 5: + stat = asn1PE_H225H322Caps (pctxt, pvalue->u.h322); + if (stat != ASN_OK) return stat; + break; + + /* h323 */ + case 6: + stat = asn1PE_H225H323Caps (pctxt, pvalue->u.h323); + if (stat != ASN_OK) return stat; + break; + + /* h324 */ + case 7: + stat = asn1PE_H225H324Caps (pctxt, pvalue->u.h324); + if (stat != ASN_OK) return stat; + break; + + /* voice */ + case 8: + stat = asn1PE_H225VoiceCaps (pctxt, pvalue->u.voice); + if (stat != ASN_OK) return stat; + break; + + /* t120_only */ + case 9: + stat = asn1PE_H225T120OnlyCaps (pctxt, pvalue->u.t120_only); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 10); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* nonStandardProtocol */ + case 10: + stat = asn1PE_H225NonStandardProtocol (&lctxt, pvalue->u.nonStandardProtocol); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* t38FaxAnnexbOnly */ + case 11: + stat = asn1PE_H225T38FaxAnnexbOnlyCaps (&lctxt, pvalue->u.t38FaxAnnexbOnly); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* sip */ + case 12: + stat = asn1PE_H225SIPCaps (&lctxt, pvalue->u.sip); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225SupportedProtocols */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225SupportedProtocols (OOCTXT* pctxt, H225_SeqOfH225SupportedProtocols* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225SupportedProtocols (pctxt, ((H225SupportedProtocols*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GatewayInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GatewayInfo (OOCTXT* pctxt, H225GatewayInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.protocolPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode protocol */ + + if (pvalue->m.protocolPresent) { + stat = asn1PE_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocol); + if (stat != ASN_OK) return stat; + } + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* McuInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225McuInfo (OOCTXT* pctxt, H225McuInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.protocolPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.protocolPresent); + /* encode extension elements */ + + if (pvalue->m.protocolPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->protocol); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TerminalInfo (OOCTXT* pctxt, H225TerminalInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TunnelledProtocolAlternateIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_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; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.protocolVariantPresent); + + /* encode protocolType */ + + addSizeConstraint (pctxt, &protocolType_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->protocolType, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + + /* encode protocolVariant */ + + if (pvalue->m.protocolVariantPresent) { + addSizeConstraint (pctxt, &protocolVariant_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->protocolVariant, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TunnelledProtocol_id */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TunnelledProtocol_id (OOCTXT* pctxt, H225TunnelledProtocol_id* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* tunnelledProtocolObjectID */ + case 1: + stat = encodeObjectIdentifier (pctxt, pvalue->u.tunnelledProtocolObjectID); + if (stat != ASN_OK) return stat; + break; + + /* tunnelledProtocolAlternateID */ + case 2: + stat = asn1PE_H225TunnelledProtocolAlternateIdentifier (pctxt, pvalue->u.tunnelledProtocolAlternateID); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TunnelledProtocol */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TunnelledProtocol (OOCTXT* pctxt, H225TunnelledProtocol* pvalue) +{ + static Asn1SizeCnst subIdentifier_lsize1 = { 0, 1, 64, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.subIdentifierPresent); + + /* encode id */ + + stat = asn1PE_H225TunnelledProtocol_id (pctxt, &pvalue->id); + if (stat != ASN_OK) return stat; + + /* encode subIdentifier */ + + if (pvalue->m.subIdentifierPresent) { + addSizeConstraint (pctxt, &subIdentifier_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->subIdentifier, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225TunnelledProtocol */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225TunnelledProtocol (OOCTXT* pctxt, H225_SeqOfH225TunnelledProtocol* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225TunnelledProtocol (pctxt, ((H225TunnelledProtocol*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EndpointType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225EndpointType (OOCTXT* pctxt, H225EndpointType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.setPresent || + pvalue->m.supportedTunnelledProtocolsPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.vendorPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatewayPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mcuPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode vendor */ + + if (pvalue->m.vendorPresent) { + stat = asn1PE_H225VendorIdentifier (pctxt, &pvalue->vendor); + if (stat != ASN_OK) return stat; + } + + /* encode gatekeeper */ + + if (pvalue->m.gatekeeperPresent) { + stat = asn1PE_H225GatekeeperInfo (pctxt, &pvalue->gatekeeper); + if (stat != ASN_OK) return stat; + } + + /* encode gateway */ + + if (pvalue->m.gatewayPresent) { + stat = asn1PE_H225GatewayInfo (pctxt, &pvalue->gateway); + if (stat != ASN_OK) return stat; + } + + /* encode mcu */ + + if (pvalue->m.mcuPresent) { + stat = asn1PE_H225McuInfo (pctxt, &pvalue->mcu); + if (stat != ASN_OK) return stat; + } + + /* encode terminal */ + + if (pvalue->m.terminalPresent) { + stat = asn1PE_H225TerminalInfo (pctxt, &pvalue->terminal); + if (stat != ASN_OK) return stat; + } + + /* encode mc */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mc); + if (stat != ASN_OK) return stat; + + /* encode undefinedNode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->undefinedNode); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.setPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedTunnelledProtocolsPresent); + /* encode extension elements */ + + if (pvalue->m.setPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225EndpointType_set (&lctxt, &pvalue->set); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedTunnelledProtocolsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225TunnelledProtocol (&lctxt, &pvalue->supportedTunnelledProtocols); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225CallReferenceValue */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225CallReferenceValue (OOCTXT* pctxt, H225_SeqOfH225CallReferenceValue* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Setup_UUIE_conferenceGoal */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Setup_UUIE_conferenceGoal (OOCTXT* pctxt, H225Setup_UUIE_conferenceGoal* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* create */ + case 1: + /* NULL */ + break; + + /* join */ + case 2: + /* NULL */ + break; + + /* invite */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* capability_negotiation */ + case 4: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* callIndependentSupplementaryService */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Q954Details */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Q954Details (OOCTXT* pctxt, H225Q954Details* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode conferenceCalling */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->conferenceCalling); + if (stat != ASN_OK) return stat; + + /* encode threePartyService */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->threePartyService); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* QseriesOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225QseriesOptions (OOCTXT* pctxt, H225QseriesOptions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode q932Full */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q932Full); + if (stat != ASN_OK) return stat; + + /* encode q951Full */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q951Full); + if (stat != ASN_OK) return stat; + + /* encode q952Full */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q952Full); + if (stat != ASN_OK) return stat; + + /* encode q953Full */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q953Full); + if (stat != ASN_OK) return stat; + + /* encode q955Full */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q955Full); + if (stat != ASN_OK) return stat; + + /* encode q956Full */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q956Full); + if (stat != ASN_OK) return stat; + + /* encode q957Full */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->q957Full); + if (stat != ASN_OK) return stat; + + /* encode q954Info */ + + stat = asn1PE_H225Q954Details (pctxt, &pvalue->q954Info); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallType (OOCTXT* pctxt, H225CallType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* pointToPoint */ + case 1: + /* NULL */ + break; + + /* oneToN */ + case 2: + /* NULL */ + break; + + /* nToOne */ + case 3: + /* NULL */ + break; + + /* nToN */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallIdentifier (OOCTXT* pctxt, H225CallIdentifier* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode guid */ + + stat = asn1PE_H225GloballyUniqueID (pctxt, &pvalue->guid); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* SecurityServiceMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225SecurityServiceMode (OOCTXT* pctxt, H225SecurityServiceMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* none */ + case 2: + /* NULL */ + break; + + /* default_ */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SecurityCapabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225SecurityCapabilities (OOCTXT* pctxt, H225SecurityCapabilities* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + /* encode encryption */ + + stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->encryption); + if (stat != ASN_OK) return stat; + + /* encode authenticaton */ + + stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->authenticaton); + if (stat != ASN_OK) return stat; + + /* encode integrity */ + + stat = asn1PE_H225SecurityServiceMode (pctxt, &pvalue->integrity); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H245Security */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H245Security (OOCTXT* pctxt, H225H245Security* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* noSecurity */ + case 2: + /* NULL */ + break; + + /* tls */ + case 3: + stat = asn1PE_H225SecurityCapabilities (pctxt, pvalue->u.tls); + if (stat != ASN_OK) return stat; + break; + + /* ipsec */ + case 4: + stat = asn1PE_H225SecurityCapabilities (pctxt, pvalue->u.ipsec); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225H245Security */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225H245Security (OOCTXT* pctxt, H225_SeqOfH225H245Security* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225H245Security (pctxt, ((H225H245Security*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225ClearToken */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225ClearToken (OOCTXT* pctxt, H225_SeqOfH225ClearToken* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H235ClearToken (pctxt, ((H235ClearToken*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoEPPwdHash */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CryptoH323Token_cryptoEPPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPPwdHash* pvalue) +{ + int stat = ASN_OK; + + /* encode alias */ + + stat = asn1PE_H225AliasAddress (pctxt, &pvalue->alias); + if (stat != ASN_OK) return stat; + + /* encode timeStamp */ + + stat = asn1PE_H235TimeStamp (pctxt, pvalue->timeStamp); + if (stat != ASN_OK) return stat; + + /* encode token */ + + stat = asn1PE_H235HASHED (pctxt, &pvalue->token); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoGKPwdHash */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CryptoH323Token_cryptoGKPwdHash (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKPwdHash* pvalue) +{ + int stat = ASN_OK; + + /* encode gatekeeperId */ + + stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperId); + if (stat != ASN_OK) return stat; + + /* encode timeStamp */ + + stat = asn1PE_H235TimeStamp (pctxt, pvalue->timeStamp); + if (stat != ASN_OK) return stat; + + /* encode token */ + + stat = asn1PE_H235HASHED (pctxt, &pvalue->token); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoEPCert */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CryptoH323Token_cryptoEPCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoEPCert* pvalue) +{ + int stat = ASN_OK; + + /* encode toBeSigned */ + + stat = asn1PE_H235EncodedPwdCertToken (pctxt, pvalue->toBeSigned); + if (stat != ASN_OK) return stat; + + /* encode algorithmOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID); + if (stat != ASN_OK) return stat; + + /* encode paramS */ + + stat = asn1PE_H235Params (pctxt, &pvalue->paramS); + if (stat != ASN_OK) return stat; + + /* encode signature */ + + stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoGKCert */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CryptoH323Token_cryptoGKCert (OOCTXT* pctxt, H225CryptoH323Token_cryptoGKCert* pvalue) +{ + int stat = ASN_OK; + + /* encode toBeSigned */ + + stat = asn1PE_H235EncodedPwdCertToken (pctxt, pvalue->toBeSigned); + if (stat != ASN_OK) return stat; + + /* encode algorithmOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID); + if (stat != ASN_OK) return stat; + + /* encode paramS */ + + stat = asn1PE_H235Params (pctxt, &pvalue->paramS); + if (stat != ASN_OK) return stat; + + /* encode signature */ + + stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoH323Token_cryptoFastStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CryptoH323Token_cryptoFastStart (OOCTXT* pctxt, H225CryptoH323Token_cryptoFastStart* pvalue) +{ + int stat = ASN_OK; + + /* encode toBeSigned */ + + stat = asn1PE_H225EncodedFastStartToken (pctxt, pvalue->toBeSigned); + if (stat != ASN_OK) return stat; + + /* encode algorithmOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID); + if (stat != ASN_OK) return stat; + + /* encode paramS */ + + stat = asn1PE_H235Params (pctxt, &pvalue->paramS); + if (stat != ASN_OK) return stat; + + /* encode signature */ + + stat = encodeBitString (pctxt, pvalue->signature.numbits, pvalue->signature.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CryptoH323Token */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CryptoH323Token (OOCTXT* pctxt, H225CryptoH323Token* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 8); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* cryptoEPPwdHash */ + case 1: + stat = asn1PE_H225CryptoH323Token_cryptoEPPwdHash (pctxt, pvalue->u.cryptoEPPwdHash); + if (stat != ASN_OK) return stat; + break; + + /* cryptoGKPwdHash */ + case 2: + stat = asn1PE_H225CryptoH323Token_cryptoGKPwdHash (pctxt, pvalue->u.cryptoGKPwdHash); + if (stat != ASN_OK) return stat; + break; + + /* cryptoEPPwdEncr */ + case 3: + stat = asn1PE_H235ENCRYPTED (pctxt, pvalue->u.cryptoEPPwdEncr); + if (stat != ASN_OK) return stat; + break; + + /* cryptoGKPwdEncr */ + case 4: + stat = asn1PE_H235ENCRYPTED (pctxt, pvalue->u.cryptoGKPwdEncr); + if (stat != ASN_OK) return stat; + break; + + /* cryptoEPCert */ + case 5: + stat = asn1PE_H225CryptoH323Token_cryptoEPCert (pctxt, pvalue->u.cryptoEPCert); + if (stat != ASN_OK) return stat; + break; + + /* cryptoGKCert */ + case 6: + stat = asn1PE_H225CryptoH323Token_cryptoGKCert (pctxt, pvalue->u.cryptoGKCert); + if (stat != ASN_OK) return stat; + break; + + /* cryptoFastStart */ + case 7: + stat = asn1PE_H225CryptoH323Token_cryptoFastStart (pctxt, pvalue->u.cryptoFastStart); + if (stat != ASN_OK) return stat; + break; + + /* nestedcryptoToken */ + case 8: + stat = asn1PE_H235CryptoToken (pctxt, pvalue->u.nestedcryptoToken); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225CryptoH323Token */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225CryptoH323Token (OOCTXT* pctxt, H225_SeqOfH225CryptoH323Token* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225CryptoH323Token (pctxt, ((H225CryptoH323Token*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Setup_UUIE_fastStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Setup_UUIE_fastStart (OOCTXT* pctxt, H225Setup_UUIE_fastStart* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ScnConnectionType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ScnConnectionType (OOCTXT* pctxt, H225ScnConnectionType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 7); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unknown */ + case 1: + /* NULL */ + break; + + /* bChannel */ + case 2: + /* NULL */ + break; + + /* hybrid2x64 */ + case 3: + /* NULL */ + break; + + /* hybrid384 */ + case 4: + /* NULL */ + break; + + /* hybrid1536 */ + case 5: + /* NULL */ + break; + + /* hybrid1920 */ + case 6: + /* NULL */ + break; + + /* multirate */ + case 7: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ScnConnectionAggregation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ScnConnectionAggregation (OOCTXT* pctxt, H225ScnConnectionAggregation* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* auto_ */ + case 1: + /* NULL */ + break; + + /* none */ + case 2: + /* NULL */ + break; + + /* h221 */ + case 3: + /* NULL */ + break; + + /* bonded_mode1 */ + case 4: + /* NULL */ + break; + + /* bonded_mode2 */ + case 5: + /* NULL */ + break; + + /* bonded_mode3 */ + case 6: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Setup_UUIE_connectionParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Setup_UUIE_connectionParameters (OOCTXT* pctxt, H225Setup_UUIE_connectionParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode connectionType */ + + stat = asn1PE_H225ScnConnectionType (pctxt, &pvalue->connectionType); + if (stat != ASN_OK) return stat; + + /* encode numberOfScnConnections */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfScnConnections, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode connectionAggregation */ + + stat = asn1PE_H225ScnConnectionAggregation (pctxt, &pvalue->connectionAggregation); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Setup_UUIE_language */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Setup_UUIE_language (OOCTXT* pctxt, H225Setup_UUIE_language* pvalue) +{ + static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + addSizeConstraint (pctxt, &element_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->elem[xx1], 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* PresentationIndicator */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225PresentationIndicator (OOCTXT* pctxt, H225PresentationIndicator* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* presentationAllowed */ + case 1: + /* NULL */ + break; + + /* presentationRestricted */ + case 2: + /* NULL */ + break; + + /* addressNotAvailable */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallCreditServiceControl_billingMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallCreditServiceControl_billingMode (OOCTXT* pctxt, H225CallCreditServiceControl_billingMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* credit */ + case 1: + /* NULL */ + break; + + /* debit */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallCreditServiceControl_callStartingPoint */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallCreditServiceControl_callStartingPoint (OOCTXT* pctxt, H225CallCreditServiceControl_callStartingPoint* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* alerting */ + case 1: + /* NULL */ + break; + + /* connect */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallCreditServiceControl */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallCreditServiceControl (OOCTXT* pctxt, H225CallCreditServiceControl* pvalue) +{ + static Asn1SizeCnst amountString_lsize1 = { 0, 1, 512, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.amountStringPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.billingModePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callDurationLimitPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.enforceCallDurationLimitPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callStartingPointPresent); + + /* encode amountString */ + + if (pvalue->m.amountStringPresent) { + addSizeConstraint (pctxt, &amountString_lsize1); + + stat = encodeBMPString (pctxt, pvalue->amountString, 0); + if (stat != ASN_OK) return stat; + } + + /* encode billingMode */ + + if (pvalue->m.billingModePresent) { + stat = asn1PE_H225CallCreditServiceControl_billingMode (pctxt, &pvalue->billingMode); + if (stat != ASN_OK) return stat; + } + + /* encode callDurationLimit */ + + if (pvalue->m.callDurationLimitPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->callDurationLimit, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + /* encode enforceCallDurationLimit */ + + if (pvalue->m.enforceCallDurationLimitPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->enforceCallDurationLimit); + if (stat != ASN_OK) return stat; + } + + /* encode callStartingPoint */ + + if (pvalue->m.callStartingPointPresent) { + stat = asn1PE_H225CallCreditServiceControl_callStartingPoint (pctxt, &pvalue->callStartingPoint); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ServiceControlDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ServiceControlDescriptor (OOCTXT* pctxt, H225ServiceControlDescriptor* pvalue) +{ + static Asn1SizeCnst url_lsize1 = { 0, 0, 512, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* url */ + case 1: + addSizeConstraint (pctxt, &url_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->u.url, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + break; + + /* signal */ + case 2: + stat = asn1PE_H225H248SignalsDescriptor (pctxt, *pvalue->u.signal); + if (stat != ASN_OK) return stat; + break; + + /* nonStandard */ + case 3: + stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* callCreditServiceControl */ + case 4: + stat = asn1PE_H225CallCreditServiceControl (pctxt, pvalue->u.callCreditServiceControl); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ServiceControlSession_reason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ServiceControlSession_reason (OOCTXT* pctxt, H225ServiceControlSession_reason* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* open */ + case 1: + /* NULL */ + break; + + /* refresh */ + case 2: + /* NULL */ + break; + + /* close */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ServiceControlSession */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ServiceControlSession (OOCTXT* pctxt, H225ServiceControlSession* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.contentsPresent); + + /* encode sessionId */ + + stat = encodeConsUnsigned (pctxt, pvalue->sessionId, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode contents */ + + if (pvalue->m.contentsPresent) { + stat = asn1PE_H225ServiceControlDescriptor (pctxt, &pvalue->contents); + if (stat != ASN_OK) return stat; + } + + /* encode reason */ + + stat = asn1PE_H225ServiceControlSession_reason (pctxt, &pvalue->reason); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225ServiceControlSession */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225ServiceControlSession (OOCTXT* pctxt, H225_SeqOfH225ServiceControlSession* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225ServiceControlSession (pctxt, ((H225ServiceControlSession*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CarrierInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CarrierInfo (OOCTXT* pctxt, H225CarrierInfo* pvalue) +{ + static Asn1SizeCnst carrierName_lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.carrierIdentificationCodePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.carrierNamePresent); + + /* encode carrierIdentificationCode */ + + if (pvalue->m.carrierIdentificationCodePresent) { + stat = asn1PE_H225CarrierInfo_carrierIdentificationCode (pctxt, &pvalue->carrierIdentificationCode); + if (stat != ASN_OK) return stat; + } + + /* encode carrierName */ + + if (pvalue->m.carrierNamePresent) { + addSizeConstraint (pctxt, &carrierName_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->carrierName, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallsAvailable */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallsAvailable (OOCTXT* pctxt, H225CallsAvailable* pvalue) +{ + static Asn1SizeCnst group_lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.carrierPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.groupPresent); + + /* encode calls */ + + stat = encodeConsUnsigned (pctxt, pvalue->calls, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + /* encode group */ + + if (pvalue->m.groupPresent) { + addSizeConstraint (pctxt, &group_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->group, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.carrierPresent); + /* encode extension elements */ + + if (pvalue->m.carrierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CarrierInfo (&lctxt, &pvalue->carrier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225CallsAvailable */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225CallsAvailable (OOCTXT* pctxt, H225_SeqOfH225CallsAvailable* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225CallsAvailable (pctxt, ((H225CallsAvailable*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallCapacityInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallCapacityInfo (OOCTXT* pctxt, H225CallCapacityInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.sipGwCallsAvailablePresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.voiceGwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h310GwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h320GwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h321GwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h322GwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h323GwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h324GwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t120OnlyGwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxAnnexbOnlyGwCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalCallsAvailablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mcuCallsAvailablePresent); + + /* encode voiceGwCallsAvailable */ + + if (pvalue->m.voiceGwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->voiceGwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode h310GwCallsAvailable */ + + if (pvalue->m.h310GwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h310GwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode h320GwCallsAvailable */ + + if (pvalue->m.h320GwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h320GwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode h321GwCallsAvailable */ + + if (pvalue->m.h321GwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h321GwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode h322GwCallsAvailable */ + + if (pvalue->m.h322GwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h322GwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode h323GwCallsAvailable */ + + if (pvalue->m.h323GwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h323GwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode h324GwCallsAvailable */ + + if (pvalue->m.h324GwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->h324GwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode t120OnlyGwCallsAvailable */ + + if (pvalue->m.t120OnlyGwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->t120OnlyGwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode t38FaxAnnexbOnlyGwCallsAvailable */ + + if (pvalue->m.t38FaxAnnexbOnlyGwCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->t38FaxAnnexbOnlyGwCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode terminalCallsAvailable */ + + if (pvalue->m.terminalCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->terminalCallsAvailable); + if (stat != ASN_OK) return stat; + } + + /* encode mcuCallsAvailable */ + + if (pvalue->m.mcuCallsAvailablePresent) { + stat = asn1PE_H225_SeqOfH225CallsAvailable (pctxt, &pvalue->mcuCallsAvailable); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sipGwCallsAvailablePresent); + /* encode extension elements */ + + if (pvalue->m.sipGwCallsAvailablePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CallsAvailable (&lctxt, &pvalue->sipGwCallsAvailable); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallCapacity */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallCapacity (OOCTXT* pctxt, H225CallCapacity* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maximumCallCapacityPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.currentCallCapacityPresent); + + /* encode maximumCallCapacity */ + + if (pvalue->m.maximumCallCapacityPresent) { + stat = asn1PE_H225CallCapacityInfo (pctxt, &pvalue->maximumCallCapacity); + if (stat != ASN_OK) return stat; + } + + /* encode currentCallCapacity */ + + if (pvalue->m.currentCallCapacityPresent) { + stat = asn1PE_H225CallCapacityInfo (pctxt, &pvalue->currentCallCapacity); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225CicInfo_cic_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225CicInfo_cic_element (OOCTXT* pctxt, H225_SeqOfH225CicInfo_cic_element* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H225CicInfo_cic_element (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CicInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CicInfo (OOCTXT* pctxt, H225CicInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode cic */ + + stat = asn1PE_H225_SeqOfH225CicInfo_cic_element (pctxt, &pvalue->cic); + if (stat != ASN_OK) return stat; + + /* encode pointCode */ + + stat = asn1PE_H225CicInfo_pointCode (pctxt, &pvalue->pointCode); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* GroupID_member */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GroupID_member (OOCTXT* pctxt, H225GroupID_member* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 0U, 65535U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GroupID */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GroupID (OOCTXT* pctxt, H225GroupID* pvalue) +{ + static Asn1SizeCnst group_lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.memberPresent); + + /* encode member */ + + if (pvalue->m.memberPresent) { + stat = asn1PE_H225GroupID_member (pctxt, &pvalue->member); + if (stat != ASN_OK) return stat; + } + + /* encode group */ + + addSizeConstraint (pctxt, &group_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->group, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CircuitIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CircuitIdentifier (OOCTXT* pctxt, H225CircuitIdentifier* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.carrierPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cicPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.groupPresent); + + /* encode cic */ + + if (pvalue->m.cicPresent) { + stat = asn1PE_H225CicInfo (pctxt, &pvalue->cic); + if (stat != ASN_OK) return stat; + } + + /* encode group */ + + if (pvalue->m.groupPresent) { + stat = asn1PE_H225GroupID (pctxt, &pvalue->group); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.carrierPresent); + /* encode extension elements */ + + if (pvalue->m.carrierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CarrierInfo (&lctxt, &pvalue->carrier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225GenericData */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225GenericData (OOCTXT* pctxt, H225_SeqOfH225GenericData* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225GenericData (pctxt, ((H225GenericData*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CircuitInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CircuitInfo (OOCTXT* pctxt, H225CircuitInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceCircuitIDPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationCircuitIDPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + + /* encode sourceCircuitID */ + + if (pvalue->m.sourceCircuitIDPresent) { + stat = asn1PE_H225CircuitIdentifier (pctxt, &pvalue->sourceCircuitID); + if (stat != ASN_OK) return stat; + } + + /* encode destinationCircuitID */ + + if (pvalue->m.destinationCircuitIDPresent) { + stat = asn1PE_H225CircuitIdentifier (pctxt, &pvalue->destinationCircuitID); + if (stat != ASN_OK) return stat; + } + + /* encode genericData */ + + if (pvalue->m.genericDataPresent) { + stat = asn1PE_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225FeatureDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225FeatureDescriptor (OOCTXT* pctxt, H225_SeqOfH225FeatureDescriptor* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225FeatureDescriptor (pctxt, ((H225FeatureDescriptor*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Setup_UUIE_parallelH245Control */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Setup_UUIE_parallelH245Control (OOCTXT* pctxt, H225Setup_UUIE_parallelH245Control* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ExtendedAliasAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ExtendedAliasAddress (OOCTXT* pctxt, H225ExtendedAliasAddress* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent); + + /* encode address */ + + stat = asn1PE_H225AliasAddress (pctxt, &pvalue->address); + if (stat != ASN_OK) return stat; + + /* encode presentationIndicator */ + + if (pvalue->m.presentationIndicatorPresent) { + stat = asn1PE_H225PresentationIndicator (pctxt, &pvalue->presentationIndicator); + if (stat != ASN_OK) return stat; + } + + /* encode screeningIndicator */ + + if (pvalue->m.screeningIndicatorPresent) { + stat = asn1PE_H225ScreeningIndicator (pctxt, pvalue->screeningIndicator); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225ExtendedAliasAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225ExtendedAliasAddress (OOCTXT* pctxt, H225_SeqOfH225ExtendedAliasAddress* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225ExtendedAliasAddress (pctxt, ((H225ExtendedAliasAddress*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Setup_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Setup_UUIE (OOCTXT* pctxt, H225Setup_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.sourceCallSignalAddressPresent || + pvalue->m.remoteExtensionAddressPresent || + pvalue->m.callIdentifierPresent || + pvalue->m.h245SecurityCapabilityPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.fastStartPresent || + pvalue->m.mediaWaitForConnectPresent || + pvalue->m.canOverlapSendPresent || + pvalue->m.endpointIdentifierPresent || + pvalue->m.multipleCallsPresent || + pvalue->m.maintainConnectionPresent || + pvalue->m.connectionParametersPresent || + pvalue->m.languagePresent || + pvalue->m.presentationIndicatorPresent || + pvalue->m.screeningIndicatorPresent || + pvalue->m.serviceControlPresent || + pvalue->m.symmetricOperationRequiredPresent || + pvalue->m.capacityPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.desiredProtocolsPresent || + pvalue->m.neededFeaturesPresent || + pvalue->m.desiredFeaturesPresent || + pvalue->m.supportedFeaturesPresent || + pvalue->m.parallelH245ControlPresent || + pvalue->m.additionalSourceAddressesPresent || + pvalue->m.hopCountPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destCallSignalAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCRVPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callServicesPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode h245Address */ + + if (pvalue->m.h245AddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address); + if (stat != ASN_OK) return stat; + } + + /* encode sourceAddress */ + + if (pvalue->m.sourceAddressPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->sourceAddress); + if (stat != ASN_OK) return stat; + } + + /* encode sourceInfo */ + + stat = asn1PE_H225EndpointType (pctxt, &pvalue->sourceInfo); + if (stat != ASN_OK) return stat; + + /* encode destinationAddress */ + + if (pvalue->m.destinationAddressPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationAddress); + if (stat != ASN_OK) return stat; + } + + /* encode destCallSignalAddress */ + + if (pvalue->m.destCallSignalAddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress); + if (stat != ASN_OK) return stat; + } + + /* encode destExtraCallInfo */ + + if (pvalue->m.destExtraCallInfoPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo); + if (stat != ASN_OK) return stat; + } + + /* encode destExtraCRV */ + + if (pvalue->m.destExtraCRVPresent) { + stat = asn1PE_H225_SeqOfH225CallReferenceValue (pctxt, &pvalue->destExtraCRV); + if (stat != ASN_OK) return stat; + } + + /* encode activeMC */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->activeMC); + if (stat != ASN_OK) return stat; + + /* encode conferenceID */ + + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + + /* encode conferenceGoal */ + + stat = asn1PE_H225Setup_UUIE_conferenceGoal (pctxt, &pvalue->conferenceGoal); + if (stat != ASN_OK) return stat; + + /* encode callServices */ + + if (pvalue->m.callServicesPresent) { + stat = asn1PE_H225QseriesOptions (pctxt, &pvalue->callServices); + if (stat != ASN_OK) return stat; + } + + /* encode callType */ + + stat = asn1PE_H225CallType (pctxt, &pvalue->callType); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 26); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceCallSignalAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaWaitForConnectPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.canOverlapSendPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.connectionParametersPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.languagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.symmetricOperationRequiredPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredProtocolsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.neededFeaturesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredFeaturesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedFeaturesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.parallelH245ControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.additionalSourceAddressesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.hopCountPresent); + /* encode extension elements */ + + if (pvalue->m.sourceCallSignalAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225TransportAddress (&lctxt, &pvalue->sourceCallSignalAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.remoteExtensionAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AliasAddress (&lctxt, &pvalue->remoteExtensionAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h245SecurityCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225H245Security (&lctxt, &pvalue->h245SecurityCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastStartPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Setup_UUIE_fastStart (&lctxt, &pvalue->fastStart); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.mediaWaitForConnectPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->mediaWaitForConnect); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.canOverlapSendPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canOverlapSend); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.endpointIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225EndpointIdentifier (&lctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.maintainConnectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.connectionParametersPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Setup_UUIE_connectionParameters (&lctxt, &pvalue->connectionParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.languagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Setup_UUIE_language (&lctxt, &pvalue->language); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.presentationIndicatorPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225PresentationIndicator (&lctxt, &pvalue->presentationIndicator); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.screeningIndicatorPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ScreeningIndicator (&lctxt, pvalue->screeningIndicator); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.symmetricOperationRequiredPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.desiredProtocolsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->desiredProtocols); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.neededFeaturesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225FeatureDescriptor (&lctxt, &pvalue->neededFeatures); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.desiredFeaturesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225FeatureDescriptor (&lctxt, &pvalue->desiredFeatures); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedFeaturesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225FeatureDescriptor (&lctxt, &pvalue->supportedFeatures); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.parallelH245ControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Setup_UUIE_parallelH245Control (&lctxt, &pvalue->parallelH245Control); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.additionalSourceAddressesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ExtendedAliasAddress (&lctxt, &pvalue->additionalSourceAddresses); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.hopCountPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->hopCount, 1U, 31U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallProceeding_UUIE_fastStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallProceeding_UUIE_fastStart (OOCTXT* pctxt, H225CallProceeding_UUIE_fastStart* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FeatureSet */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225FeatureSet (OOCTXT* pctxt, H225FeatureSet* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.neededFeaturesPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredFeaturesPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedFeaturesPresent); + + /* encode replacementFeatureSet */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->replacementFeatureSet); + if (stat != ASN_OK) return stat; + + /* encode neededFeatures */ + + if (pvalue->m.neededFeaturesPresent) { + stat = asn1PE_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->neededFeatures); + if (stat != ASN_OK) return stat; + } + + /* encode desiredFeatures */ + + if (pvalue->m.desiredFeaturesPresent) { + stat = asn1PE_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->desiredFeatures); + if (stat != ASN_OK) return stat; + } + + /* encode supportedFeatures */ + + if (pvalue->m.supportedFeaturesPresent) { + stat = asn1PE_H225_SeqOfH225FeatureDescriptor (pctxt, &pvalue->supportedFeatures); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallProceeding_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallProceeding_UUIE (OOCTXT* pctxt, H225CallProceeding_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.h245SecurityModePresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.fastStartPresent || + pvalue->m.multipleCallsPresent || + pvalue->m.maintainConnectionPresent || + pvalue->m.fastConnectRefusedPresent || + pvalue->m.featureSetPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode destinationInfo */ + + stat = asn1PE_H225EndpointType (pctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return stat; + + /* encode h245Address */ + + if (pvalue->m.h245AddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 8); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h245SecurityModePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225H245Security (&lctxt, &pvalue->h245SecurityMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastStartPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallProceeding_UUIE_fastStart (&lctxt, &pvalue->fastStart); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.maintainConnectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastConnectRefusedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Connect_UUIE_fastStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Connect_UUIE_fastStart (OOCTXT* pctxt, H225Connect_UUIE_fastStart* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Connect_UUIE_language */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Connect_UUIE_language (OOCTXT* pctxt, H225Connect_UUIE_language* pvalue) +{ + static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + addSizeConstraint (pctxt, &element_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->elem[xx1], 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Connect_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Connect_UUIE (OOCTXT* pctxt, H225Connect_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.h245SecurityModePresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.fastStartPresent || + pvalue->m.multipleCallsPresent || + pvalue->m.maintainConnectionPresent || + pvalue->m.languagePresent || + pvalue->m.connectedAddressPresent || + pvalue->m.presentationIndicatorPresent || + pvalue->m.screeningIndicatorPresent || + pvalue->m.fastConnectRefusedPresent || + pvalue->m.serviceControlPresent || + pvalue->m.capacityPresent || + pvalue->m.featureSetPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode h245Address */ + + if (pvalue->m.h245AddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address); + if (stat != ASN_OK) return stat; + } + + /* encode destinationInfo */ + + stat = asn1PE_H225EndpointType (pctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return stat; + + /* encode conferenceID */ + + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 14); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.languagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.connectedAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h245SecurityModePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225H245Security (&lctxt, &pvalue->h245SecurityMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastStartPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Connect_UUIE_fastStart (&lctxt, &pvalue->fastStart); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.maintainConnectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.languagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Connect_UUIE_language (&lctxt, &pvalue->language); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.connectedAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->connectedAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.presentationIndicatorPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225PresentationIndicator (&lctxt, &pvalue->presentationIndicator); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.screeningIndicatorPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ScreeningIndicator (&lctxt, pvalue->screeningIndicator); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastConnectRefusedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Alerting_UUIE_fastStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Alerting_UUIE_fastStart (OOCTXT* pctxt, H225Alerting_UUIE_fastStart* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Alerting_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Alerting_UUIE (OOCTXT* pctxt, H225Alerting_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.h245SecurityModePresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.fastStartPresent || + pvalue->m.multipleCallsPresent || + pvalue->m.maintainConnectionPresent || + pvalue->m.alertingAddressPresent || + pvalue->m.presentationIndicatorPresent || + pvalue->m.screeningIndicatorPresent || + pvalue->m.fastConnectRefusedPresent || + pvalue->m.serviceControlPresent || + pvalue->m.capacityPresent || + pvalue->m.featureSetPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode destinationInfo */ + + stat = asn1PE_H225EndpointType (pctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return stat; + + /* encode h245Address */ + + if (pvalue->m.h245AddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 13); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alertingAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h245SecurityModePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225H245Security (&lctxt, &pvalue->h245SecurityMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastStartPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Alerting_UUIE_fastStart (&lctxt, &pvalue->fastStart); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.maintainConnectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.alertingAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->alertingAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.presentationIndicatorPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225PresentationIndicator (&lctxt, &pvalue->presentationIndicator); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.screeningIndicatorPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ScreeningIndicator (&lctxt, pvalue->screeningIndicator); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastConnectRefusedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Information_UUIE_fastStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Information_UUIE_fastStart (OOCTXT* pctxt, H225Information_UUIE_fastStart* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Information_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Information_UUIE (OOCTXT* pctxt, H225Information_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.fastStartPresent || + pvalue->m.fastConnectRefusedPresent || + pvalue->m.circuitInfoPresent); + + encodeBit (pctxt, extbit); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 5); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastStartPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Information_UUIE_fastStart (&lctxt, &pvalue->fastStart); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastConnectRefusedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SecurityErrors */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225SecurityErrors (OOCTXT* pctxt, H225SecurityErrors* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 16); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 15); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* securityWrongSyncTime */ + case 1: + /* NULL */ + break; + + /* securityReplay */ + case 2: + /* NULL */ + break; + + /* securityWrongGeneralID */ + case 3: + /* NULL */ + break; + + /* securityWrongSendersID */ + case 4: + /* NULL */ + break; + + /* securityIntegrityFailed */ + case 5: + /* NULL */ + break; + + /* securityWrongOID */ + case 6: + /* NULL */ + break; + + /* securityDHmismatch */ + case 7: + /* NULL */ + break; + + /* securityCertificateExpired */ + case 8: + /* NULL */ + break; + + /* securityCertificateDateInvalid */ + case 9: + /* NULL */ + break; + + /* securityCertificateRevoked */ + case 10: + /* NULL */ + break; + + /* securityCertificateNotReadable */ + case 11: + /* NULL */ + break; + + /* securityCertificateSignatureInvalid */ + case 12: + /* NULL */ + break; + + /* securityCertificateMissing */ + case 13: + /* NULL */ + break; + + /* securityCertificateIncomplete */ + case 14: + /* NULL */ + break; + + /* securityUnsupportedCertificateAlgOID */ + case 15: + /* NULL */ + break; + + /* securityUnknownCA */ + case 16: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 17); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ReleaseCompleteReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ReleaseCompleteReason (OOCTXT* pctxt, H225ReleaseCompleteReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 12); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 11); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noBandwidth */ + case 1: + /* NULL */ + break; + + /* gatekeeperResources */ + case 2: + /* NULL */ + break; + + /* unreachableDestination */ + case 3: + /* NULL */ + break; + + /* destinationRejection */ + case 4: + /* NULL */ + break; + + /* invalidRevision */ + case 5: + /* NULL */ + break; + + /* noPermission */ + case 6: + /* NULL */ + break; + + /* unreachableGatekeeper */ + case 7: + /* NULL */ + break; + + /* gatewayResources */ + case 8: + /* NULL */ + break; + + /* badFormatAddress */ + case 9: + /* NULL */ + break; + + /* adaptiveBusy */ + case 10: + /* NULL */ + break; + + /* inConf */ + case 11: + /* NULL */ + break; + + /* undefinedReason */ + case 12: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 13); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* facilityCallDeflection */ + case 13: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityDenied */ + case 14: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* calledPartyNotRegistered */ + case 15: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* callerNotRegistered */ + case 16: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* newConnectionNeeded */ + case 17: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* nonStandardReason */ + case 18: + stat = asn1PE_H225NonStandardParameter (&lctxt, pvalue->u.nonStandardReason); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* replaceWithConferenceInvite */ + case 19: + stat = asn1PE_H225ConferenceIdentifier (&lctxt, pvalue->u.replaceWithConferenceInvite); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericDataReason */ + case 20: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* neededFeatureNotSupported */ + case 21: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* tunnelledSignallingRejected */ + case 22: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* invalidCID */ + case 23: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityError */ + case 24: + stat = asn1PE_H225SecurityErrors (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* hopCountExceeded */ + case 25: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ReleaseComplete_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ReleaseComplete_UUIE (OOCTXT* pctxt, H225ReleaseComplete_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.busyAddressPresent || + pvalue->m.presentationIndicatorPresent || + pvalue->m.screeningIndicatorPresent || + pvalue->m.capacityPresent || + pvalue->m.serviceControlPresent || + pvalue->m.featureSetPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.reasonPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode reason */ + + if (pvalue->m.reasonPresent) { + stat = asn1PE_H225ReleaseCompleteReason (pctxt, &pvalue->reason); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 8); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.busyAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.presentationIndicatorPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.screeningIndicatorPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.busyAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->busyAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.presentationIndicatorPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225PresentationIndicator (&lctxt, &pvalue->presentationIndicator); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.screeningIndicatorPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ScreeningIndicator (&lctxt, pvalue->screeningIndicator); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FacilityReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225FacilityReason (OOCTXT* pctxt, H225FacilityReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* routeCallToGatekeeper */ + case 1: + /* NULL */ + break; + + /* callForwarded */ + case 2: + /* NULL */ + break; + + /* routeCallToMC */ + case 3: + /* NULL */ + break; + + /* undefinedReason */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* conferenceListChoice */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* startH245 */ + case 6: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* noH245 */ + case 7: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* newTokens */ + case 8: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* featureSetUpdate */ + case 9: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* forwardedElements */ + case 10: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* transportedInformation */ + case 11: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceList */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ConferenceList (OOCTXT* pctxt, H225ConferenceList* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.conferenceIDPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.conferenceAliasPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode conferenceID */ + + if (pvalue->m.conferenceIDPresent) { + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + } + + /* encode conferenceAlias */ + + if (pvalue->m.conferenceAliasPresent) { + stat = asn1PE_H225AliasAddress (pctxt, &pvalue->conferenceAlias); + if (stat != ASN_OK) return stat; + } + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225ConferenceList */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225ConferenceList (OOCTXT* pctxt, H225_SeqOfH225ConferenceList* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225ConferenceList (pctxt, ((H225ConferenceList*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Facility_UUIE_fastStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Facility_UUIE_fastStart (OOCTXT* pctxt, H225Facility_UUIE_fastStart* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Facility_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Facility_UUIE (OOCTXT* pctxt, H225Facility_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.destExtraCallInfoPresent || + pvalue->m.remoteExtensionAddressPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.conferencesPresent || + pvalue->m.h245AddressPresent || + pvalue->m.fastStartPresent || + pvalue->m.multipleCallsPresent || + pvalue->m.maintainConnectionPresent || + pvalue->m.fastConnectRefusedPresent || + pvalue->m.serviceControlPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.featureSetPresent || + pvalue->m.destinationInfoPresent || + pvalue->m.h245SecurityModePresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternativeAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternativeAliasAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.conferenceIDPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode alternativeAddress */ + + if (pvalue->m.alternativeAddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->alternativeAddress); + if (stat != ASN_OK) return stat; + } + + /* encode alternativeAliasAddress */ + + if (pvalue->m.alternativeAliasAddressPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->alternativeAliasAddress); + if (stat != ASN_OK) return stat; + } + + /* encode conferenceID */ + + if (pvalue->m.conferenceIDPresent) { + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + } + + /* encode reason */ + + stat = asn1PE_H225FacilityReason (pctxt, &pvalue->reason); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 15); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.conferencesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.destExtraCallInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destExtraCallInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.remoteExtensionAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AliasAddress (&lctxt, &pvalue->remoteExtensionAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.conferencesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ConferenceList (&lctxt, &pvalue->conferences); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h245AddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225TransportAddress (&lctxt, &pvalue->h245Address); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastStartPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225Facility_UUIE_fastStart (&lctxt, &pvalue->fastStart); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.maintainConnectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastConnectRefusedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.destinationInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225EndpointType (&lctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h245SecurityModePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225H245Security (&lctxt, &pvalue->h245SecurityMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Progress_UUIE_fastStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Progress_UUIE_fastStart (OOCTXT* pctxt, H225Progress_UUIE_fastStart* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Progress_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Progress_UUIE (OOCTXT* pctxt, H225Progress_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.multipleCallsPresent || + pvalue->m.maintainConnectionPresent || + pvalue->m.fastConnectRefusedPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245AddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245SecurityModePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastStartPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode destinationInfo */ + + stat = asn1PE_H225EndpointType (pctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return stat; + + /* encode h245Address */ + + if (pvalue->m.h245AddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->h245Address); + if (stat != ASN_OK) return stat; + } + + /* encode callIdentifier */ + + stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return stat; + + /* encode h245SecurityMode */ + + if (pvalue->m.h245SecurityModePresent) { + stat = asn1PE_H225H245Security (pctxt, &pvalue->h245SecurityMode); + if (stat != ASN_OK) return stat; + } + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode fastStart */ + + if (pvalue->m.fastStartPresent) { + stat = asn1PE_H225Progress_UUIE_fastStart (pctxt, &pvalue->fastStart); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 2); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.fastConnectRefusedPresent); + /* encode extension elements */ + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.maintainConnectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.fastConnectRefusedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Status_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Status_UUIE (OOCTXT* pctxt, H225Status_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode callIdentifier */ + + stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return stat; + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* StatusInquiry_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225StatusInquiry_UUIE (OOCTXT* pctxt, H225StatusInquiry_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode callIdentifier */ + + stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return stat; + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SetupAcknowledge_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225SetupAcknowledge_UUIE (OOCTXT* pctxt, H225SetupAcknowledge_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode callIdentifier */ + + stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return stat; + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Notify_UUIE */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Notify_UUIE (OOCTXT* pctxt, H225Notify_UUIE* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode callIdentifier */ + + stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return stat; + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UU_PDU_h323_message_body */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323_UU_PDU_h323_message_body (OOCTXT* pctxt, H225H323_UU_PDU_h323_message_body* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 7); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* setup */ + case 1: + stat = asn1PE_H225Setup_UUIE (pctxt, pvalue->u.setup); + if (stat != ASN_OK) return stat; + break; + + /* callProceeding */ + case 2: + stat = asn1PE_H225CallProceeding_UUIE (pctxt, pvalue->u.callProceeding); + if (stat != ASN_OK) return stat; + break; + + /* connect */ + case 3: + stat = asn1PE_H225Connect_UUIE (pctxt, pvalue->u.connect); + if (stat != ASN_OK) return stat; + break; + + /* alerting */ + case 4: + stat = asn1PE_H225Alerting_UUIE (pctxt, pvalue->u.alerting); + if (stat != ASN_OK) return stat; + break; + + /* information */ + case 5: + stat = asn1PE_H225Information_UUIE (pctxt, pvalue->u.information); + if (stat != ASN_OK) return stat; + break; + + /* releaseComplete */ + case 6: + stat = asn1PE_H225ReleaseComplete_UUIE (pctxt, pvalue->u.releaseComplete); + if (stat != ASN_OK) return stat; + break; + + /* facility */ + case 7: + stat = asn1PE_H225Facility_UUIE (pctxt, pvalue->u.facility); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* progress */ + case 8: + stat = asn1PE_H225Progress_UUIE (&lctxt, pvalue->u.progress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* empty */ + case 9: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* status */ + case 10: + stat = asn1PE_H225Status_UUIE (&lctxt, pvalue->u.status); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* statusInquiry */ + case 11: + stat = asn1PE_H225StatusInquiry_UUIE (&lctxt, pvalue->u.statusInquiry); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* setupAcknowledge */ + case 12: + stat = asn1PE_H225SetupAcknowledge_UUIE (&lctxt, pvalue->u.setupAcknowledge); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* notify */ + case 13: + stat = asn1PE_H225Notify_UUIE (&lctxt, pvalue->u.notify); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UU_PDU_h4501SupplementaryService */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323_UU_PDU_h4501SupplementaryService (OOCTXT* pctxt, H225H323_UU_PDU_h4501SupplementaryService* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UU_PDU_h245Control */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323_UU_PDU_h245Control (OOCTXT* pctxt, H225H323_UU_PDU_h245Control* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225NonStandardParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225NonStandardParameter (OOCTXT* pctxt, H225_SeqOfH225NonStandardParameter* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225NonStandardParameter (pctxt, ((H225NonStandardParameter*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallLinkage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallLinkage (OOCTXT* pctxt, H225CallLinkage* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.globalCallIdPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.threadIdPresent); + + /* encode globalCallId */ + + if (pvalue->m.globalCallIdPresent) { + stat = asn1PE_H225GloballyUniqueID (pctxt, &pvalue->globalCallId); + if (stat != ASN_OK) return stat; + } + + /* encode threadId */ + + if (pvalue->m.threadIdPresent) { + stat = asn1PE_H225GloballyUniqueID (pctxt, &pvalue->threadId); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UU_PDU_tunnelledSignallingMessage_messageContent */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage_messageContent* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeOctetString (pctxt, pvalue->elem[xx1].numocts, pvalue->elem[xx1].data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UU_PDU_tunnelledSignallingMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage (OOCTXT* pctxt, H225H323_UU_PDU_tunnelledSignallingMessage* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tunnellingRequiredPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode tunnelledProtocolID */ + + stat = asn1PE_H225TunnelledProtocol (pctxt, &pvalue->tunnelledProtocolID); + if (stat != ASN_OK) return stat; + + /* encode messageContent */ + + stat = asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage_messageContent (pctxt, &pvalue->messageContent); + if (stat != ASN_OK) return stat; + + /* encode tunnellingRequired */ + + if (pvalue->m.tunnellingRequiredPresent) { + /* NULL */ + } + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* StimulusControl */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225StimulusControl (OOCTXT* pctxt, H225StimulusControl* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.isTextPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h248MessagePresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + /* encode isText */ + + if (pvalue->m.isTextPresent) { + /* NULL */ + } + + /* encode h248Message */ + + if (pvalue->m.h248MessagePresent) { + stat = encodeOctetString (pctxt, pvalue->h248Message.numocts, pvalue->h248Message.data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UU_PDU */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323_UU_PDU (OOCTXT* pctxt, H225H323_UU_PDU* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.h4501SupplementaryServicePresent || + pvalue->m.h245TunnelingPresent || + pvalue->m.h245ControlPresent || + pvalue->m.nonStandardControlPresent || + pvalue->m.callLinkagePresent || + pvalue->m.tunnelledSignallingMessagePresent || + pvalue->m.provisionalRespToH245TunnelingPresent || + pvalue->m.stimulusControlPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode h323_message_body */ + + stat = asn1PE_H225H323_UU_PDU_h323_message_body (pctxt, &pvalue->h323_message_body); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 8); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h4501SupplementaryServicePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245TunnelingPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h245ControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tunnelledSignallingMessagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.provisionalRespToH245TunnelingPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.stimulusControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.h4501SupplementaryServicePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225H323_UU_PDU_h4501SupplementaryService (&lctxt, &pvalue->h4501SupplementaryService); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h245TunnelingPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->h245Tunneling); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h245ControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225H323_UU_PDU_h245Control (&lctxt, &pvalue->h245Control); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.nonStandardControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225NonStandardParameter (&lctxt, &pvalue->nonStandardControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callLinkagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tunnelledSignallingMessagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225H323_UU_PDU_tunnelledSignallingMessage (&lctxt, &pvalue->tunnelledSignallingMessage); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.provisionalRespToH245TunnelingPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.stimulusControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225StimulusControl (&lctxt, &pvalue->stimulusControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UserInformation_user_data */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323_UserInformation_user_data (OOCTXT* pctxt, H225H323_UserInformation_user_data* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode protocol_discriminator */ + + stat = encodeConsUnsigned (pctxt, pvalue->protocol_discriminator, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode user_information */ + + stat = asn1PE_H225H323_UserInformation_user_data_user_information (pctxt, &pvalue->user_information); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H323_UserInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225H323_UserInformation (OOCTXT* pctxt, H225H323_UserInformation* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.user_dataPresent); + + /* encode h323_uu_pdu */ + + stat = asn1PE_H225H323_UU_PDU (pctxt, &pvalue->h323_uu_pdu); + if (stat != ASN_OK) return stat; + + /* encode user_data */ + + if (pvalue->m.user_dataPresent) { + stat = asn1PE_H225H323_UserInformation_user_data (pctxt, &pvalue->user_data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AddressPattern_range */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AddressPattern_range (OOCTXT* pctxt, H225AddressPattern_range* pvalue) +{ + int stat = ASN_OK; + + /* encode startOfRange */ + + stat = asn1PE_H225PartyNumber (pctxt, &pvalue->startOfRange); + if (stat != ASN_OK) return stat; + + /* encode endOfRange */ + + stat = asn1PE_H225PartyNumber (pctxt, &pvalue->endOfRange); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* AddressPattern */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AddressPattern (OOCTXT* pctxt, H225AddressPattern* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* wildcard */ + case 1: + stat = asn1PE_H225AliasAddress (pctxt, pvalue->u.wildcard); + if (stat != ASN_OK) return stat; + break; + + /* range */ + case 2: + stat = asn1PE_H225AddressPattern_range (pctxt, pvalue->u.range); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225TransportAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225TransportAddress (OOCTXT* pctxt, H225_SeqOfH225TransportAddress* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225TransportAddress (pctxt, ((H225TransportAddress*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AlternateTransportAddresses */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AlternateTransportAddresses (OOCTXT* pctxt, H225AlternateTransportAddresses* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.sctpPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.annexEPresent); + + /* encode annexE */ + + if (pvalue->m.annexEPresent) { + stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->annexE); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sctpPresent); + /* encode extension elements */ + + if (pvalue->m.sctpPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225TransportAddress (&lctxt, &pvalue->sctp); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Endpoint */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225Endpoint (OOCTXT* pctxt, H225Endpoint* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.alternateTransportAddressesPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.featureSetPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.aliasAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callSignalAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rasAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointTypePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.priorityPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode aliasAddress */ + + if (pvalue->m.aliasAddressPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->aliasAddress); + if (stat != ASN_OK) return stat; + } + + /* encode callSignalAddress */ + + if (pvalue->m.callSignalAddressPresent) { + stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress); + if (stat != ASN_OK) return stat; + } + + /* encode rasAddress */ + + if (pvalue->m.rasAddressPresent) { + stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->rasAddress); + if (stat != ASN_OK) return stat; + } + + /* encode endpointType */ + + if (pvalue->m.endpointTypePresent) { + stat = asn1PE_H225EndpointType (pctxt, &pvalue->endpointType); + if (stat != ASN_OK) return stat; + } + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode priority */ + + if (pvalue->m.priorityPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->priority, 0U, 127U); + if (stat != ASN_OK) return stat; + + } + + /* encode remoteExtensionAddress */ + + if (pvalue->m.remoteExtensionAddressPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->remoteExtensionAddress); + if (stat != ASN_OK) return stat; + } + + /* encode destExtraCallInfo */ + + if (pvalue->m.destExtraCallInfoPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 2); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + /* encode extension elements */ + + if (pvalue->m.alternateTransportAddressesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UseSpecifiedTransport */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225UseSpecifiedTransport (OOCTXT* pctxt, H225UseSpecifiedTransport* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* tcp */ + case 1: + /* NULL */ + break; + + /* annexE */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* sctp */ + case 3: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AlternateGK */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AlternateGK (OOCTXT* pctxt, H225AlternateGK* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + + /* encode rasAddress */ + + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress); + if (stat != ASN_OK) return stat; + + /* encode gatekeeperIdentifier */ + + if (pvalue->m.gatekeeperIdentifierPresent) { + stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return stat; + } + + /* encode needToRegister */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->needToRegister); + if (stat != ASN_OK) return stat; + + /* encode priority */ + + stat = encodeConsUnsigned (pctxt, pvalue->priority, 0U, 127U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225AlternateGK */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225AlternateGK (OOCTXT* pctxt, H225_SeqOfH225AlternateGK* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225AlternateGK (pctxt, ((H225AlternateGK*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AltGKInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AltGKInfo (OOCTXT* pctxt, H225AltGKInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode alternateGatekeeper */ + + stat = asn1PE_H225_SeqOfH225AlternateGK (pctxt, &pvalue->alternateGatekeeper); + if (stat != ASN_OK) return stat; + + /* encode altGKisPermanent */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->altGKisPermanent); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* SecurityErrors2 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225SecurityErrors2 (OOCTXT* pctxt, H225SecurityErrors2* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* securityWrongSyncTime */ + case 1: + /* NULL */ + break; + + /* securityReplay */ + case 2: + /* NULL */ + break; + + /* securityWrongGeneralID */ + case 3: + /* NULL */ + break; + + /* securityWrongSendersID */ + case 4: + /* NULL */ + break; + + /* securityIntegrityFailed */ + case 5: + /* NULL */ + break; + + /* securityWrongOID */ + case 6: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptIntAlg */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225EncryptIntAlg (OOCTXT* pctxt, H225EncryptIntAlg* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* isoAlgorithm */ + case 2: + stat = encodeObjectIdentifier (pctxt, pvalue->u.isoAlgorithm); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonIsoIntegrityMechanism */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225NonIsoIntegrityMechanism (OOCTXT* pctxt, H225NonIsoIntegrityMechanism* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* hMAC_MD5 */ + case 1: + /* NULL */ + break; + + /* hMAC_iso10118_2_s */ + case 2: + stat = asn1PE_H225EncryptIntAlg (pctxt, pvalue->u.hMAC_iso10118_2_s); + if (stat != ASN_OK) return stat; + break; + + /* hMAC_iso10118_2_l */ + case 3: + stat = asn1PE_H225EncryptIntAlg (pctxt, pvalue->u.hMAC_iso10118_2_l); + if (stat != ASN_OK) return stat; + break; + + /* hMAC_iso10118_3 */ + case 4: + stat = encodeObjectIdentifier (pctxt, pvalue->u.hMAC_iso10118_3); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IntegrityMechanism */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225IntegrityMechanism (OOCTXT* pctxt, H225IntegrityMechanism* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H225NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* digSig */ + case 2: + /* NULL */ + break; + + /* iso9797 */ + case 3: + stat = encodeObjectIdentifier (pctxt, pvalue->u.iso9797); + if (stat != ASN_OK) return stat; + break; + + /* nonIsoIM */ + case 4: + stat = asn1PE_H225NonIsoIntegrityMechanism (pctxt, pvalue->u.nonIsoIM); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ICV */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ICV (OOCTXT* pctxt, H225ICV* pvalue) +{ + int stat = ASN_OK; + + /* encode algorithmOID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->algorithmOID); + if (stat != ASN_OK) return stat; + + /* encode icv */ + + stat = encodeBitString (pctxt, pvalue->icv.numbits, pvalue->icv.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapacityReportingCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CapacityReportingCapability (OOCTXT* pctxt, H225CapacityReportingCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode canReportCallCapacity */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->canReportCallCapacity); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapacityReportingSpecification_when */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CapacityReportingSpecification_when (OOCTXT* pctxt, H225CapacityReportingSpecification_when* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callStartPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callEndPresent); + + /* encode callStart */ + + if (pvalue->m.callStartPresent) { + /* NULL */ + } + + /* encode callEnd */ + + if (pvalue->m.callEndPresent) { + /* NULL */ + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapacityReportingSpecification */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CapacityReportingSpecification (OOCTXT* pctxt, H225CapacityReportingSpecification* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode when */ + + stat = asn1PE_H225CapacityReportingSpecification_when (pctxt, &pvalue->when); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RasUsageInfoTypes */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RasUsageInfoTypes (OOCTXT* pctxt, H225RasUsageInfoTypes* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.startTimePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endTimePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminationCausePresent); + + /* encode nonStandardUsageTypes */ + + stat = asn1PE_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardUsageTypes); + if (stat != ASN_OK) return stat; + + /* encode startTime */ + + if (pvalue->m.startTimePresent) { + /* NULL */ + } + + /* encode endTime */ + + if (pvalue->m.endTimePresent) { + /* NULL */ + } + + /* encode terminationCause */ + + if (pvalue->m.terminationCausePresent) { + /* NULL */ + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RasUsageSpecification_when */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RasUsageSpecification_when (OOCTXT* pctxt, H225RasUsageSpecification_when* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.startPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.inIrrPresent); + + /* encode start */ + + if (pvalue->m.startPresent) { + /* NULL */ + } + + /* encode end */ + + if (pvalue->m.endPresent) { + /* NULL */ + } + + /* encode inIrr */ + + if (pvalue->m.inIrrPresent) { + /* NULL */ + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RasUsageSpecification_callStartingPoint */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RasUsageSpecification_callStartingPoint (OOCTXT* pctxt, H225RasUsageSpecification_callStartingPoint* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alertingPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.connectPresent); + + /* encode alerting */ + + if (pvalue->m.alertingPresent) { + /* NULL */ + } + + /* encode connect */ + + if (pvalue->m.connectPresent) { + /* NULL */ + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RasUsageSpecification */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RasUsageSpecification (OOCTXT* pctxt, H225RasUsageSpecification* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callStartingPointPresent); + + /* encode when */ + + stat = asn1PE_H225RasUsageSpecification_when (pctxt, &pvalue->when); + if (stat != ASN_OK) return stat; + + /* encode callStartingPoint */ + + if (pvalue->m.callStartingPointPresent) { + stat = asn1PE_H225RasUsageSpecification_callStartingPoint (pctxt, &pvalue->callStartingPoint); + if (stat != ASN_OK) return stat; + } + + /* encode required */ + + stat = asn1PE_H225RasUsageInfoTypes (pctxt, &pvalue->required); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RasUsageInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RasUsageInformation (OOCTXT* pctxt, H225RasUsageInformation* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alertingTimePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.connectTimePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endTimePresent); + + /* encode nonStandardUsageFields */ + + stat = asn1PE_H225_SeqOfH225NonStandardParameter (pctxt, &pvalue->nonStandardUsageFields); + if (stat != ASN_OK) return stat; + + /* encode alertingTime */ + + if (pvalue->m.alertingTimePresent) { + stat = asn1PE_H235TimeStamp (pctxt, pvalue->alertingTime); + if (stat != ASN_OK) return stat; + } + + /* encode connectTime */ + + if (pvalue->m.connectTimePresent) { + stat = asn1PE_H235TimeStamp (pctxt, pvalue->connectTime); + if (stat != ASN_OK) return stat; + } + + /* encode endTime */ + + if (pvalue->m.endTimePresent) { + stat = asn1PE_H235TimeStamp (pctxt, pvalue->endTime); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallTerminationCause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallTerminationCause (OOCTXT* pctxt, H225CallTerminationCause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* releaseCompleteReason */ + case 1: + stat = asn1PE_H225ReleaseCompleteReason (pctxt, pvalue->u.releaseCompleteReason); + if (stat != ASN_OK) return stat; + break; + + /* releaseCompleteCauseIE */ + case 2: + stat = asn1PE_H225CallTerminationCause_releaseCompleteCauseIE (pctxt, pvalue->u.releaseCompleteCauseIE); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportChannelInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportChannelInfo (OOCTXT* pctxt, H225TransportChannelInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sendAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.recvAddressPresent); + + /* encode sendAddress */ + + if (pvalue->m.sendAddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->sendAddress); + if (stat != ASN_OK) return stat; + } + + /* encode recvAddress */ + + if (pvalue->m.recvAddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->recvAddress); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* BandwidthDetails */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225BandwidthDetails (OOCTXT* pctxt, H225BandwidthDetails* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sender */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->sender); + if (stat != ASN_OK) return stat; + + /* encode multicast */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multicast); + if (stat != ASN_OK) return stat; + + /* encode bandwidth */ + + stat = asn1PE_H225BandWidth (pctxt, pvalue->bandwidth); + if (stat != ASN_OK) return stat; + + /* encode rtcpAddresses */ + + stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->rtcpAddresses); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallCreditCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallCreditCapability (OOCTXT* pctxt, H225CallCreditCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.canDisplayAmountStringPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.canEnforceDurationLimitPresent); + + /* encode canDisplayAmountString */ + + if (pvalue->m.canDisplayAmountStringPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->canDisplayAmountString); + if (stat != ASN_OK) return stat; + } + + /* encode canEnforceDurationLimit */ + + if (pvalue->m.canEnforceDurationLimitPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->canEnforceDurationLimit); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPSession_associatedSessionIds */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RTPSession_associatedSessionIds (OOCTXT* pctxt, H225RTPSession_associatedSessionIds* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 1U, 255U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPSession */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RTPSession (OOCTXT* pctxt, H225RTPSession* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.multicastPresent || + pvalue->m.bandwidthPresent); + + encodeBit (pctxt, extbit); + + /* encode rtpAddress */ + + stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->rtpAddress); + if (stat != ASN_OK) return stat; + + /* encode rtcpAddress */ + + stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->rtcpAddress); + if (stat != ASN_OK) return stat; + + /* encode cname */ + + stat = encodeConstrainedStringEx (pctxt, pvalue->cname, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + + /* encode ssrc */ + + stat = encodeConsUnsigned (pctxt, pvalue->ssrc, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + /* encode sessionId */ + + stat = encodeConsUnsigned (pctxt, pvalue->sessionId, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode associatedSessionIds */ + + stat = asn1PE_H225RTPSession_associatedSessionIds (pctxt, &pvalue->associatedSessionIds); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multicastPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bandwidthPresent); + /* encode extension elements */ + + if (pvalue->m.multicastPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.bandwidthPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225BandWidth (&lctxt, pvalue->bandwidth); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225Endpoint */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225Endpoint (OOCTXT* pctxt, H225_SeqOfH225Endpoint* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225Endpoint (pctxt, ((H225Endpoint*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225AuthenticationMechanism */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225AuthenticationMechanism (OOCTXT* pctxt, H225_SeqOfH225AuthenticationMechanism* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H235AuthenticationMechanism (pctxt, ((H235AuthenticationMechanism*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GatekeeperRequest_algorithmOIDs */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GatekeeperRequest_algorithmOIDs (OOCTXT* pctxt, H225GatekeeperRequest_algorithmOIDs* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeObjectIdentifier (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225IntegrityMechanism */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225IntegrityMechanism (OOCTXT* pctxt, H225_SeqOfH225IntegrityMechanism* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225IntegrityMechanism (pctxt, ((H225IntegrityMechanism*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GatekeeperRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GatekeeperRequest (OOCTXT* pctxt, H225GatekeeperRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.alternateEndpointsPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.authenticationCapabilityPresent || + pvalue->m.algorithmOIDsPresent || + pvalue->m.integrityPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.supportsAltGKPresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callServicesPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointAliasPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode rasAddress */ + + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress); + if (stat != ASN_OK) return stat; + + /* encode endpointType */ + + stat = asn1PE_H225EndpointType (pctxt, &pvalue->endpointType); + if (stat != ASN_OK) return stat; + + /* encode gatekeeperIdentifier */ + + if (pvalue->m.gatekeeperIdentifierPresent) { + stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return stat; + } + + /* encode callServices */ + + if (pvalue->m.callServicesPresent) { + stat = asn1PE_H225QseriesOptions (pctxt, &pvalue->callServices); + if (stat != ASN_OK) return stat; + } + + /* encode endpointAlias */ + + if (pvalue->m.endpointAliasPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 9); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.authenticationCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.algorithmOIDsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportsAltGKPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.alternateEndpointsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.authenticationCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AuthenticationMechanism (&lctxt, &pvalue->authenticationCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.algorithmOIDsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225GatekeeperRequest_algorithmOIDs (&lctxt, &pvalue->algorithmOIDs); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225IntegrityMechanism (&lctxt, &pvalue->integrity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportsAltGKPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GatekeeperConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GatekeeperConfirm (OOCTXT* pctxt, H225GatekeeperConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.alternateGatekeeperPresent || + pvalue->m.authenticationModePresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.algorithmOIDPresent || + pvalue->m.integrityPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode gatekeeperIdentifier */ + + if (pvalue->m.gatekeeperIdentifierPresent) { + stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return stat; + } + + /* encode rasAddress */ + + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 8); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateGatekeeperPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.authenticationModePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.algorithmOIDPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.alternateGatekeeperPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AlternateGK (&lctxt, &pvalue->alternateGatekeeper); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.authenticationModePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H235AuthenticationMechanism (&lctxt, &pvalue->authenticationMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.algorithmOIDPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeObjectIdentifier (&lctxt, &pvalue->algorithmOID); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225IntegrityMechanism (&lctxt, &pvalue->integrity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GatekeeperRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GatekeeperRejectReason (OOCTXT* pctxt, H225GatekeeperRejectReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* resourceUnavailable */ + case 1: + /* NULL */ + break; + + /* terminalExcluded */ + case 2: + /* NULL */ + break; + + /* invalidRevision */ + case 3: + /* NULL */ + break; + + /* undefinedReason */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* securityDenial */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericDataReason */ + case 6: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* neededFeatureNotSupported */ + case 7: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityError */ + case 8: + stat = asn1PE_H225SecurityErrors (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GatekeeperReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225GatekeeperReject (OOCTXT* pctxt, H225GatekeeperReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode gatekeeperIdentifier */ + + if (pvalue->m.gatekeeperIdentifierPresent) { + stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return stat; + } + + /* encode rejectReason */ + + stat = asn1PE_H225GatekeeperRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 5); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.altGKInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225AddressPattern */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225AddressPattern (OOCTXT* pctxt, H225_SeqOfH225AddressPattern* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225AddressPattern (pctxt, ((H225AddressPattern*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225H248PackagesDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225H248PackagesDescriptor (OOCTXT* pctxt, H225_SeqOfH225H248PackagesDescriptor* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H225H248PackagesDescriptor (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RegistrationRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RegistrationRequest (OOCTXT* pctxt, H225RegistrationRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.alternateEndpointsPresent || + pvalue->m.timeToLivePresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.keepAlivePresent || + pvalue->m.endpointIdentifierPresent || + pvalue->m.willSupplyUUIEsPresent || + pvalue->m.maintainConnectionPresent || + pvalue->m.alternateTransportAddressesPresent || + pvalue->m.additiveRegistrationPresent || + pvalue->m.terminalAliasPatternPresent || + pvalue->m.supportsAltGKPresent || + pvalue->m.usageReportingCapabilityPresent || + pvalue->m.multipleCallsPresent || + pvalue->m.supportedH248PackagesPresent || + pvalue->m.callCreditCapabilityPresent || + pvalue->m.capacityReportingCapabilityPresent || + pvalue->m.capacityPresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent || + pvalue->m.restartPresent || + pvalue->m.supportsACFSequencesPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode discoveryComplete */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->discoveryComplete); + if (stat != ASN_OK) return stat; + + /* encode callSignalAddress */ + + stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress); + if (stat != ASN_OK) return stat; + + /* encode rasAddress */ + + stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->rasAddress); + if (stat != ASN_OK) return stat; + + /* encode terminalType */ + + stat = asn1PE_H225EndpointType (pctxt, &pvalue->terminalType); + if (stat != ASN_OK) return stat; + + /* encode terminalAlias */ + + if (pvalue->m.terminalAliasPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias); + if (stat != ASN_OK) return stat; + } + + /* encode gatekeeperIdentifier */ + + if (pvalue->m.gatekeeperIdentifierPresent) { + stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return stat; + } + + /* encode endpointVendor */ + + stat = asn1PE_H225VendorIdentifier (pctxt, &pvalue->endpointVendor); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 22); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.timeToLivePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.keepAlivePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.willSupplyUUIEsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.additiveRegistrationPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPatternPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportsAltGKPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageReportingCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedH248PackagesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callCreditCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityReportingCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.restartPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportsACFSequencesPresent); + /* encode extension elements */ + + if (pvalue->m.alternateEndpointsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.timeToLivePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225TimeToLive (&lctxt, pvalue->timeToLive); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.keepAlivePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->keepAlive); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.endpointIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225EndpointIdentifier (&lctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.willSupplyUUIEsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->willSupplyUUIEs); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.maintainConnectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.alternateTransportAddressesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.additiveRegistrationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.terminalAliasPatternPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AddressPattern (&lctxt, &pvalue->terminalAliasPattern); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportsAltGKPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.usageReportingCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225RasUsageInfoTypes (&lctxt, &pvalue->usageReportingCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedH248PackagesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225H248PackagesDescriptor (&lctxt, &pvalue->supportedH248Packages); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callCreditCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCreditCapability (&lctxt, &pvalue->callCreditCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityReportingCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CapacityReportingCapability (&lctxt, &pvalue->capacityReportingCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.restartPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportsACFSequencesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RegistrationConfirm_preGrantedARQ */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RegistrationConfirm_preGrantedARQ (OOCTXT* pctxt, H225RegistrationConfirm_preGrantedARQ* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.irrFrequencyInCallPresent || + pvalue->m.totalBandwidthRestrictionPresent || + pvalue->m.alternateTransportAddressesPresent || + pvalue->m.useSpecifiedTransportPresent); + + encodeBit (pctxt, extbit); + + /* encode makeCall */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->makeCall); + if (stat != ASN_OK) return stat; + + /* encode useGKCallSignalAddressToMakeCall */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->useGKCallSignalAddressToMakeCall); + if (stat != ASN_OK) return stat; + + /* encode answerCall */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->answerCall); + if (stat != ASN_OK) return stat; + + /* encode useGKCallSignalAddressToAnswer */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->useGKCallSignalAddressToAnswer); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 3); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.irrFrequencyInCallPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.totalBandwidthRestrictionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.useSpecifiedTransportPresent); + /* encode extension elements */ + + if (pvalue->m.irrFrequencyInCallPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->irrFrequencyInCall, 1U, 65535U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.totalBandwidthRestrictionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225BandWidth (&lctxt, pvalue->totalBandwidthRestriction); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.alternateTransportAddressesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.useSpecifiedTransportPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225UseSpecifiedTransport (&lctxt, &pvalue->useSpecifiedTransport); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225RasUsageSpecification */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225RasUsageSpecification (OOCTXT* pctxt, H225_SeqOfH225RasUsageSpecification* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225RasUsageSpecification (pctxt, ((H225RasUsageSpecification*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RegistrationConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RegistrationConfirm (OOCTXT* pctxt, H225RegistrationConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.alternateGatekeeperPresent || + pvalue->m.timeToLivePresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.willRespondToIRRPresent || + pvalue->m.preGrantedARQPresent || + pvalue->m.maintainConnectionPresent || + pvalue->m.serviceControlPresent || + pvalue->m.supportsAdditiveRegistrationPresent || + pvalue->m.terminalAliasPatternPresent || + pvalue->m.supportedPrefixesPresent || + pvalue->m.usageSpecPresent || + pvalue->m.featureServerAliasPresent || + pvalue->m.capacityReportingSpecPresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode callSignalAddress */ + + stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress); + if (stat != ASN_OK) return stat; + + /* encode terminalAlias */ + + if (pvalue->m.terminalAliasPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias); + if (stat != ASN_OK) return stat; + } + + /* encode gatekeeperIdentifier */ + + if (pvalue->m.gatekeeperIdentifierPresent) { + stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return stat; + } + + /* encode endpointIdentifier */ + + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 16); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateGatekeeperPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.timeToLivePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.willRespondToIRRPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.preGrantedARQPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maintainConnectionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportsAdditiveRegistrationPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPatternPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageSpecPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureServerAliasPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityReportingSpecPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.alternateGatekeeperPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AlternateGK (&lctxt, &pvalue->alternateGatekeeper); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.timeToLivePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225TimeToLive (&lctxt, pvalue->timeToLive); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.willRespondToIRRPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->willRespondToIRR); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.preGrantedARQPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225RegistrationConfirm_preGrantedARQ (&lctxt, &pvalue->preGrantedARQ); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.maintainConnectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maintainConnection); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportsAdditiveRegistrationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.terminalAliasPatternPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AddressPattern (&lctxt, &pvalue->terminalAliasPattern); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.usageSpecPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225RasUsageSpecification (&lctxt, &pvalue->usageSpec); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureServerAliasPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AliasAddress (&lctxt, &pvalue->featureServerAlias); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityReportingSpecPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CapacityReportingSpecification (&lctxt, &pvalue->capacityReportingSpec); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RegistrationRejectReason_invalidTerminalAliases */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RegistrationRejectReason_invalidTerminalAliases (OOCTXT* pctxt, H225RegistrationRejectReason_invalidTerminalAliases* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalAliasPatternPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + + /* encode terminalAlias */ + + if (pvalue->m.terminalAliasPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->terminalAlias); + if (stat != ASN_OK) return stat; + } + + /* encode terminalAliasPattern */ + + if (pvalue->m.terminalAliasPatternPresent) { + stat = asn1PE_H225_SeqOfH225AddressPattern (pctxt, &pvalue->terminalAliasPattern); + if (stat != ASN_OK) return stat; + } + + /* encode supportedPrefixes */ + + if (pvalue->m.supportedPrefixesPresent) { + stat = asn1PE_H225_SeqOfH225SupportedPrefix (pctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RegistrationRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RegistrationRejectReason (OOCTXT* pctxt, H225RegistrationRejectReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 8); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* discoveryRequired */ + case 1: + /* NULL */ + break; + + /* invalidRevision */ + case 2: + /* NULL */ + break; + + /* invalidCallSignalAddress */ + case 3: + /* NULL */ + break; + + /* invalidRASAddress */ + case 4: + /* NULL */ + break; + + /* duplicateAlias */ + case 5: + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, pvalue->u.duplicateAlias); + if (stat != ASN_OK) return stat; + break; + + /* invalidTerminalType */ + case 6: + /* NULL */ + break; + + /* undefinedReason */ + case 7: + /* NULL */ + break; + + /* transportNotSupported */ + case 8: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* transportQOSNotSupported */ + case 9: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* resourceUnavailable */ + case 10: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* invalidAlias */ + case 11: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityDenial */ + case 12: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* fullRegistrationRequired */ + case 13: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* additiveRegistrationNotSupported */ + case 14: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* invalidTerminalAliases */ + case 15: + stat = asn1PE_H225RegistrationRejectReason_invalidTerminalAliases (&lctxt, pvalue->u.invalidTerminalAliases); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericDataReason */ + case 16: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* neededFeatureNotSupported */ + case 17: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityError */ + case 18: + stat = asn1PE_H225SecurityErrors (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RegistrationReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RegistrationReject (OOCTXT* pctxt, H225RegistrationReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode rejectReason */ + + stat = asn1PE_H225RegistrationRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + /* encode gatekeeperIdentifier */ + + if (pvalue->m.gatekeeperIdentifierPresent) { + stat = asn1PE_H225GatekeeperIdentifier (pctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 5); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.altGKInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnregRequestReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225UnregRequestReason (OOCTXT* pctxt, H225UnregRequestReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* reregistrationRequired */ + case 1: + /* NULL */ + break; + + /* ttlExpired */ + case 2: + /* NULL */ + break; + + /* securityDenial */ + case 3: + /* NULL */ + break; + + /* undefinedReason */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* maintenance */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityError */ + case 6: + stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnregistrationRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225UnregistrationRequest (OOCTXT* pctxt, H225UnregistrationRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.alternateEndpointsPresent || + pvalue->m.gatekeeperIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.reasonPresent || + pvalue->m.endpointAliasPatternPresent || + pvalue->m.supportedPrefixesPresent || + pvalue->m.alternateGatekeeperPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointAliasPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode callSignalAddress */ + + stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress); + if (stat != ASN_OK) return stat; + + /* encode endpointAlias */ + + if (pvalue->m.endpointAliasPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias); + if (stat != ASN_OK) return stat; + } + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode endpointIdentifier */ + + if (pvalue->m.endpointIdentifierPresent) { + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 9); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.reasonPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointAliasPatternPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedPrefixesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateGatekeeperPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.alternateEndpointsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.gatekeeperIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.reasonPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225UnregRequestReason (&lctxt, &pvalue->reason); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.endpointAliasPatternPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AddressPattern (&lctxt, &pvalue->endpointAliasPattern); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedPrefixesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedPrefix (&lctxt, &pvalue->supportedPrefixes); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.alternateGatekeeperPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AlternateGK (&lctxt, &pvalue->alternateGatekeeper); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnregistrationConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225UnregistrationConfirm (OOCTXT* pctxt, H225UnregistrationConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 3); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnregRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225UnregRejectReason (OOCTXT* pctxt, H225UnregRejectReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* notCurrentlyRegistered */ + case 1: + /* NULL */ + break; + + /* callInProgress */ + case 2: + /* NULL */ + break; + + /* undefinedReason */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* permissionDenied */ + case 4: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityDenial */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityError */ + case 6: + stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnregistrationReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225UnregistrationReject (OOCTXT* pctxt, H225UnregistrationReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode rejectReason */ + + stat = asn1PE_H225UnregRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 4); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.altGKInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CallModel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225CallModel (OOCTXT* pctxt, H225CallModel* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* direct */ + case 1: + /* NULL */ + break; + + /* gatekeeperRouted */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportQOS */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225TransportQOS (OOCTXT* pctxt, H225TransportQOS* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* endpointControlled */ + case 1: + /* NULL */ + break; + + /* gatekeeperControlled */ + case 2: + /* NULL */ + break; + + /* noControl */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AdmissionRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AdmissionRequest (OOCTXT* pctxt, H225AdmissionRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.canMapAliasPresent || + pvalue->m.callIdentifierPresent || + pvalue->m.srcAlternativesPresent || + pvalue->m.destAlternativesPresent || + pvalue->m.gatekeeperIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.transportQOSPresent || + pvalue->m.willSupplyUUIEsPresent || + pvalue->m.callLinkagePresent || + pvalue->m.gatewayDataRatePresent || + pvalue->m.capacityPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.desiredProtocolsPresent || + pvalue->m.desiredTunnelledProtocolPresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent || + pvalue->m.canMapSrcAliasPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callModelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationInfoPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destCallSignalAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.srcCallSignalAddressPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callServicesPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode callType */ + + stat = asn1PE_H225CallType (pctxt, &pvalue->callType); + if (stat != ASN_OK) return stat; + + /* encode callModel */ + + if (pvalue->m.callModelPresent) { + stat = asn1PE_H225CallModel (pctxt, &pvalue->callModel); + if (stat != ASN_OK) return stat; + } + + /* encode endpointIdentifier */ + + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + + /* encode destinationInfo */ + + if (pvalue->m.destinationInfoPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return stat; + } + + /* encode destCallSignalAddress */ + + if (pvalue->m.destCallSignalAddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress); + if (stat != ASN_OK) return stat; + } + + /* encode destExtraCallInfo */ + + if (pvalue->m.destExtraCallInfoPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destExtraCallInfo); + if (stat != ASN_OK) return stat; + } + + /* encode srcInfo */ + + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->srcInfo); + if (stat != ASN_OK) return stat; + + /* encode srcCallSignalAddress */ + + if (pvalue->m.srcCallSignalAddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->srcCallSignalAddress); + if (stat != ASN_OK) return stat; + } + + /* encode bandWidth */ + + stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth); + if (stat != ASN_OK) return stat; + + /* encode callReferenceValue */ + + stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode callServices */ + + if (pvalue->m.callServicesPresent) { + stat = asn1PE_H225QseriesOptions (pctxt, &pvalue->callServices); + if (stat != ASN_OK) return stat; + } + + /* encode conferenceID */ + + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + + /* encode activeMC */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->activeMC); + if (stat != ASN_OK) return stat; + + /* encode answerCall */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->answerCall); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 18); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.canMapAliasPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.srcAlternativesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destAlternativesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportQOSPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.willSupplyUUIEsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatewayDataRatePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredProtocolsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredTunnelledProtocolPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.canMapSrcAliasPresent); + /* encode extension elements */ + + if (pvalue->m.canMapAliasPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canMapAlias); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.srcAlternativesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->srcAlternatives); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.destAlternativesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->destAlternatives); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.gatekeeperIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.transportQOSPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225TransportQOS (&lctxt, &pvalue->transportQOS); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.willSupplyUUIEsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->willSupplyUUIEs); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callLinkagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.gatewayDataRatePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225DataRate (&lctxt, &pvalue->gatewayDataRate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.desiredProtocolsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->desiredProtocols); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.desiredTunnelledProtocolPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225TunnelledProtocol (&lctxt, &pvalue->desiredTunnelledProtocol); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.canMapSrcAliasPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canMapSrcAlias); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UUIEsRequested */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225UUIEsRequested (OOCTXT* pctxt, H225UUIEsRequested* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.statusPresent || + pvalue->m.statusInquiryPresent || + pvalue->m.setupAcknowledgePresent || + pvalue->m.notifyPresent); + + encodeBit (pctxt, extbit); + + /* encode setup */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->setup); + if (stat != ASN_OK) return stat; + + /* encode callProceeding */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->callProceeding); + if (stat != ASN_OK) return stat; + + /* encode connect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->connect); + if (stat != ASN_OK) return stat; + + /* encode alerting */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alerting); + if (stat != ASN_OK) return stat; + + /* encode information */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->information); + if (stat != ASN_OK) return stat; + + /* encode releaseComplete */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->releaseComplete); + if (stat != ASN_OK) return stat; + + /* encode facility */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->facility); + if (stat != ASN_OK) return stat; + + /* encode progress */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->progress); + if (stat != ASN_OK) return stat; + + /* encode empty */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->empty); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 3); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.statusPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.statusInquiryPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.setupAcknowledgePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.notifyPresent); + /* encode extension elements */ + + if (pvalue->m.statusPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->status); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.statusInquiryPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->statusInquiry); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.setupAcknowledgePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->setupAcknowledge); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.notifyPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->notify); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AdmissionConfirm_language */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AdmissionConfirm_language (OOCTXT* pctxt, H225AdmissionConfirm_language* pvalue) +{ + static Asn1SizeCnst element_lsize1 = { 0, 1, 32, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + addSizeConstraint (pctxt, &element_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->elem[xx1], 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AdmissionConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AdmissionConfirm (OOCTXT* pctxt, H225AdmissionConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.destinationInfoPresent || + pvalue->m.destExtraCallInfoPresent || + pvalue->m.destinationTypePresent || + pvalue->m.remoteExtensionAddressPresent || + pvalue->m.alternateEndpointsPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.transportQOSPresent || + pvalue->m.willRespondToIRRPresent || + pvalue->m.uuiesRequestedPresent || + pvalue->m.languagePresent || + pvalue->m.alternateTransportAddressesPresent || + pvalue->m.useSpecifiedTransportPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.usageSpecPresent || + pvalue->m.supportedProtocolsPresent || + pvalue->m.serviceControlPresent || + pvalue->m.multipleCallsPresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent || + pvalue->m.modifiedSrcInfoPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.irrFrequencyPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode bandWidth */ + + stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth); + if (stat != ASN_OK) return stat; + + /* encode callModel */ + + stat = asn1PE_H225CallModel (pctxt, &pvalue->callModel); + if (stat != ASN_OK) return stat; + + /* encode destCallSignalAddress */ + + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->destCallSignalAddress); + if (stat != ASN_OK) return stat; + + /* encode irrFrequency */ + + if (pvalue->m.irrFrequencyPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->irrFrequency, 1U, 65535U); + if (stat != ASN_OK) return stat; + + } + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 21); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationTypePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportQOSPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.willRespondToIRRPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.uuiesRequestedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.languagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.useSpecifiedTransportPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageSpecPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedProtocolsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.modifiedSrcInfoPresent); + /* encode extension elements */ + + if (pvalue->m.destinationInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.destExtraCallInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destExtraCallInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.destinationTypePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225EndpointType (&lctxt, &pvalue->destinationType); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.remoteExtensionAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->remoteExtensionAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.alternateEndpointsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.transportQOSPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225TransportQOS (&lctxt, &pvalue->transportQOS); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.willRespondToIRRPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->willRespondToIRR); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.uuiesRequestedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225UUIEsRequested (&lctxt, &pvalue->uuiesRequested); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.languagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AdmissionConfirm_language (&lctxt, &pvalue->language); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.alternateTransportAddressesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.useSpecifiedTransportPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225UseSpecifiedTransport (&lctxt, &pvalue->useSpecifiedTransport); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.usageSpecPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225RasUsageSpecification (&lctxt, &pvalue->usageSpec); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedProtocolsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->supportedProtocols); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.modifiedSrcInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->modifiedSrcInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225PartyNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225PartyNumber (OOCTXT* pctxt, H225_SeqOfH225PartyNumber* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225PartyNumber (pctxt, ((H225PartyNumber*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AdmissionRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AdmissionRejectReason (OOCTXT* pctxt, H225AdmissionRejectReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 8); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* calledPartyNotRegistered */ + case 1: + /* NULL */ + break; + + /* invalidPermission */ + case 2: + /* NULL */ + break; + + /* requestDenied */ + case 3: + /* NULL */ + break; + + /* undefinedReason */ + case 4: + /* NULL */ + break; + + /* callerNotRegistered */ + case 5: + /* NULL */ + break; + + /* routeCallToGatekeeper */ + case 6: + /* NULL */ + break; + + /* invalidEndpointIdentifier */ + case 7: + /* NULL */ + break; + + /* resourceUnavailable */ + case 8: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* securityDenial */ + case 9: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* qosControlNotSupported */ + case 10: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* incompleteAddress */ + case 11: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* aliasesInconsistent */ + case 12: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* routeCallToSCN */ + case 13: + stat = asn1PE_H225_SeqOfH225PartyNumber (&lctxt, pvalue->u.routeCallToSCN); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* exceedsCallCapacity */ + case 14: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* collectDestination */ + case 15: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* collectPIN */ + case 16: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericDataReason */ + case 17: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* neededFeatureNotSupported */ + case 18: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityErrors */ + case 19: + stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityErrors); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityDHmismatch */ + case 20: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* noRouteToDestination */ + case 21: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* unallocatedNumber */ + case 22: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AdmissionReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225AdmissionReject (OOCTXT* pctxt, H225AdmissionReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.callSignalAddressPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.serviceControlPresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode rejectReason */ + + stat = asn1PE_H225AdmissionRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 7); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callSignalAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.altGKInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callSignalAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225TransportAddress (&lctxt, &pvalue->callSignalAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225BandwidthDetails */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225BandwidthDetails (OOCTXT* pctxt, H225_SeqOfH225BandwidthDetails* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225BandwidthDetails (pctxt, ((H225BandwidthDetails*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* BandwidthRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225BandwidthRequest (OOCTXT* pctxt, H225BandwidthRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.gatekeeperIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.answeredCallPresent || + pvalue->m.callLinkagePresent || + pvalue->m.capacityPresent || + pvalue->m.usageInformationPresent || + pvalue->m.bandwidthDetailsPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callTypePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode endpointIdentifier */ + + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + + /* encode conferenceID */ + + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + + /* encode callReferenceValue */ + + stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue); + if (stat != ASN_OK) return stat; + + /* encode callType */ + + if (pvalue->m.callTypePresent) { + stat = asn1PE_H225CallType (pctxt, &pvalue->callType); + if (stat != ASN_OK) return stat; + } + + /* encode bandWidth */ + + stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 10); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.answeredCallPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInformationPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bandwidthDetailsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.gatekeeperIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.answeredCallPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->answeredCall); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callLinkagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.usageInformationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225RasUsageInformation (&lctxt, &pvalue->usageInformation); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.bandwidthDetailsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225BandwidthDetails (&lctxt, &pvalue->bandwidthDetails); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* BandwidthConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225BandwidthConfirm (OOCTXT* pctxt, H225BandwidthConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.capacityPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode bandWidth */ + + stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 4); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* BandRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225BandRejectReason (OOCTXT* pctxt, H225BandRejectReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* notBound */ + case 1: + /* NULL */ + break; + + /* invalidConferenceID */ + case 2: + /* NULL */ + break; + + /* invalidPermission */ + case 3: + /* NULL */ + break; + + /* insufficientResources */ + case 4: + /* NULL */ + break; + + /* invalidRevision */ + case 5: + /* NULL */ + break; + + /* undefinedReason */ + case 6: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* securityDenial */ + case 7: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityError */ + case 8: + stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* BandwidthReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225BandwidthReject (OOCTXT* pctxt, H225BandwidthReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode rejectReason */ + + stat = asn1PE_H225BandRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + /* encode allowedBandWidth */ + + stat = asn1PE_H225BandWidth (pctxt, pvalue->allowedBandWidth); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 4); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.altGKInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DisengageReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225DisengageReason (OOCTXT* pctxt, H225DisengageReason* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* forcedDrop */ + case 1: + /* NULL */ + break; + + /* normalDrop */ + case 2: + /* NULL */ + break; + + /* undefinedReason */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DisengageRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225DisengageRequest (OOCTXT* pctxt, H225DisengageRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.gatekeeperIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.answeredCallPresent || + pvalue->m.callLinkagePresent || + pvalue->m.capacityPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.usageInformationPresent || + pvalue->m.terminationCausePresent || + pvalue->m.serviceControlPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode endpointIdentifier */ + + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + + /* encode conferenceID */ + + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + + /* encode callReferenceValue */ + + stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue); + if (stat != ASN_OK) return stat; + + /* encode disengageReason */ + + stat = asn1PE_H225DisengageReason (pctxt, &pvalue->disengageReason); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 12); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.answeredCallPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInformationPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminationCausePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.gatekeeperIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.answeredCallPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->answeredCall); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callLinkagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.usageInformationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225RasUsageInformation (&lctxt, &pvalue->usageInformation); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.terminationCausePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallTerminationCause (&lctxt, &pvalue->terminationCause); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DisengageConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225DisengageConfirm (OOCTXT* pctxt, H225DisengageConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.capacityPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.usageInformationPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 6); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInformationPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.usageInformationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225RasUsageInformation (&lctxt, &pvalue->usageInformation); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DisengageRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225DisengageRejectReason (OOCTXT* pctxt, H225DisengageRejectReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* notRegistered */ + case 1: + /* NULL */ + break; + + /* requestToDropOther */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* securityDenial */ + case 3: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityError */ + case 4: + stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DisengageReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225DisengageReject (OOCTXT* pctxt, H225DisengageReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode rejectReason */ + + stat = asn1PE_H225DisengageRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 4); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.altGKInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* LocationRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225LocationRequest (OOCTXT* pctxt, H225LocationRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.sourceInfoPresent || + pvalue->m.canMapAliasPresent || + pvalue->m.gatekeeperIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.desiredProtocolsPresent || + pvalue->m.desiredTunnelledProtocolPresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent || + pvalue->m.hopCountPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.callIdentifierPresent || + pvalue->m.bandWidthPresent || + pvalue->m.sourceEndpointInfoPresent || + pvalue->m.canMapSrcAliasPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode endpointIdentifier */ + + if (pvalue->m.endpointIdentifierPresent) { + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + } + + /* encode destinationInfo */ + + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode replyAddress */ + + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->replyAddress); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 15); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.canMapAliasPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.gatekeeperIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredProtocolsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.desiredTunnelledProtocolPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.hopCountPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bandWidthPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourceEndpointInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.canMapSrcAliasPresent); + /* encode extension elements */ + + if (pvalue->m.sourceInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->sourceInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.canMapAliasPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canMapAlias); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.gatekeeperIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225GatekeeperIdentifier (&lctxt, pvalue->gatekeeperIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.desiredProtocolsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->desiredProtocols); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.desiredTunnelledProtocolPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225TunnelledProtocol (&lctxt, &pvalue->desiredTunnelledProtocol); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.hopCountPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->hopCount, 1U, 255U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.bandWidthPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225BandWidth (&lctxt, pvalue->bandWidth); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.sourceEndpointInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->sourceEndpointInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.canMapSrcAliasPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->canMapSrcAlias); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* LocationConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225LocationConfirm (OOCTXT* pctxt, H225LocationConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.destinationInfoPresent || + pvalue->m.destExtraCallInfoPresent || + pvalue->m.destinationTypePresent || + pvalue->m.remoteExtensionAddressPresent || + pvalue->m.alternateEndpointsPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.alternateTransportAddressesPresent || + pvalue->m.supportedProtocolsPresent || + pvalue->m.multipleCallsPresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent || + pvalue->m.circuitInfoPresent || + pvalue->m.serviceControlPresent || + pvalue->m.modifiedSrcInfoPresent || + pvalue->m.bandWidthPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode callSignalAddress */ + + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->callSignalAddress); + if (stat != ASN_OK) return stat; + + /* encode rasAddress */ + + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 16); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destExtraCallInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationTypePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.remoteExtensionAddressPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateEndpointsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.alternateTransportAddressesPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supportedProtocolsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipleCallsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.modifiedSrcInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bandWidthPresent); + /* encode extension elements */ + + if (pvalue->m.destinationInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destinationInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.destExtraCallInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->destExtraCallInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.destinationTypePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225EndpointType (&lctxt, &pvalue->destinationType); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.remoteExtensionAddressPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->remoteExtensionAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.alternateEndpointsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225Endpoint (&lctxt, &pvalue->alternateEndpoints); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.alternateTransportAddressesPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AlternateTransportAddresses (&lctxt, &pvalue->alternateTransportAddresses); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.supportedProtocolsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225SupportedProtocols (&lctxt, &pvalue->supportedProtocols); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipleCallsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipleCalls); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.modifiedSrcInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225AliasAddress (&lctxt, &pvalue->modifiedSrcInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.bandWidthPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225BandWidth (&lctxt, pvalue->bandWidth); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* LocationRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225LocationRejectReason (OOCTXT* pctxt, H225LocationRejectReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* notRegistered */ + case 1: + /* NULL */ + break; + + /* invalidPermission */ + case 2: + /* NULL */ + break; + + /* requestDenied */ + case 3: + /* NULL */ + break; + + /* undefinedReason */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* securityDenial */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* aliasesInconsistent */ + case 6: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* routeCalltoSCN */ + case 7: + stat = asn1PE_H225_SeqOfH225PartyNumber (&lctxt, pvalue->u.routeCalltoSCN); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* resourceUnavailable */ + case 8: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericDataReason */ + case 9: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* neededFeatureNotSupported */ + case 10: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* hopCountExceeded */ + case 11: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* incompleteAddress */ + case 12: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityError */ + case 13: + stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* securityDHmismatch */ + case 14: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* noRouteToDestination */ + case 15: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* unallocatedNumber */ + case 16: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* LocationReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225LocationReject (OOCTXT* pctxt, H225LocationReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.altGKInfoPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent || + pvalue->m.serviceControlPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode rejectReason */ + + stat = asn1PE_H225LocationRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 6); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.serviceControlPresent); + /* encode extension elements */ + + if (pvalue->m.altGKInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225AltGKInfo (&lctxt, &pvalue->altGKInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.serviceControlPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (&lctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* InfoRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225InfoRequest (OOCTXT* pctxt, H225InfoRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.uuiesRequestedPresent || + pvalue->m.callLinkagePresent || + pvalue->m.usageInfoRequestedPresent || + pvalue->m.segmentedResponseSupportedPresent || + pvalue->m.nextSegmentRequestedPresent || + pvalue->m.capacityInfoRequestedPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.replyAddressPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode callReferenceValue */ + + stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode replyAddress */ + + if (pvalue->m.replyAddressPresent) { + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->replyAddress); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 10); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.uuiesRequestedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInfoRequestedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.segmentedResponseSupportedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nextSegmentRequestedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityInfoRequestedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.uuiesRequestedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225UUIEsRequested (&lctxt, &pvalue->uuiesRequested); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callLinkagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.usageInfoRequestedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225RasUsageInfoTypes (&lctxt, &pvalue->usageInfoRequested); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.segmentedResponseSupportedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.nextSegmentRequestedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->nextSegmentRequested, 0U, 65535U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityInfoRequestedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225RTPSession */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225RTPSession (OOCTXT* pctxt, H225_SeqOfH225RTPSession* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225RTPSession (pctxt, ((H225RTPSession*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225TransportChannelInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225TransportChannelInfo (OOCTXT* pctxt, H225_SeqOfH225TransportChannelInfo* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225TransportChannelInfo (pctxt, ((H225TransportChannelInfo*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225ConferenceIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225ConferenceIdentifier (OOCTXT* pctxt, H225_SeqOfH225ConferenceIdentifier* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* InfoRequestResponse_perCallInfo_element_pdu_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue) +{ + int stat = ASN_OK; + + /* encode h323pdu */ + + stat = asn1PE_H225H323_UU_PDU (pctxt, &pvalue->h323pdu); + if (stat != ASN_OK) return stat; + + /* encode sent */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->sent); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_el */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225InfoRequestResponse_perCallInfo_element_pdu_element (pctxt, ((H225InfoRequestResponse_perCallInfo_element_pdu_element*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* InfoRequestResponse_perCallInfo_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225InfoRequestResponse_perCallInfo_element* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.callIdentifierPresent || + pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.substituteConfIDsPresent || + pvalue->m.pduPresent || + pvalue->m.callLinkagePresent || + pvalue->m.usageInformationPresent || + pvalue->m.circuitInfoPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.originatorPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.audioPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode callReferenceValue */ + + stat = asn1PE_H225CallReferenceValue (pctxt, pvalue->callReferenceValue); + if (stat != ASN_OK) return stat; + + /* encode conferenceID */ + + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + + /* encode originator */ + + if (pvalue->m.originatorPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->originator); + if (stat != ASN_OK) return stat; + } + + /* encode audio */ + + if (pvalue->m.audioPresent) { + stat = asn1PE_H225_SeqOfH225RTPSession (pctxt, &pvalue->audio); + if (stat != ASN_OK) return stat; + } + + /* encode video */ + + if (pvalue->m.videoPresent) { + stat = asn1PE_H225_SeqOfH225RTPSession (pctxt, &pvalue->video); + if (stat != ASN_OK) return stat; + } + + /* encode data */ + + if (pvalue->m.dataPresent) { + stat = asn1PE_H225_SeqOfH225TransportChannelInfo (pctxt, &pvalue->data); + if (stat != ASN_OK) return stat; + } + + /* encode h245 */ + + stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->h245); + if (stat != ASN_OK) return stat; + + /* encode callSignaling */ + + stat = asn1PE_H225TransportChannelInfo (pctxt, &pvalue->callSignaling); + if (stat != ASN_OK) return stat; + + /* encode callType */ + + stat = asn1PE_H225CallType (pctxt, &pvalue->callType); + if (stat != ASN_OK) return stat; + + /* encode bandWidth */ + + stat = asn1PE_H225BandWidth (pctxt, pvalue->bandWidth); + if (stat != ASN_OK) return stat; + + /* encode callModel */ + + stat = asn1PE_H225CallModel (pctxt, &pvalue->callModel); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 7); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callIdentifierPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.substituteConfIDsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.pduPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callLinkagePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.usageInformationPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.circuitInfoPresent); + /* encode extension elements */ + + if (pvalue->m.callIdentifierPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallIdentifier (&lctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.substituteConfIDsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ConferenceIdentifier (&lctxt, &pvalue->substituteConfIDs); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.pduPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element_pdu_element (&lctxt, &pvalue->pdu); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.callLinkagePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallLinkage (&lctxt, &pvalue->callLinkage); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.usageInformationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225RasUsageInformation (&lctxt, &pvalue->usageInformation); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.circuitInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CircuitInfo (&lctxt, &pvalue->circuitInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225InfoRequestResponse_perCallInfo_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (OOCTXT* pctxt, H225_SeqOfH225InfoRequestResponse_perCallInfo_element* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225InfoRequestResponse_perCallInfo_element (pctxt, ((H225InfoRequestResponse_perCallInfo_element*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* InfoRequestResponseStatus */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225InfoRequestResponseStatus (OOCTXT* pctxt, H225InfoRequestResponseStatus* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* complete */ + case 1: + /* NULL */ + break; + + /* incomplete */ + case 2: + /* NULL */ + break; + + /* segment */ + case 3: + stat = encodeConsUnsigned (pctxt, pvalue->u.segment, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* invalidCall */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* InfoRequestResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225InfoRequestResponse (OOCTXT* pctxt, H225InfoRequestResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.needResponsePresent || + pvalue->m.capacityPresent || + pvalue->m.irrStatusPresent || + pvalue->m.unsolicitedPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointAliasPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.perCallInfoPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode endpointType */ + + stat = asn1PE_H225EndpointType (pctxt, &pvalue->endpointType); + if (stat != ASN_OK) return stat; + + /* encode endpointIdentifier */ + + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + + /* encode rasAddress */ + + stat = asn1PE_H225TransportAddress (pctxt, &pvalue->rasAddress); + if (stat != ASN_OK) return stat; + + /* encode callSignalAddress */ + + stat = asn1PE_H225_SeqOfH225TransportAddress (pctxt, &pvalue->callSignalAddress); + if (stat != ASN_OK) return stat; + + /* encode endpointAlias */ + + if (pvalue->m.endpointAliasPresent) { + stat = asn1PE_H225_SeqOfH225AliasAddress (pctxt, &pvalue->endpointAlias); + if (stat != ASN_OK) return stat; + } + + /* encode perCallInfo */ + + if (pvalue->m.perCallInfoPresent) { + stat = asn1PE_H225_SeqOfH225InfoRequestResponse_perCallInfo_element (pctxt, &pvalue->perCallInfo); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 7); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.needResponsePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.irrStatusPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.unsolicitedPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.needResponsePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->needResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.irrStatusPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225InfoRequestResponseStatus (&lctxt, &pvalue->irrStatus); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.unsolicitedPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->unsolicited); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225NonStandardMessage (OOCTXT* pctxt, H225NonStandardMessage* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.featureSetPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 4); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.featureSetPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225FeatureSet (&lctxt, &pvalue->featureSet); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnknownMessageResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225UnknownMessageResponse (OOCTXT* pctxt, H225UnknownMessageResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.tokensPresent || + pvalue->m.cryptoTokensPresent || + pvalue->m.integrityCheckValuePresent || + pvalue->m.messageNotUnderstoodPresent); + + encodeBit (pctxt, extbit); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 3); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.messageNotUnderstoodPresent); + /* encode extension elements */ + + if (pvalue->m.tokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225ClearToken (&lctxt, &pvalue->tokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.cryptoTokensPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225CryptoH323Token (&lctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.integrityCheckValuePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225ICV (&lctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.messageNotUnderstoodPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOctetString (&lctxt, pvalue->messageNotUnderstood.numocts, pvalue->messageNotUnderstood.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestInProgress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RequestInProgress (OOCTXT* pctxt, H225RequestInProgress* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode integrityCheckValue */ + + if (pvalue->m.integrityCheckValuePresent) { + stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return stat; + } + + /* encode delay */ + + stat = encodeConsUnsigned (pctxt, pvalue->delay, 1U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ResourcesAvailableIndicate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ResourcesAvailableIndicate (OOCTXT* pctxt, H225ResourcesAvailableIndicate* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.capacityPresent || + pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode endpointIdentifier */ + + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + + /* encode protocols */ + + stat = asn1PE_H225_SeqOfH225SupportedProtocols (pctxt, &pvalue->protocols); + if (stat != ASN_OK) return stat; + + /* encode almostOutOfResources */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->almostOutOfResources); + if (stat != ASN_OK) return stat; + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode integrityCheckValue */ + + if (pvalue->m.integrityCheckValuePresent) { + stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capacityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.capacityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225CallCapacity (&lctxt, &pvalue->capacity); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ResourcesAvailableConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ResourcesAvailableConfirm (OOCTXT* pctxt, H225ResourcesAvailableConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.genericDataPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = asn1PE_H225ProtocolIdentifier (pctxt, pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode integrityCheckValue */ + + if (pvalue->m.integrityCheckValuePresent) { + stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + /* encode extension elements */ + + if (pvalue->m.genericDataPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H225_SeqOfH225GenericData (&lctxt, &pvalue->genericData); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* InfoRequestAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225InfoRequestAck (OOCTXT* pctxt, H225InfoRequestAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode integrityCheckValue */ + + if (pvalue->m.integrityCheckValuePresent) { + stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* InfoRequestNakReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225InfoRequestNakReason (OOCTXT* pctxt, H225InfoRequestNakReason* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* notRegistered */ + case 1: + /* NULL */ + break; + + /* securityDenial */ + case 2: + /* NULL */ + break; + + /* undefinedReason */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* securityError */ + case 4: + stat = asn1PE_H225SecurityErrors2 (&lctxt, pvalue->u.securityError); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* InfoRequestNak */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225InfoRequestNak (OOCTXT* pctxt, H225InfoRequestNak* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.altGKInfoPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode nakReason */ + + stat = asn1PE_H225InfoRequestNakReason (pctxt, &pvalue->nakReason); + if (stat != ASN_OK) return stat; + + /* encode altGKInfo */ + + if (pvalue->m.altGKInfoPresent) { + stat = asn1PE_H225AltGKInfo (pctxt, &pvalue->altGKInfo); + if (stat != ASN_OK) return stat; + } + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode integrityCheckValue */ + + if (pvalue->m.integrityCheckValuePresent) { + stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ServiceControlIndication_callSpecific */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ServiceControlIndication_callSpecific (OOCTXT* pctxt, H225ServiceControlIndication_callSpecific* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode callIdentifier */ + + stat = asn1PE_H225CallIdentifier (pctxt, &pvalue->callIdentifier); + if (stat != ASN_OK) return stat; + + /* encode conferenceID */ + + stat = asn1PE_H225ConferenceIdentifier (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + + /* encode answeredCall */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->answeredCall); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ServiceControlIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ServiceControlIndication (OOCTXT* pctxt, H225ServiceControlIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.endpointIdentifierPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.callSpecificPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode serviceControl */ + + stat = asn1PE_H225_SeqOfH225ServiceControlSession (pctxt, &pvalue->serviceControl); + if (stat != ASN_OK) return stat; + + /* encode endpointIdentifier */ + + if (pvalue->m.endpointIdentifierPresent) { + stat = asn1PE_H225EndpointIdentifier (pctxt, pvalue->endpointIdentifier); + if (stat != ASN_OK) return stat; + } + + /* encode callSpecific */ + + if (pvalue->m.callSpecificPresent) { + stat = asn1PE_H225ServiceControlIndication_callSpecific (pctxt, &pvalue->callSpecific); + if (stat != ASN_OK) return stat; + } + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode integrityCheckValue */ + + if (pvalue->m.integrityCheckValuePresent) { + stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return stat; + } + + /* encode featureSet */ + + if (pvalue->m.featureSetPresent) { + stat = asn1PE_H225FeatureSet (pctxt, &pvalue->featureSet); + if (stat != ASN_OK) return stat; + } + + /* encode genericData */ + + if (pvalue->m.genericDataPresent) { + stat = asn1PE_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ServiceControlResponse_result */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ServiceControlResponse_result (OOCTXT* pctxt, H225ServiceControlResponse_result* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* started */ + case 1: + /* NULL */ + break; + + /* failed */ + case 2: + /* NULL */ + break; + + /* stopped */ + case 3: + /* NULL */ + break; + + /* notAvailable */ + case 4: + /* NULL */ + break; + + /* neededFeatureNotSupported */ + case 5: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ServiceControlResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225ServiceControlResponse (OOCTXT* pctxt, H225ServiceControlResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.resultPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cryptoTokensPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCheckValuePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.featureSetPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericDataPresent); + + /* encode requestSeqNum */ + + stat = asn1PE_H225RequestSeqNum (pctxt, pvalue->requestSeqNum); + if (stat != ASN_OK) return stat; + + /* encode result */ + + if (pvalue->m.resultPresent) { + stat = asn1PE_H225ServiceControlResponse_result (pctxt, &pvalue->result); + if (stat != ASN_OK) return stat; + } + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H225NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode tokens */ + + if (pvalue->m.tokensPresent) { + stat = asn1PE_H225_SeqOfH225ClearToken (pctxt, &pvalue->tokens); + if (stat != ASN_OK) return stat; + } + + /* encode cryptoTokens */ + + if (pvalue->m.cryptoTokensPresent) { + stat = asn1PE_H225_SeqOfH225CryptoH323Token (pctxt, &pvalue->cryptoTokens); + if (stat != ASN_OK) return stat; + } + + /* encode integrityCheckValue */ + + if (pvalue->m.integrityCheckValuePresent) { + stat = asn1PE_H225ICV (pctxt, &pvalue->integrityCheckValue); + if (stat != ASN_OK) return stat; + } + + /* encode featureSet */ + + if (pvalue->m.featureSetPresent) { + stat = asn1PE_H225FeatureSet (pctxt, &pvalue->featureSet); + if (stat != ASN_OK) return stat; + } + + /* encode genericData */ + + if (pvalue->m.genericDataPresent) { + stat = asn1PE_H225_SeqOfH225GenericData (pctxt, &pvalue->genericData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH225AdmissionConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225_SeqOfH225AdmissionConfirm (OOCTXT* pctxt, H225_SeqOfH225AdmissionConfirm* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H225AdmissionConfirm (pctxt, ((H225AdmissionConfirm*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RasMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H225RasMessage (OOCTXT* pctxt, H225RasMessage* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 25); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 24); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* gatekeeperRequest */ + case 1: + stat = asn1PE_H225GatekeeperRequest (pctxt, pvalue->u.gatekeeperRequest); + if (stat != ASN_OK) return stat; + break; + + /* gatekeeperConfirm */ + case 2: + stat = asn1PE_H225GatekeeperConfirm (pctxt, pvalue->u.gatekeeperConfirm); + if (stat != ASN_OK) return stat; + break; + + /* gatekeeperReject */ + case 3: + stat = asn1PE_H225GatekeeperReject (pctxt, pvalue->u.gatekeeperReject); + if (stat != ASN_OK) return stat; + break; + + /* registrationRequest */ + case 4: + stat = asn1PE_H225RegistrationRequest (pctxt, pvalue->u.registrationRequest); + if (stat != ASN_OK) return stat; + break; + + /* registrationConfirm */ + case 5: + stat = asn1PE_H225RegistrationConfirm (pctxt, pvalue->u.registrationConfirm); + if (stat != ASN_OK) return stat; + break; + + /* registrationReject */ + case 6: + stat = asn1PE_H225RegistrationReject (pctxt, pvalue->u.registrationReject); + if (stat != ASN_OK) return stat; + break; + + /* unregistrationRequest */ + case 7: + stat = asn1PE_H225UnregistrationRequest (pctxt, pvalue->u.unregistrationRequest); + if (stat != ASN_OK) return stat; + break; + + /* unregistrationConfirm */ + case 8: + stat = asn1PE_H225UnregistrationConfirm (pctxt, pvalue->u.unregistrationConfirm); + if (stat != ASN_OK) return stat; + break; + + /* unregistrationReject */ + case 9: + stat = asn1PE_H225UnregistrationReject (pctxt, pvalue->u.unregistrationReject); + if (stat != ASN_OK) return stat; + break; + + /* admissionRequest */ + case 10: + stat = asn1PE_H225AdmissionRequest (pctxt, pvalue->u.admissionRequest); + if (stat != ASN_OK) return stat; + break; + + /* admissionConfirm */ + case 11: + stat = asn1PE_H225AdmissionConfirm (pctxt, pvalue->u.admissionConfirm); + if (stat != ASN_OK) return stat; + break; + + /* admissionReject */ + case 12: + stat = asn1PE_H225AdmissionReject (pctxt, pvalue->u.admissionReject); + if (stat != ASN_OK) return stat; + break; + + /* bandwidthRequest */ + case 13: + stat = asn1PE_H225BandwidthRequest (pctxt, pvalue->u.bandwidthRequest); + if (stat != ASN_OK) return stat; + break; + + /* bandwidthConfirm */ + case 14: + stat = asn1PE_H225BandwidthConfirm (pctxt, pvalue->u.bandwidthConfirm); + if (stat != ASN_OK) return stat; + break; + + /* bandwidthReject */ + case 15: + stat = asn1PE_H225BandwidthReject (pctxt, pvalue->u.bandwidthReject); + if (stat != ASN_OK) return stat; + break; + + /* disengageRequest */ + case 16: + stat = asn1PE_H225DisengageRequest (pctxt, pvalue->u.disengageRequest); + if (stat != ASN_OK) return stat; + break; + + /* disengageConfirm */ + case 17: + stat = asn1PE_H225DisengageConfirm (pctxt, pvalue->u.disengageConfirm); + if (stat != ASN_OK) return stat; + break; + + /* disengageReject */ + case 18: + stat = asn1PE_H225DisengageReject (pctxt, pvalue->u.disengageReject); + if (stat != ASN_OK) return stat; + break; + + /* locationRequest */ + case 19: + stat = asn1PE_H225LocationRequest (pctxt, pvalue->u.locationRequest); + if (stat != ASN_OK) return stat; + break; + + /* locationConfirm */ + case 20: + stat = asn1PE_H225LocationConfirm (pctxt, pvalue->u.locationConfirm); + if (stat != ASN_OK) return stat; + break; + + /* locationReject */ + case 21: + stat = asn1PE_H225LocationReject (pctxt, pvalue->u.locationReject); + if (stat != ASN_OK) return stat; + break; + + /* infoRequest */ + case 22: + stat = asn1PE_H225InfoRequest (pctxt, pvalue->u.infoRequest); + if (stat != ASN_OK) return stat; + break; + + /* infoRequestResponse */ + case 23: + stat = asn1PE_H225InfoRequestResponse (pctxt, pvalue->u.infoRequestResponse); + if (stat != ASN_OK) return stat; + break; + + /* nonStandardMessage */ + case 24: + stat = asn1PE_H225NonStandardMessage (pctxt, pvalue->u.nonStandardMessage); + if (stat != ASN_OK) return stat; + break; + + /* unknownMessageResponse */ + case 25: + stat = asn1PE_H225UnknownMessageResponse (pctxt, pvalue->u.unknownMessageResponse); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 26); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* requestInProgress */ + case 26: + stat = asn1PE_H225RequestInProgress (&lctxt, pvalue->u.requestInProgress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* resourcesAvailableIndicate */ + case 27: + stat = asn1PE_H225ResourcesAvailableIndicate (&lctxt, pvalue->u.resourcesAvailableIndicate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* resourcesAvailableConfirm */ + case 28: + stat = asn1PE_H225ResourcesAvailableConfirm (&lctxt, pvalue->u.resourcesAvailableConfirm); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* infoRequestAck */ + case 29: + stat = asn1PE_H225InfoRequestAck (&lctxt, pvalue->u.infoRequestAck); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* infoRequestNak */ + case 30: + stat = asn1PE_H225InfoRequestNak (&lctxt, pvalue->u.infoRequestNak); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* serviceControlIndication */ + case 31: + stat = asn1PE_H225ServiceControlIndication (&lctxt, pvalue->u.serviceControlIndication); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* serviceControlResponse */ + case 32: + stat = asn1PE_H225ServiceControlResponse (&lctxt, pvalue->u.serviceControlResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* admissionConfirmSequence */ + case 33: + stat = asn1PE_H225_SeqOfH225AdmissionConfirm (&lctxt, pvalue->u.admissionConfirmSequence); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + diff --git a/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.c b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.c new file mode 100644 index 000000000..ca69407a6 --- /dev/null +++ b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.c @@ -0,0 +1,40 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#include "ooasn1.h" +#include "MULTIMEDIA-SYSTEM-CONTROL.h" + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_networkAddress */ +/* */ +/**************************************************************/ + +EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet = +"#*,0123456789"; + +/**************************************************************/ +/* */ +/* UserInputIndication_signal */ +/* */ +/**************************************************************/ + +EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet = +"!#*0123456789ABCD"; + diff --git a/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.h b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.h new file mode 100644 index 000000000..6923cba5a --- /dev/null +++ b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROL.h @@ -0,0 +1,10937 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#ifndef MULTIMEDIA_SYSTEM_CONTROL_H +#define MULTIMEDIA_SYSTEM_CONTROL_H + +#ifdef __cplusplus +extern "C" { +#endif + +#include +#include + +#include "ooasn1.h" + +/**************************************************************/ +/* */ +/* NonStandardIdentifier_h221NonStandard */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NonStandardIdentifier_h221NonStandard { + ASN1UINT8 t35CountryCode; + ASN1UINT8 t35Extension; + ASN1USINT manufacturerCode; +} H245NonStandardIdentifier_h221NonStandard; + +EXTERN int asn1PE_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue); + +EXTERN int asn1PD_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue); + +/**************************************************************/ +/* */ +/* NonStandardIdentifier */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NonStandardIdentifier_object 1 +#define T_H245NonStandardIdentifier_h221NonStandard 2 + +typedef struct EXTERN H245NonStandardIdentifier { + int t; + union { + /* t = 1 */ + ASN1OBJID *object; + /* t = 2 */ + H245NonStandardIdentifier_h221NonStandard *h221NonStandard; + } u; +} H245NonStandardIdentifier; + +EXTERN int asn1PE_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* pvalue); + +EXTERN int asn1PD_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* NonStandardParameter */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NonStandardParameter { + H245NonStandardIdentifier nonStandardIdentifier; + ASN1DynOctStr data; +} H245NonStandardParameter; + +EXTERN int asn1PE_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue); + +EXTERN int asn1PD_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue); + +/**************************************************************/ +/* */ +/* V42bis */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245V42bis { + ASN1UINT numberOfCodewords; + ASN1USINT maximumStringLength; +} H245V42bis; + +EXTERN int asn1PE_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue); + +EXTERN int asn1PD_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue); + +/**************************************************************/ +/* */ +/* CompressionType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CompressionType_v42bis 1 +#define T_H245CompressionType_extElem1 2 + +typedef struct EXTERN H245CompressionType { + int t; + union { + /* t = 1 */ + H245V42bis *v42bis; + /* t = 2 */ + } u; +} H245CompressionType; + +EXTERN int asn1PE_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue); + +EXTERN int asn1PD_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue); + +/**************************************************************/ +/* */ +/* DataProtocolCapability_v76wCompression */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245DataProtocolCapability_v76wCompression_transmitCompression 1 +#define T_H245DataProtocolCapability_v76wCompression_receiveCompression 2 +#define T_H245DataProtocolCapability_v76wCompression_transmitAndReceiveCompression 3 +#define T_H245DataProtocolCapability_v76wCompression_extElem1 4 + +typedef struct EXTERN H245DataProtocolCapability_v76wCompression { + int t; + union { + /* t = 1 */ + H245CompressionType *transmitCompression; + /* t = 2 */ + H245CompressionType *receiveCompression; + /* t = 3 */ + H245CompressionType *transmitAndReceiveCompression; + /* t = 4 */ + } u; +} H245DataProtocolCapability_v76wCompression; + +EXTERN int asn1PE_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue); + +EXTERN int asn1PD_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue); + +/**************************************************************/ +/* */ +/* DataProtocolCapability */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245DataProtocolCapability_nonStandard 1 +#define T_H245DataProtocolCapability_v14buffered 2 +#define T_H245DataProtocolCapability_v42lapm 3 +#define T_H245DataProtocolCapability_hdlcFrameTunnelling 4 +#define T_H245DataProtocolCapability_h310SeparateVCStack 5 +#define T_H245DataProtocolCapability_h310SingleVCStack 6 +#define T_H245DataProtocolCapability_transparent 7 +#define T_H245DataProtocolCapability_segmentationAndReassembly 8 +#define T_H245DataProtocolCapability_hdlcFrameTunnelingwSAR 9 +#define T_H245DataProtocolCapability_v120 10 +#define T_H245DataProtocolCapability_separateLANStack 11 +#define T_H245DataProtocolCapability_v76wCompression 12 +#define T_H245DataProtocolCapability_tcp 13 +#define T_H245DataProtocolCapability_udp 14 +#define T_H245DataProtocolCapability_extElem1 15 + +typedef struct EXTERN H245DataProtocolCapability { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + /* t = 9 */ + /* t = 10 */ + /* t = 11 */ + /* t = 12 */ + H245DataProtocolCapability_v76wCompression *v76wCompression; + /* t = 13 */ + /* t = 14 */ + /* t = 15 */ + } u; +} H245DataProtocolCapability; + +EXTERN int asn1PE_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue); + +EXTERN int asn1PD_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue); + +/**************************************************************/ +/* */ +/* T38FaxRateManagement */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245T38FaxRateManagement_localTCF 1 +#define T_H245T38FaxRateManagement_transferredTCF 2 +#define T_H245T38FaxRateManagement_extElem1 3 + +typedef struct EXTERN H245T38FaxRateManagement { + int t; +} H245T38FaxRateManagement; + +EXTERN int asn1PE_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue); + +EXTERN int asn1PD_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue); + +/**************************************************************/ +/* */ +/* T38FaxUdpOptions_t38FaxUdpEC */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245T38FaxUdpOptions_t38FaxUdpEC_t38UDPFEC 1 +#define T_H245T38FaxUdpOptions_t38FaxUdpEC_t38UDPRedundancy 2 +#define T_H245T38FaxUdpOptions_t38FaxUdpEC_extElem1 3 + +typedef struct EXTERN H245T38FaxUdpOptions_t38FaxUdpEC { + int t; +} H245T38FaxUdpOptions_t38FaxUdpEC; + +EXTERN int asn1PE_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue); + +EXTERN int asn1PD_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue); + +/**************************************************************/ +/* */ +/* T38FaxUdpOptions */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245T38FaxUdpOptions { + struct { + unsigned t38FaxMaxBufferPresent : 1; + unsigned t38FaxMaxDatagramPresent : 1; + } m; + ASN1INT t38FaxMaxBuffer; + ASN1INT t38FaxMaxDatagram; + H245T38FaxUdpOptions_t38FaxUdpEC t38FaxUdpEC; +} H245T38FaxUdpOptions; + +EXTERN int asn1PE_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue); + +EXTERN int asn1PD_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue); + +/**************************************************************/ +/* */ +/* T38FaxTcpOptions */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245T38FaxTcpOptions { + ASN1BOOL t38TCPBidirectionalMode; +} H245T38FaxTcpOptions; + +EXTERN int asn1PE_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue); + +EXTERN int asn1PD_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue); + +/**************************************************************/ +/* */ +/* T38FaxProfile */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245T38FaxProfile { + struct { + unsigned versionPresent : 1; + unsigned t38FaxRateManagementPresent : 1; + unsigned t38FaxUdpOptionsPresent : 1; + unsigned t38FaxTcpOptionsPresent : 1; + } m; + ASN1BOOL fillBitRemoval; + ASN1BOOL transcodingJBIG; + ASN1BOOL transcodingMMR; + ASN1UINT8 version; + H245T38FaxRateManagement t38FaxRateManagement; + H245T38FaxUdpOptions t38FaxUdpOptions; + H245T38FaxTcpOptions t38FaxTcpOptions; +} H245T38FaxProfile; + +EXTERN int asn1PE_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue); + +EXTERN int asn1PD_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue); + +/**************************************************************/ +/* */ +/* NonStandardMessage */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NonStandardMessage { + H245NonStandardParameter nonStandardData; +} H245NonStandardMessage; + +EXTERN int asn1PE_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue); + +EXTERN int asn1PD_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue); + +/**************************************************************/ +/* */ +/* MasterSlaveDetermination */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MasterSlaveDetermination { + ASN1UINT8 terminalType; + ASN1UINT statusDeterminationNumber; +} H245MasterSlaveDetermination; + +EXTERN int asn1PE_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue); + +EXTERN int asn1PD_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue); + +/**************************************************************/ +/* */ +/* SequenceNumber */ +/* */ +/**************************************************************/ + +typedef ASN1UINT8 H245SequenceNumber; + +EXTERN int asn1PE_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber value); + +EXTERN int asn1PD_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber* pvalue); + +/**************************************************************/ +/* */ +/* VCCapability_aal1 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VCCapability_aal1 { + ASN1BOOL nullClockRecovery; + ASN1BOOL srtsClockRecovery; + ASN1BOOL adaptiveClockRecovery; + ASN1BOOL nullErrorCorrection; + ASN1BOOL longInterleaver; + ASN1BOOL shortInterleaver; + ASN1BOOL errorCorrectionOnly; + ASN1BOOL structuredDataTransfer; + ASN1BOOL partiallyFilledCells; +} H245VCCapability_aal1; + +EXTERN int asn1PE_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue); + +EXTERN int asn1PD_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue); + +/**************************************************************/ +/* */ +/* VCCapability_aal5 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VCCapability_aal5 { + ASN1USINT forwardMaximumSDUSize; + ASN1USINT backwardMaximumSDUSize; +} H245VCCapability_aal5; + +EXTERN int asn1PE_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue); + +EXTERN int asn1PD_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue); + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates_type_rangeOfBitRates */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VCCapability_availableBitRates_type_rangeOfBitRates { + ASN1USINT lowerBitRate; + ASN1USINT higherBitRate; +} H245VCCapability_availableBitRates_type_rangeOfBitRates; + +EXTERN int asn1PE_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue); + +EXTERN int asn1PD_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue); + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates_type */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245VCCapability_availableBitRates_type_singleBitRate 1 +#define T_H245VCCapability_availableBitRates_type_rangeOfBitRates 2 + +typedef struct EXTERN H245VCCapability_availableBitRates_type { + int t; + union { + /* t = 1 */ + ASN1USINT singleBitRate; + /* t = 2 */ + H245VCCapability_availableBitRates_type_rangeOfBitRates *rangeOfBitRates; + } u; +} H245VCCapability_availableBitRates_type; + +EXTERN int asn1PE_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* pvalue); + +EXTERN int asn1PD_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* pvalue); + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VCCapability_availableBitRates { + H245VCCapability_availableBitRates_type type; +} H245VCCapability_availableBitRates; + +EXTERN int asn1PE_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue); + +EXTERN int asn1PD_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue); + +/**************************************************************/ +/* */ +/* Q2931Address_address_nsapAddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245Q2931Address_address_nsapAddress { + ASN1UINT numocts; + ASN1OCTET data[20]; +} H245Q2931Address_address_nsapAddress; + +EXTERN int asn1PE_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* pvalue); + +EXTERN int asn1PD_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* pvalue); + +/**************************************************************/ +/* */ +/* Q2931Address_address */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245Q2931Address_address_internationalNumber 1 +#define T_H245Q2931Address_address_nsapAddress 2 +#define T_H245Q2931Address_address_extElem1 3 + +typedef struct EXTERN H245Q2931Address_address { + int t; + union { + /* t = 1 */ + ASN1NumericString internationalNumber; + /* t = 2 */ + H245Q2931Address_address_nsapAddress *nsapAddress; + /* t = 3 */ + } u; +} H245Q2931Address_address; + +EXTERN int asn1PE_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue); + +EXTERN int asn1PD_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue); + +/**************************************************************/ +/* */ +/* Q2931Address_subaddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245Q2931Address_subaddress { + ASN1UINT numocts; + ASN1OCTET data[20]; +} H245Q2931Address_subaddress; + +EXTERN int asn1PE_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* pvalue); + +EXTERN int asn1PD_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* pvalue); + +/**************************************************************/ +/* */ +/* Q2931Address */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245Q2931Address { + struct { + unsigned subaddressPresent : 1; + } m; + H245Q2931Address_address address; + H245Q2931Address_subaddress subaddress; +} H245Q2931Address; + +EXTERN int asn1PE_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue); + +EXTERN int asn1PD_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue); + +/**************************************************************/ +/* */ +/* VCCapability_aal1ViaGateway_gatewayAddress */ +/* */ +/**************************************************************/ + +/* List of H245Q2931Address */ +typedef DList H245VCCapability_aal1ViaGateway_gatewayAddress; + +EXTERN int asn1PE_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue); + +EXTERN int asn1PD_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue); + +/**************************************************************/ +/* */ +/* VCCapability_aal1ViaGateway */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VCCapability_aal1ViaGateway { + H245VCCapability_aal1ViaGateway_gatewayAddress gatewayAddress; + ASN1BOOL nullClockRecovery; + ASN1BOOL srtsClockRecovery; + ASN1BOOL adaptiveClockRecovery; + ASN1BOOL nullErrorCorrection; + ASN1BOOL longInterleaver; + ASN1BOOL shortInterleaver; + ASN1BOOL errorCorrectionOnly; + ASN1BOOL structuredDataTransfer; + ASN1BOOL partiallyFilledCells; +} H245VCCapability_aal1ViaGateway; + +EXTERN int asn1PE_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue); + +EXTERN int asn1PD_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue); + +/**************************************************************/ +/* */ +/* VCCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VCCapability { + struct { + unsigned aal1Present : 1; + unsigned aal5Present : 1; + unsigned aal1ViaGatewayPresent : 1; + } m; + H245VCCapability_aal1 aal1; + H245VCCapability_aal5 aal5; + ASN1BOOL transportStream; + ASN1BOOL programStream; + H245VCCapability_availableBitRates availableBitRates; + H245VCCapability_aal1ViaGateway aal1ViaGateway; +} H245VCCapability; + +EXTERN int asn1PE_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue); + +EXTERN int asn1PD_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue); + +/**************************************************************/ +/* */ +/* _SetOfH245VCCapability */ +/* */ +/**************************************************************/ + +/* List of H245VCCapability */ +typedef DList H245_SetOfH245VCCapability; + +EXTERN int asn1PE_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue); + +EXTERN int asn1PD_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue); + +/**************************************************************/ +/* */ +/* H222Capability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H222Capability { + ASN1USINT numberOfVCs; + H245_SetOfH245VCCapability vcCapability; +} H245H222Capability; + +EXTERN int asn1PE_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue); + +EXTERN int asn1PD_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue); + +/**************************************************************/ +/* */ +/* H223Capability_h223MultiplexTableCapability_enhanced */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223Capability_h223MultiplexTableCapability_enhanced { + ASN1UINT8 maximumNestingDepth; + ASN1UINT8 maximumElementListSize; + ASN1UINT8 maximumSubElementListSize; +} H245H223Capability_h223MultiplexTableCapability_enhanced; + +EXTERN int asn1PE_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue); + +EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue); + +/**************************************************************/ +/* */ +/* H223Capability_h223MultiplexTableCapability */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223Capability_h223MultiplexTableCapability_basic 1 +#define T_H245H223Capability_h223MultiplexTableCapability_enhanced 2 + +typedef struct EXTERN H245H223Capability_h223MultiplexTableCapability { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245H223Capability_h223MultiplexTableCapability_enhanced *enhanced; + } u; +} H245H223Capability_h223MultiplexTableCapability; + +EXTERN int asn1PE_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue); + +EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue); + +/**************************************************************/ +/* */ +/* H223Capability_mobileOperationTransmitCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223Capability_mobileOperationTransmitCapability { + ASN1BOOL modeChangeCapability; + ASN1BOOL h223AnnexA; + ASN1BOOL h223AnnexADoubleFlag; + ASN1BOOL h223AnnexB; + ASN1BOOL h223AnnexBwithHeader; +} H245H223Capability_mobileOperationTransmitCapability; + +EXTERN int asn1PE_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue); + +EXTERN int asn1PD_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue); + +/**************************************************************/ +/* */ +/* H223AnnexCCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223AnnexCCapability { + struct { + unsigned rsCodeCapabilityPresent : 1; + } m; + ASN1BOOL videoWithAL1M; + ASN1BOOL videoWithAL2M; + ASN1BOOL videoWithAL3M; + ASN1BOOL audioWithAL1M; + ASN1BOOL audioWithAL2M; + ASN1BOOL audioWithAL3M; + ASN1BOOL dataWithAL1M; + ASN1BOOL dataWithAL2M; + ASN1BOOL dataWithAL3M; + ASN1BOOL alpduInterleaving; + ASN1USINT maximumAL1MPDUSize; + ASN1USINT maximumAL2MSDUSize; + ASN1USINT maximumAL3MSDUSize; + ASN1BOOL rsCodeCapability; +} H245H223AnnexCCapability; + +EXTERN int asn1PE_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue); + +EXTERN int asn1PD_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue); + +/**************************************************************/ +/* */ +/* H223Capability_mobileMultilinkFrameCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223Capability_mobileMultilinkFrameCapability { + ASN1UINT8 maximumSampleSize; + ASN1USINT maximumPayloadLength; +} H245H223Capability_mobileMultilinkFrameCapability; + +EXTERN int asn1PE_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue); + +EXTERN int asn1PD_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue); + +/**************************************************************/ +/* */ +/* H223Capability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223Capability { + struct { + unsigned maxMUXPDUSizeCapabilityPresent : 1; + unsigned nsrpSupportPresent : 1; + unsigned mobileOperationTransmitCapabilityPresent : 1; + unsigned h223AnnexCCapabilityPresent : 1; + unsigned bitRatePresent : 1; + unsigned mobileMultilinkFrameCapabilityPresent : 1; + } m; + ASN1BOOL transportWithI_frames; + ASN1BOOL videoWithAL1; + ASN1BOOL videoWithAL2; + ASN1BOOL videoWithAL3; + ASN1BOOL audioWithAL1; + ASN1BOOL audioWithAL2; + ASN1BOOL audioWithAL3; + ASN1BOOL dataWithAL1; + ASN1BOOL dataWithAL2; + ASN1BOOL dataWithAL3; + ASN1USINT maximumAl2SDUSize; + ASN1USINT maximumAl3SDUSize; + ASN1USINT maximumDelayJitter; + H245H223Capability_h223MultiplexTableCapability h223MultiplexTableCapability; + ASN1BOOL maxMUXPDUSizeCapability; + ASN1BOOL nsrpSupport; + H245H223Capability_mobileOperationTransmitCapability mobileOperationTransmitCapability; + H245H223AnnexCCapability h223AnnexCCapability; + ASN1USINT bitRate; + H245H223Capability_mobileMultilinkFrameCapability mobileMultilinkFrameCapability; +} H245H223Capability; + +EXTERN int asn1PE_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue); + +EXTERN int asn1PD_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue); + +/**************************************************************/ +/* */ +/* V75Capability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245V75Capability { + ASN1BOOL audioHeader; +} H245V75Capability; + +EXTERN int asn1PE_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue); + +EXTERN int asn1PD_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue); + +/**************************************************************/ +/* */ +/* V76Capability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245V76Capability { + ASN1BOOL suspendResumeCapabilitywAddress; + ASN1BOOL suspendResumeCapabilitywoAddress; + ASN1BOOL rejCapability; + ASN1BOOL sREJCapability; + ASN1BOOL mREJCapability; + ASN1BOOL crc8bitCapability; + ASN1BOOL crc16bitCapability; + ASN1BOOL crc32bitCapability; + ASN1BOOL uihCapability; + ASN1USINT numOfDLCS; + ASN1BOOL twoOctetAddressFieldCapability; + ASN1BOOL loopBackTestCapability; + ASN1USINT n401Capability; + ASN1UINT8 maxWindowSizeCapability; + H245V75Capability v75Capability; +} H245V76Capability; + +EXTERN int asn1PE_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue); + +EXTERN int asn1PD_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue); + +/**************************************************************/ +/* */ +/* T84Profile_t84Restricted */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245T84Profile_t84Restricted { + ASN1BOOL qcif; + ASN1BOOL cif; + ASN1BOOL ccir601Seq; + ASN1BOOL ccir601Prog; + ASN1BOOL hdtvSeq; + ASN1BOOL hdtvProg; + ASN1BOOL g3FacsMH200x100; + ASN1BOOL g3FacsMH200x200; + ASN1BOOL g4FacsMMR200x100; + ASN1BOOL g4FacsMMR200x200; + ASN1BOOL jbig200x200Seq; + ASN1BOOL jbig200x200Prog; + ASN1BOOL jbig300x300Seq; + ASN1BOOL jbig300x300Prog; + ASN1BOOL digPhotoLow; + ASN1BOOL digPhotoMedSeq; + ASN1BOOL digPhotoMedProg; + ASN1BOOL digPhotoHighSeq; + ASN1BOOL digPhotoHighProg; +} H245T84Profile_t84Restricted; + +EXTERN int asn1PE_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue); + +EXTERN int asn1PD_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue); + +/**************************************************************/ +/* */ +/* T84Profile */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245T84Profile_t84Unrestricted 1 +#define T_H245T84Profile_t84Restricted 2 + +typedef struct EXTERN H245T84Profile { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245T84Profile_t84Restricted *t84Restricted; + } u; +} H245T84Profile; + +EXTERN int asn1PE_H245T84Profile (OOCTXT* pctxt, H245T84Profile* pvalue); + +EXTERN int asn1PD_H245T84Profile (OOCTXT* pctxt, H245T84Profile* pvalue); + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_t84 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245DataApplicationCapability_application_t84 { + H245DataProtocolCapability t84Protocol; + H245T84Profile t84Profile; +} H245DataApplicationCapability_application_t84; + +EXTERN int asn1PE_H245DataApplicationCapability_application_t84 (OOCTXT* pctxt, H245DataApplicationCapability_application_t84* pvalue); + +EXTERN int asn1PD_H245DataApplicationCapability_application_t84 (OOCTXT* pctxt, H245DataApplicationCapability_application_t84* pvalue); + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_nlpid */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245DataApplicationCapability_application_nlpid { + H245DataProtocolCapability nlpidProtocol; + ASN1DynOctStr nlpidData; +} H245DataApplicationCapability_application_nlpid; + +EXTERN int asn1PE_H245DataApplicationCapability_application_nlpid (OOCTXT* pctxt, H245DataApplicationCapability_application_nlpid* pvalue); + +EXTERN int asn1PD_H245DataApplicationCapability_application_nlpid (OOCTXT* pctxt, H245DataApplicationCapability_application_nlpid* pvalue); + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_t38fax */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245DataApplicationCapability_application_t38fax { + H245DataProtocolCapability t38FaxProtocol; + H245T38FaxProfile t38FaxProfile; +} H245DataApplicationCapability_application_t38fax; + +EXTERN int asn1PE_H245DataApplicationCapability_application_t38fax (OOCTXT* pctxt, H245DataApplicationCapability_application_t38fax* pvalue); + +EXTERN int asn1PD_H245DataApplicationCapability_application_t38fax (OOCTXT* pctxt, H245DataApplicationCapability_application_t38fax* pvalue); + +/**************************************************************/ +/* */ +/* CapabilityIdentifier_uuid */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CapabilityIdentifier_uuid { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H245CapabilityIdentifier_uuid; + +EXTERN int asn1PE_H245CapabilityIdentifier_uuid (OOCTXT* pctxt, H245CapabilityIdentifier_uuid* pvalue); + +EXTERN int asn1PD_H245CapabilityIdentifier_uuid (OOCTXT* pctxt, H245CapabilityIdentifier_uuid* pvalue); + +/**************************************************************/ +/* */ +/* CapabilityIdentifier */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CapabilityIdentifier_standard 1 +#define T_H245CapabilityIdentifier_h221NonStandard 2 +#define T_H245CapabilityIdentifier_uuid 3 +#define T_H245CapabilityIdentifier_domainBased 4 +#define T_H245CapabilityIdentifier_extElem1 5 + +typedef struct EXTERN H245CapabilityIdentifier { + int t; + union { + /* t = 1 */ + ASN1OBJID *standard; + /* t = 2 */ + H245NonStandardParameter *h221NonStandard; + /* t = 3 */ + H245CapabilityIdentifier_uuid *uuid; + /* t = 4 */ + ASN1IA5String domainBased; + /* t = 5 */ + } u; +} H245CapabilityIdentifier; + +EXTERN int asn1PE_H245CapabilityIdentifier (OOCTXT* pctxt, H245CapabilityIdentifier* pvalue); + +EXTERN int asn1PD_H245CapabilityIdentifier (OOCTXT* pctxt, H245CapabilityIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* ParameterIdentifier_uuid */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ParameterIdentifier_uuid { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H245ParameterIdentifier_uuid; + +EXTERN int asn1PE_H245ParameterIdentifier_uuid (OOCTXT* pctxt, H245ParameterIdentifier_uuid* pvalue); + +EXTERN int asn1PD_H245ParameterIdentifier_uuid (OOCTXT* pctxt, H245ParameterIdentifier_uuid* pvalue); + +/**************************************************************/ +/* */ +/* ParameterIdentifier */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ParameterIdentifier_standard 1 +#define T_H245ParameterIdentifier_h221NonStandard 2 +#define T_H245ParameterIdentifier_uuid 3 +#define T_H245ParameterIdentifier_domainBased 4 +#define T_H245ParameterIdentifier_extElem1 5 + +typedef struct EXTERN H245ParameterIdentifier { + int t; + union { + /* t = 1 */ + ASN1UINT8 standard; + /* t = 2 */ + H245NonStandardParameter *h221NonStandard; + /* t = 3 */ + H245ParameterIdentifier_uuid *uuid; + /* t = 4 */ + ASN1IA5String domainBased; + /* t = 5 */ + } u; +} H245ParameterIdentifier; + +EXTERN int asn1PE_H245ParameterIdentifier (OOCTXT* pctxt, H245ParameterIdentifier* pvalue); + +EXTERN int asn1PD_H245ParameterIdentifier (OOCTXT* pctxt, H245ParameterIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* ParameterValue */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ParameterValue_logical 1 +#define T_H245ParameterValue_booleanArray 2 +#define T_H245ParameterValue_unsignedMin 3 +#define T_H245ParameterValue_unsignedMax 4 +#define T_H245ParameterValue_unsigned32Min 5 +#define T_H245ParameterValue_unsigned32Max 6 +#define T_H245ParameterValue_octetString 7 +#define T_H245ParameterValue_genericParameter 8 +#define T_H245ParameterValue_extElem1 9 + +typedef struct EXTERN H245ParameterValue { + int t; + union { + /* t = 1 */ + /* t = 2 */ + ASN1UINT8 booleanArray; + /* t = 3 */ + ASN1USINT unsignedMin; + /* t = 4 */ + ASN1USINT unsignedMax; + /* t = 5 */ + ASN1UINT unsigned32Min; + /* t = 6 */ + ASN1UINT unsigned32Max; + /* t = 7 */ + ASN1DynOctStr *octetString; + /* t = 8 */ + DList *genericParameter; + /* t = 9 */ + } u; +} H245ParameterValue; + +EXTERN int asn1PE_H245ParameterValue (OOCTXT* pctxt, H245ParameterValue* pvalue); + +EXTERN int asn1PD_H245ParameterValue (OOCTXT* pctxt, H245ParameterValue* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245ParameterIdentifier */ +/* */ +/**************************************************************/ + +/* List of H245ParameterIdentifier */ +typedef DList H245_SeqOfH245ParameterIdentifier; + +EXTERN int asn1PE_H245_SeqOfH245ParameterIdentifier (OOCTXT* pctxt, H245_SeqOfH245ParameterIdentifier* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245ParameterIdentifier (OOCTXT* pctxt, H245_SeqOfH245ParameterIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* GenericParameter */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245GenericParameter { + struct { + unsigned supersedesPresent : 1; + } m; + H245ParameterIdentifier parameterIdentifier; + H245ParameterValue parameterValue; + H245_SeqOfH245ParameterIdentifier supersedes; +} H245GenericParameter; + +EXTERN int asn1PE_H245GenericParameter (OOCTXT* pctxt, H245GenericParameter* pvalue); + +EXTERN int asn1PD_H245GenericParameter (OOCTXT* pctxt, H245GenericParameter* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245GenericParameter */ +/* */ +/**************************************************************/ + +/* List of H245GenericParameter */ +typedef DList H245_SeqOfH245GenericParameter; + +EXTERN int asn1PE_H245_SeqOfH245GenericParameter (OOCTXT* pctxt, H245_SeqOfH245GenericParameter* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245GenericParameter (OOCTXT* pctxt, H245_SeqOfH245GenericParameter* pvalue); + +/**************************************************************/ +/* */ +/* GenericCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245GenericCapability { + struct { + unsigned maxBitRatePresent : 1; + unsigned collapsingPresent : 1; + unsigned nonCollapsingPresent : 1; + unsigned nonCollapsingRawPresent : 1; + unsigned transportPresent : 1; + } m; + H245CapabilityIdentifier capabilityIdentifier; + ASN1UINT maxBitRate; + H245_SeqOfH245GenericParameter collapsing; + H245_SeqOfH245GenericParameter nonCollapsing; + ASN1DynOctStr nonCollapsingRaw; + H245DataProtocolCapability transport; +} H245GenericCapability; + +EXTERN int asn1PE_H245GenericCapability (OOCTXT* pctxt, H245GenericCapability* pvalue); + +EXTERN int asn1PD_H245GenericCapability (OOCTXT* pctxt, H245GenericCapability* pvalue); + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245DataApplicationCapability_application_nonStandard 1 +#define T_H245DataApplicationCapability_application_t120 2 +#define T_H245DataApplicationCapability_application_dsm_cc 3 +#define T_H245DataApplicationCapability_application_userData 4 +#define T_H245DataApplicationCapability_application_t84 5 +#define T_H245DataApplicationCapability_application_t434 6 +#define T_H245DataApplicationCapability_application_h224 7 +#define T_H245DataApplicationCapability_application_nlpid 8 +#define T_H245DataApplicationCapability_application_dsvdControl 9 +#define T_H245DataApplicationCapability_application_h222DataPartitioning 10 +#define T_H245DataApplicationCapability_application_t30fax 11 +#define T_H245DataApplicationCapability_application_t140 12 +#define T_H245DataApplicationCapability_application_t38fax 13 +#define T_H245DataApplicationCapability_application_genericDataCapability 14 +#define T_H245DataApplicationCapability_application_extElem1 15 + +typedef struct EXTERN H245DataApplicationCapability_application { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245DataProtocolCapability *t120; + /* t = 3 */ + H245DataProtocolCapability *dsm_cc; + /* t = 4 */ + H245DataProtocolCapability *userData; + /* t = 5 */ + H245DataApplicationCapability_application_t84 *t84; + /* t = 6 */ + H245DataProtocolCapability *t434; + /* t = 7 */ + H245DataProtocolCapability *h224; + /* t = 8 */ + H245DataApplicationCapability_application_nlpid *nlpid; + /* t = 9 */ + /* t = 10 */ + H245DataProtocolCapability *h222DataPartitioning; + /* t = 11 */ + H245DataProtocolCapability *t30fax; + /* t = 12 */ + H245DataProtocolCapability *t140; + /* t = 13 */ + H245DataApplicationCapability_application_t38fax *t38fax; + /* t = 14 */ + H245GenericCapability *genericDataCapability; + /* t = 15 */ + } u; +} H245DataApplicationCapability_application; + +EXTERN int asn1PE_H245DataApplicationCapability_application (OOCTXT* pctxt, H245DataApplicationCapability_application* pvalue); + +EXTERN int asn1PD_H245DataApplicationCapability_application (OOCTXT* pctxt, H245DataApplicationCapability_application* pvalue); + +/**************************************************************/ +/* */ +/* DataApplicationCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245DataApplicationCapability { + H245DataApplicationCapability_application application; + ASN1UINT maxBitRate; +} H245DataApplicationCapability; + +EXTERN int asn1PE_H245DataApplicationCapability (OOCTXT* pctxt, H245DataApplicationCapability* pvalue); + +EXTERN int asn1PD_H245DataApplicationCapability (OOCTXT* pctxt, H245DataApplicationCapability* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245DataApplicationCapability */ +/* */ +/**************************************************************/ + +/* List of H245DataApplicationCapability */ +typedef DList H245_SeqOfH245DataApplicationCapability; + +EXTERN int asn1PE_H245_SeqOfH245DataApplicationCapability (OOCTXT* pctxt, H245_SeqOfH245DataApplicationCapability* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245DataApplicationCapability (OOCTXT* pctxt, H245_SeqOfH245DataApplicationCapability* pvalue); + +/**************************************************************/ +/* */ +/* MediaDistributionCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MediaDistributionCapability { + struct { + unsigned centralizedDataPresent : 1; + unsigned distributedDataPresent : 1; + } m; + ASN1BOOL centralizedControl; + ASN1BOOL distributedControl; + ASN1BOOL centralizedAudio; + ASN1BOOL distributedAudio; + ASN1BOOL centralizedVideo; + ASN1BOOL distributedVideo; + H245_SeqOfH245DataApplicationCapability centralizedData; + H245_SeqOfH245DataApplicationCapability distributedData; +} H245MediaDistributionCapability; + +EXTERN int asn1PE_H245MediaDistributionCapability (OOCTXT* pctxt, H245MediaDistributionCapability* pvalue); + +EXTERN int asn1PD_H245MediaDistributionCapability (OOCTXT* pctxt, H245MediaDistributionCapability* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245MediaDistributionCapability */ +/* */ +/**************************************************************/ + +/* List of H245MediaDistributionCapability */ +typedef DList H245_SeqOfH245MediaDistributionCapability; + +EXTERN int asn1PE_H245_SeqOfH245MediaDistributionCapability (OOCTXT* pctxt, H245_SeqOfH245MediaDistributionCapability* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245MediaDistributionCapability (OOCTXT* pctxt, H245_SeqOfH245MediaDistributionCapability* pvalue); + +/**************************************************************/ +/* */ +/* MultipointCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultipointCapability { + ASN1BOOL multicastCapability; + ASN1BOOL multiUniCastConference; + H245_SeqOfH245MediaDistributionCapability mediaDistributionCapability; +} H245MultipointCapability; + +EXTERN int asn1PE_H245MultipointCapability (OOCTXT* pctxt, H245MultipointCapability* pvalue); + +EXTERN int asn1PD_H245MultipointCapability (OOCTXT* pctxt, H245MultipointCapability* pvalue); + +/**************************************************************/ +/* */ +/* H2250Capability_mcCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H2250Capability_mcCapability { + ASN1BOOL centralizedConferenceMC; + ASN1BOOL decentralizedConferenceMC; +} H245H2250Capability_mcCapability; + +EXTERN int asn1PE_H245H2250Capability_mcCapability (OOCTXT* pctxt, H245H2250Capability_mcCapability* pvalue); + +EXTERN int asn1PD_H245H2250Capability_mcCapability (OOCTXT* pctxt, H245H2250Capability_mcCapability* pvalue); + +/**************************************************************/ +/* */ +/* RTPPayloadType_payloadDescriptor */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RTPPayloadType_payloadDescriptor_nonStandardIdentifier 1 +#define T_H245RTPPayloadType_payloadDescriptor_rfc_number 2 +#define T_H245RTPPayloadType_payloadDescriptor_oid 3 +#define T_H245RTPPayloadType_payloadDescriptor_extElem1 4 + +typedef struct EXTERN H245RTPPayloadType_payloadDescriptor { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandardIdentifier; + /* t = 2 */ + ASN1INT rfc_number; + /* t = 3 */ + ASN1OBJID *oid; + /* t = 4 */ + } u; +} H245RTPPayloadType_payloadDescriptor; + +EXTERN int asn1PE_H245RTPPayloadType_payloadDescriptor (OOCTXT* pctxt, H245RTPPayloadType_payloadDescriptor* pvalue); + +EXTERN int asn1PD_H245RTPPayloadType_payloadDescriptor (OOCTXT* pctxt, H245RTPPayloadType_payloadDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* RTPPayloadType */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RTPPayloadType { + struct { + unsigned payloadTypePresent : 1; + } m; + H245RTPPayloadType_payloadDescriptor payloadDescriptor; + ASN1UINT8 payloadType; +} H245RTPPayloadType; + +EXTERN int asn1PE_H245RTPPayloadType (OOCTXT* pctxt, H245RTPPayloadType* pvalue); + +EXTERN int asn1PD_H245RTPPayloadType (OOCTXT* pctxt, H245RTPPayloadType* pvalue); + +/**************************************************************/ +/* */ +/* MediaPacketizationCapability_rtpPayloadType */ +/* */ +/**************************************************************/ + +/* List of H245RTPPayloadType */ +typedef DList H245MediaPacketizationCapability_rtpPayloadType; + +EXTERN int asn1PE_H245MediaPacketizationCapability_rtpPayloadType (OOCTXT* pctxt, H245MediaPacketizationCapability_rtpPayloadType* pvalue); + +EXTERN int asn1PD_H245MediaPacketizationCapability_rtpPayloadType (OOCTXT* pctxt, H245MediaPacketizationCapability_rtpPayloadType* pvalue); + +/**************************************************************/ +/* */ +/* MediaPacketizationCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MediaPacketizationCapability { + struct { + unsigned rtpPayloadTypePresent : 1; + } m; + ASN1BOOL h261aVideoPacketization; + H245MediaPacketizationCapability_rtpPayloadType rtpPayloadType; +} H245MediaPacketizationCapability; + +EXTERN int asn1PE_H245MediaPacketizationCapability (OOCTXT* pctxt, H245MediaPacketizationCapability* pvalue); + +EXTERN int asn1PD_H245MediaPacketizationCapability (OOCTXT* pctxt, H245MediaPacketizationCapability* pvalue); + +/**************************************************************/ +/* */ +/* QOSMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245QOSMode_guaranteedQOS 1 +#define T_H245QOSMode_controlledLoad 2 +#define T_H245QOSMode_extElem1 3 + +typedef struct EXTERN H245QOSMode { + int t; +} H245QOSMode; + +EXTERN int asn1PE_H245QOSMode (OOCTXT* pctxt, H245QOSMode* pvalue); + +EXTERN int asn1PD_H245QOSMode (OOCTXT* pctxt, H245QOSMode* pvalue); + +/**************************************************************/ +/* */ +/* RSVPParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RSVPParameters { + struct { + unsigned qosModePresent : 1; + unsigned tokenRatePresent : 1; + unsigned bucketSizePresent : 1; + unsigned peakRatePresent : 1; + unsigned minPolicedPresent : 1; + unsigned maxPktSizePresent : 1; + } m; + H245QOSMode qosMode; + ASN1UINT tokenRate; + ASN1UINT bucketSize; + ASN1UINT peakRate; + ASN1UINT minPoliced; + ASN1UINT maxPktSize; +} H245RSVPParameters; + +EXTERN int asn1PE_H245RSVPParameters (OOCTXT* pctxt, H245RSVPParameters* pvalue); + +EXTERN int asn1PD_H245RSVPParameters (OOCTXT* pctxt, H245RSVPParameters* pvalue); + +/**************************************************************/ +/* */ +/* ATMParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ATMParameters { + ASN1USINT maxNTUSize; + ASN1BOOL atmUBR; + ASN1BOOL atmrtVBR; + ASN1BOOL atmnrtVBR; + ASN1BOOL atmABR; + ASN1BOOL atmCBR; +} H245ATMParameters; + +EXTERN int asn1PE_H245ATMParameters (OOCTXT* pctxt, H245ATMParameters* pvalue); + +EXTERN int asn1PD_H245ATMParameters (OOCTXT* pctxt, H245ATMParameters* pvalue); + +/**************************************************************/ +/* */ +/* QOSCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245QOSCapability { + struct { + unsigned nonStandardDataPresent : 1; + unsigned rsvpParametersPresent : 1; + unsigned atmParametersPresent : 1; + } m; + H245NonStandardParameter nonStandardData; + H245RSVPParameters rsvpParameters; + H245ATMParameters atmParameters; +} H245QOSCapability; + +EXTERN int asn1PE_H245QOSCapability (OOCTXT* pctxt, H245QOSCapability* pvalue); + +EXTERN int asn1PD_H245QOSCapability (OOCTXT* pctxt, H245QOSCapability* pvalue); + +/**************************************************************/ +/* */ +/* TransportCapability_qOSCapabilities */ +/* */ +/**************************************************************/ + +/* List of H245QOSCapability */ +typedef DList H245TransportCapability_qOSCapabilities; + +EXTERN int asn1PE_H245TransportCapability_qOSCapabilities (OOCTXT* pctxt, H245TransportCapability_qOSCapabilities* pvalue); + +EXTERN int asn1PD_H245TransportCapability_qOSCapabilities (OOCTXT* pctxt, H245TransportCapability_qOSCapabilities* pvalue); + +/**************************************************************/ +/* */ +/* MediaTransportType_atm_AAL5_compressed */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MediaTransportType_atm_AAL5_compressed { + ASN1BOOL variable_delta; +} H245MediaTransportType_atm_AAL5_compressed; + +EXTERN int asn1PE_H245MediaTransportType_atm_AAL5_compressed (OOCTXT* pctxt, H245MediaTransportType_atm_AAL5_compressed* pvalue); + +EXTERN int asn1PD_H245MediaTransportType_atm_AAL5_compressed (OOCTXT* pctxt, H245MediaTransportType_atm_AAL5_compressed* pvalue); + +/**************************************************************/ +/* */ +/* MediaTransportType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MediaTransportType_ip_UDP 1 +#define T_H245MediaTransportType_ip_TCP 2 +#define T_H245MediaTransportType_atm_AAL5_UNIDIR 3 +#define T_H245MediaTransportType_atm_AAL5_BIDIR 4 +#define T_H245MediaTransportType_atm_AAL5_compressed 5 +#define T_H245MediaTransportType_extElem1 6 + +typedef struct EXTERN H245MediaTransportType { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + H245MediaTransportType_atm_AAL5_compressed *atm_AAL5_compressed; + /* t = 6 */ + } u; +} H245MediaTransportType; + +EXTERN int asn1PE_H245MediaTransportType (OOCTXT* pctxt, H245MediaTransportType* pvalue); + +EXTERN int asn1PD_H245MediaTransportType (OOCTXT* pctxt, H245MediaTransportType* pvalue); + +/**************************************************************/ +/* */ +/* MediaChannelCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MediaChannelCapability { + struct { + unsigned mediaTransportPresent : 1; + } m; + H245MediaTransportType mediaTransport; +} H245MediaChannelCapability; + +EXTERN int asn1PE_H245MediaChannelCapability (OOCTXT* pctxt, H245MediaChannelCapability* pvalue); + +EXTERN int asn1PD_H245MediaChannelCapability (OOCTXT* pctxt, H245MediaChannelCapability* pvalue); + +/**************************************************************/ +/* */ +/* TransportCapability_mediaChannelCapabilities */ +/* */ +/**************************************************************/ + +/* List of H245MediaChannelCapability */ +typedef DList H245TransportCapability_mediaChannelCapabilities; + +EXTERN int asn1PE_H245TransportCapability_mediaChannelCapabilities (OOCTXT* pctxt, H245TransportCapability_mediaChannelCapabilities* pvalue); + +EXTERN int asn1PD_H245TransportCapability_mediaChannelCapabilities (OOCTXT* pctxt, H245TransportCapability_mediaChannelCapabilities* pvalue); + +/**************************************************************/ +/* */ +/* TransportCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TransportCapability { + struct { + unsigned nonStandardPresent : 1; + unsigned qOSCapabilitiesPresent : 1; + unsigned mediaChannelCapabilitiesPresent : 1; + } m; + H245NonStandardParameter nonStandard; + H245TransportCapability_qOSCapabilities qOSCapabilities; + H245TransportCapability_mediaChannelCapabilities mediaChannelCapabilities; +} H245TransportCapability; + +EXTERN int asn1PE_H245TransportCapability (OOCTXT* pctxt, H245TransportCapability* pvalue); + +EXTERN int asn1PD_H245TransportCapability (OOCTXT* pctxt, H245TransportCapability* pvalue); + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyFrameMapping_frameSequence */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RTPH263VideoRedundancyFrameMapping_frameSequence { + ASN1UINT n; + ASN1UINT8 elem[256]; +} H245RTPH263VideoRedundancyFrameMapping_frameSequence; + +EXTERN int asn1PE_H245RTPH263VideoRedundancyFrameMapping_frameSequence (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping_frameSequence* pvalue); + +EXTERN int asn1PD_H245RTPH263VideoRedundancyFrameMapping_frameSequence (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping_frameSequence* pvalue); + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyFrameMapping */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RTPH263VideoRedundancyFrameMapping { + ASN1UINT8 threadNumber; + H245RTPH263VideoRedundancyFrameMapping_frameSequence frameSequence; +} H245RTPH263VideoRedundancyFrameMapping; + +EXTERN int asn1PE_H245RTPH263VideoRedundancyFrameMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping* pvalue); + +EXTERN int asn1PD_H245RTPH263VideoRedundancyFrameMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping* pvalue); + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_frameToThreadMapping_cust */ +/* */ +/**************************************************************/ + +/* List of H245RTPH263VideoRedundancyFrameMapping */ +typedef DList H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom; + +EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom* pvalue); + +EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom* pvalue); + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_frameToThreadMapping */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_roundrobin 1 +#define T_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom 2 +#define T_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_extElem1 3 + +typedef struct EXTERN H245RTPH263VideoRedundancyEncoding_frameToThreadMapping { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom *custom; + /* t = 3 */ + } u; +} H245RTPH263VideoRedundancyEncoding_frameToThreadMapping; + +EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping* pvalue); + +EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping* pvalue); + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_containedThreads */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RTPH263VideoRedundancyEncoding_containedThreads { + ASN1UINT n; + ASN1UINT8 elem[256]; +} H245RTPH263VideoRedundancyEncoding_containedThreads; + +EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_containedThreads (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_containedThreads* pvalue); + +EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_containedThreads (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_containedThreads* pvalue); + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RTPH263VideoRedundancyEncoding { + struct { + unsigned containedThreadsPresent : 1; + } m; + ASN1UINT8 numberOfThreads; + ASN1USINT framesBetweenSyncPoints; + H245RTPH263VideoRedundancyEncoding_frameToThreadMapping frameToThreadMapping; + H245RTPH263VideoRedundancyEncoding_containedThreads containedThreads; +} H245RTPH263VideoRedundancyEncoding; + +EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding* pvalue); + +EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingMethod */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RedundancyEncodingMethod_nonStandard 1 +#define T_H245RedundancyEncodingMethod_rtpAudioRedundancyEncoding 2 +#define T_H245RedundancyEncodingMethod_rtpH263VideoRedundancyEncoding 3 +#define T_H245RedundancyEncodingMethod_extElem1 4 + +typedef struct EXTERN H245RedundancyEncodingMethod { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + H245RTPH263VideoRedundancyEncoding *rtpH263VideoRedundancyEncoding; + /* t = 4 */ + } u; +} H245RedundancyEncodingMethod; + +EXTERN int asn1PE_H245RedundancyEncodingMethod (OOCTXT* pctxt, H245RedundancyEncodingMethod* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingMethod (OOCTXT* pctxt, H245RedundancyEncodingMethod* pvalue); + +/**************************************************************/ +/* */ +/* CapabilityTableEntryNumber */ +/* */ +/**************************************************************/ + +typedef ASN1USINT H245CapabilityTableEntryNumber; + +EXTERN int asn1PE_H245CapabilityTableEntryNumber (OOCTXT* pctxt, H245CapabilityTableEntryNumber value); + +EXTERN int asn1PD_H245CapabilityTableEntryNumber (OOCTXT* pctxt, H245CapabilityTableEntryNumber* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingCapability_secondaryEncoding */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RedundancyEncodingCapability_secondaryEncoding { + ASN1UINT n; + H245CapabilityTableEntryNumber elem[256]; +} H245RedundancyEncodingCapability_secondaryEncoding; + +EXTERN int asn1PE_H245RedundancyEncodingCapability_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingCapability_secondaryEncoding* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingCapability_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingCapability_secondaryEncoding* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RedundancyEncodingCapability { + struct { + unsigned secondaryEncodingPresent : 1; + } m; + H245RedundancyEncodingMethod redundancyEncodingMethod; + H245CapabilityTableEntryNumber primaryEncoding; + H245RedundancyEncodingCapability_secondaryEncoding secondaryEncoding; +} H245RedundancyEncodingCapability; + +EXTERN int asn1PE_H245RedundancyEncodingCapability (OOCTXT* pctxt, H245RedundancyEncodingCapability* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingCapability (OOCTXT* pctxt, H245RedundancyEncodingCapability* pvalue); + +/**************************************************************/ +/* */ +/* H2250Capability_redundancyEncodingCapability */ +/* */ +/**************************************************************/ + +/* List of H245RedundancyEncodingCapability */ +typedef DList H245H2250Capability_redundancyEncodingCapability; + +EXTERN int asn1PE_H245H2250Capability_redundancyEncodingCapability (OOCTXT* pctxt, H245H2250Capability_redundancyEncodingCapability* pvalue); + +EXTERN int asn1PD_H245H2250Capability_redundancyEncodingCapability (OOCTXT* pctxt, H245H2250Capability_redundancyEncodingCapability* pvalue); + +/**************************************************************/ +/* */ +/* H2250Capability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H2250Capability { + struct { + unsigned transportCapabilityPresent : 1; + unsigned redundancyEncodingCapabilityPresent : 1; + unsigned logicalChannelSwitchingCapabilityPresent : 1; + unsigned t120DynamicPortCapabilityPresent : 1; + } m; + ASN1USINT maximumAudioDelayJitter; + H245MultipointCapability receiveMultipointCapability; + H245MultipointCapability transmitMultipointCapability; + H245MultipointCapability receiveAndTransmitMultipointCapability; + H245H2250Capability_mcCapability mcCapability; + ASN1BOOL rtcpVideoControlCapability; + H245MediaPacketizationCapability mediaPacketizationCapability; + H245TransportCapability transportCapability; + H245H2250Capability_redundancyEncodingCapability redundancyEncodingCapability; + ASN1BOOL logicalChannelSwitchingCapability; + ASN1BOOL t120DynamicPortCapability; +} H245H2250Capability; + +EXTERN int asn1PE_H245H2250Capability (OOCTXT* pctxt, H245H2250Capability* pvalue); + +EXTERN int asn1PD_H245H2250Capability (OOCTXT* pctxt, H245H2250Capability* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexCapability */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultiplexCapability_nonStandard 1 +#define T_H245MultiplexCapability_h222Capability 2 +#define T_H245MultiplexCapability_h223Capability 3 +#define T_H245MultiplexCapability_v76Capability 4 +#define T_H245MultiplexCapability_h2250Capability 5 +#define T_H245MultiplexCapability_genericMultiplexCapability 6 +#define T_H245MultiplexCapability_extElem1 7 + +typedef struct EXTERN H245MultiplexCapability { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245H222Capability *h222Capability; + /* t = 3 */ + H245H223Capability *h223Capability; + /* t = 4 */ + H245V76Capability *v76Capability; + /* t = 5 */ + H245H2250Capability *h2250Capability; + /* t = 6 */ + H245GenericCapability *genericMultiplexCapability; + /* t = 7 */ + } u; +} H245MultiplexCapability; + +EXTERN int asn1PE_H245MultiplexCapability (OOCTXT* pctxt, H245MultiplexCapability* pvalue); + +EXTERN int asn1PD_H245MultiplexCapability (OOCTXT* pctxt, H245MultiplexCapability* pvalue); + +/**************************************************************/ +/* */ +/* H261VideoCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H261VideoCapability { + struct { + unsigned qcifMPIPresent : 1; + unsigned cifMPIPresent : 1; + unsigned videoBadMBsCapPresent : 1; + } m; + ASN1UINT8 qcifMPI; + ASN1UINT8 cifMPI; + ASN1BOOL temporalSpatialTradeOffCapability; + ASN1USINT maxBitRate; + ASN1BOOL stillImageTransmission; + ASN1BOOL videoBadMBsCap; +} H245H261VideoCapability; + +EXTERN int asn1PE_H245H261VideoCapability (OOCTXT* pctxt, H245H261VideoCapability* pvalue); + +EXTERN int asn1PD_H245H261VideoCapability (OOCTXT* pctxt, H245H261VideoCapability* pvalue); + +/**************************************************************/ +/* */ +/* H262VideoCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H262VideoCapability { + struct { + unsigned videoBitRatePresent : 1; + unsigned vbvBufferSizePresent : 1; + unsigned samplesPerLinePresent : 1; + unsigned linesPerFramePresent : 1; + unsigned framesPerSecondPresent : 1; + unsigned luminanceSampleRatePresent : 1; + unsigned videoBadMBsCapPresent : 1; + } m; + ASN1BOOL profileAndLevel_SPatML; + ASN1BOOL profileAndLevel_MPatLL; + ASN1BOOL profileAndLevel_MPatML; + ASN1BOOL profileAndLevel_MPatH_14; + ASN1BOOL profileAndLevel_MPatHL; + ASN1BOOL profileAndLevel_SNRatLL; + ASN1BOOL profileAndLevel_SNRatML; + ASN1BOOL profileAndLevel_SpatialatH_14; + ASN1BOOL profileAndLevel_HPatML; + ASN1BOOL profileAndLevel_HPatH_14; + ASN1BOOL profileAndLevel_HPatHL; + ASN1UINT videoBitRate; + ASN1UINT vbvBufferSize; + ASN1USINT samplesPerLine; + ASN1USINT linesPerFrame; + ASN1UINT8 framesPerSecond; + ASN1UINT luminanceSampleRate; + ASN1BOOL videoBadMBsCap; +} H245H262VideoCapability; + +EXTERN int asn1PE_H245H262VideoCapability (OOCTXT* pctxt, H245H262VideoCapability* pvalue); + +EXTERN int asn1PD_H245H262VideoCapability (OOCTXT* pctxt, H245H262VideoCapability* pvalue); + +/**************************************************************/ +/* */ +/* TransparencyParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TransparencyParameters { + ASN1USINT presentationOrder; + ASN1INT offset_x; + ASN1INT offset_y; + ASN1UINT8 scale_x; + ASN1UINT8 scale_y; +} H245TransparencyParameters; + +EXTERN int asn1PE_H245TransparencyParameters (OOCTXT* pctxt, H245TransparencyParameters* pvalue); + +EXTERN int asn1PD_H245TransparencyParameters (OOCTXT* pctxt, H245TransparencyParameters* pvalue); + +/**************************************************************/ +/* */ +/* RefPictureSelection_additionalPictureMemory */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RefPictureSelection_additionalPictureMemory { + struct { + unsigned sqcifAdditionalPictureMemoryPresent : 1; + unsigned qcifAdditionalPictureMemoryPresent : 1; + unsigned cifAdditionalPictureMemoryPresent : 1; + unsigned cif4AdditionalPictureMemoryPresent : 1; + unsigned cif16AdditionalPictureMemoryPresent : 1; + unsigned bigCpfAdditionalPictureMemoryPresent : 1; + } m; + ASN1USINT sqcifAdditionalPictureMemory; + ASN1USINT qcifAdditionalPictureMemory; + ASN1USINT cifAdditionalPictureMemory; + ASN1USINT cif4AdditionalPictureMemory; + ASN1USINT cif16AdditionalPictureMemory; + ASN1USINT bigCpfAdditionalPictureMemory; +} H245RefPictureSelection_additionalPictureMemory; + +EXTERN int asn1PE_H245RefPictureSelection_additionalPictureMemory (OOCTXT* pctxt, H245RefPictureSelection_additionalPictureMemory* pvalue); + +EXTERN int asn1PD_H245RefPictureSelection_additionalPictureMemory (OOCTXT* pctxt, H245RefPictureSelection_additionalPictureMemory* pvalue); + +/**************************************************************/ +/* */ +/* RefPictureSelection_videoBackChannelSend */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RefPictureSelection_videoBackChannelSend_none 1 +#define T_H245RefPictureSelection_videoBackChannelSend_ackMessageOnly 2 +#define T_H245RefPictureSelection_videoBackChannelSend_nackMessageOnly 3 +#define T_H245RefPictureSelection_videoBackChannelSend_ackOrNackMessageOnly 4 +#define T_H245RefPictureSelection_videoBackChannelSend_ackAndNackMessage 5 +#define T_H245RefPictureSelection_videoBackChannelSend_extElem1 6 + +typedef struct EXTERN H245RefPictureSelection_videoBackChannelSend { + int t; +} H245RefPictureSelection_videoBackChannelSend; + +EXTERN int asn1PE_H245RefPictureSelection_videoBackChannelSend (OOCTXT* pctxt, H245RefPictureSelection_videoBackChannelSend* pvalue); + +EXTERN int asn1PD_H245RefPictureSelection_videoBackChannelSend (OOCTXT* pctxt, H245RefPictureSelection_videoBackChannelSend* pvalue); + +/**************************************************************/ +/* */ +/* RefPictureSelection_enhancedReferencePicSelect_subPictur */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters { + ASN1UINT8 mpuHorizMBs; + ASN1UINT8 mpuVertMBs; + ASN1UINT mpuTotalNumber; +} H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters; + +EXTERN int asn1PE_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters* pvalue); + +EXTERN int asn1PD_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters* pvalue); + +/**************************************************************/ +/* */ +/* RefPictureSelection_enhancedReferencePicSelect */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RefPictureSelection_enhancedReferencePicSelect { + struct { + unsigned subPictureRemovalParametersPresent : 1; + } m; + H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters subPictureRemovalParameters; +} H245RefPictureSelection_enhancedReferencePicSelect; + +EXTERN int asn1PE_H245RefPictureSelection_enhancedReferencePicSelect (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect* pvalue); + +EXTERN int asn1PD_H245RefPictureSelection_enhancedReferencePicSelect (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect* pvalue); + +/**************************************************************/ +/* */ +/* RefPictureSelection */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RefPictureSelection { + struct { + unsigned additionalPictureMemoryPresent : 1; + unsigned enhancedReferencePicSelectPresent : 1; + } m; + H245RefPictureSelection_additionalPictureMemory additionalPictureMemory; + ASN1BOOL videoMux; + H245RefPictureSelection_videoBackChannelSend videoBackChannelSend; + H245RefPictureSelection_enhancedReferencePicSelect enhancedReferencePicSelect; +} H245RefPictureSelection; + +EXTERN int asn1PE_H245RefPictureSelection (OOCTXT* pctxt, H245RefPictureSelection* pvalue); + +EXTERN int asn1PD_H245RefPictureSelection (OOCTXT* pctxt, H245RefPictureSelection* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureClockFrequency */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CustomPictureClockFrequency { + struct { + unsigned sqcifMPIPresent : 1; + unsigned qcifMPIPresent : 1; + unsigned cifMPIPresent : 1; + unsigned cif4MPIPresent : 1; + unsigned cif16MPIPresent : 1; + } m; + ASN1USINT clockConversionCode; + ASN1UINT8 clockDivisor; + ASN1USINT sqcifMPI; + ASN1USINT qcifMPI; + ASN1USINT cifMPI; + ASN1USINT cif4MPI; + ASN1USINT cif16MPI; +} H245CustomPictureClockFrequency; + +EXTERN int asn1PE_H245CustomPictureClockFrequency (OOCTXT* pctxt, H245CustomPictureClockFrequency* pvalue); + +EXTERN int asn1PD_H245CustomPictureClockFrequency (OOCTXT* pctxt, H245CustomPictureClockFrequency* pvalue); + +/**************************************************************/ +/* */ +/* H263Options_customPictureClockFrequency */ +/* */ +/**************************************************************/ + +/* List of H245CustomPictureClockFrequency */ +typedef DList H245H263Options_customPictureClockFrequency; + +EXTERN int asn1PE_H245H263Options_customPictureClockFrequency (OOCTXT* pctxt, H245H263Options_customPictureClockFrequency* pvalue); + +EXTERN int asn1PD_H245H263Options_customPictureClockFrequency (OOCTXT* pctxt, H245H263Options_customPictureClockFrequency* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI_customPCF_element */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CustomPictureFormat_mPI_customPCF_element { + ASN1USINT clockConversionCode; + ASN1UINT8 clockDivisor; + ASN1USINT customMPI; +} H245CustomPictureFormat_mPI_customPCF_element; + +EXTERN int asn1PE_H245CustomPictureFormat_mPI_customPCF_element (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF_element* pvalue); + +EXTERN int asn1PD_H245CustomPictureFormat_mPI_customPCF_element (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF_element* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI_customPCF */ +/* */ +/**************************************************************/ + +/* List of H245CustomPictureFormat_mPI_customPCF_element */ +typedef DList H245CustomPictureFormat_mPI_customPCF; + +EXTERN int asn1PE_H245CustomPictureFormat_mPI_customPCF (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF* pvalue); + +EXTERN int asn1PD_H245CustomPictureFormat_mPI_customPCF (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CustomPictureFormat_mPI { + struct { + unsigned standardMPIPresent : 1; + unsigned customPCFPresent : 1; + } m; + ASN1UINT8 standardMPI; + H245CustomPictureFormat_mPI_customPCF customPCF; +} H245CustomPictureFormat_mPI; + +EXTERN int asn1PE_H245CustomPictureFormat_mPI (OOCTXT* pctxt, H245CustomPictureFormat_mPI* pvalue); + +EXTERN int asn1PD_H245CustomPictureFormat_mPI (OOCTXT* pctxt, H245CustomPictureFormat_mPI* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_pixelAspectCo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode { + ASN1UINT n; + ASN1UINT8 elem[14]; +} H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode; + +EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode* pvalue); + +EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_extendedPAR_e */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element { + ASN1UINT8 width; + ASN1UINT8 height; +} H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element; + +EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pvalue); + +EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_extendedPAR */ +/* */ +/**************************************************************/ + +/* List of H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element */ +typedef DList H245CustomPictureFormat_pixelAspectInformation_extendedPAR; + +EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR* pvalue); + +EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CustomPictureFormat_pixelAspectInformation_anyPixelAspectRatio 1 +#define T_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode 2 +#define T_H245CustomPictureFormat_pixelAspectInformation_extendedPAR 3 +#define T_H245CustomPictureFormat_pixelAspectInformation_extElem1 4 + +typedef struct EXTERN H245CustomPictureFormat_pixelAspectInformation { + int t; + union { + /* t = 1 */ + ASN1BOOL anyPixelAspectRatio; + /* t = 2 */ + H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode *pixelAspectCode; + /* t = 3 */ + H245CustomPictureFormat_pixelAspectInformation_extendedPAR *extendedPAR; + /* t = 4 */ + } u; +} H245CustomPictureFormat_pixelAspectInformation; + +EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation* pvalue); + +EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation* pvalue); + +/**************************************************************/ +/* */ +/* CustomPictureFormat */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CustomPictureFormat { + ASN1USINT maxCustomPictureWidth; + ASN1USINT maxCustomPictureHeight; + ASN1USINT minCustomPictureWidth; + ASN1USINT minCustomPictureHeight; + H245CustomPictureFormat_mPI mPI; + H245CustomPictureFormat_pixelAspectInformation pixelAspectInformation; +} H245CustomPictureFormat; + +EXTERN int asn1PE_H245CustomPictureFormat (OOCTXT* pctxt, H245CustomPictureFormat* pvalue); + +EXTERN int asn1PD_H245CustomPictureFormat (OOCTXT* pctxt, H245CustomPictureFormat* pvalue); + +/**************************************************************/ +/* */ +/* H263Options_customPictureFormat */ +/* */ +/**************************************************************/ + +/* List of H245CustomPictureFormat */ +typedef DList H245H263Options_customPictureFormat; + +EXTERN int asn1PE_H245H263Options_customPictureFormat (OOCTXT* pctxt, H245H263Options_customPictureFormat* pvalue); + +EXTERN int asn1PD_H245H263Options_customPictureFormat (OOCTXT* pctxt, H245H263Options_customPictureFormat* pvalue); + +/**************************************************************/ +/* */ +/* H263Version3Options */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H263Version3Options { + ASN1BOOL dataPartitionedSlices; + ASN1BOOL fixedPointIDCT0; + ASN1BOOL interlacedFields; + ASN1BOOL currentPictureHeaderRepetition; + ASN1BOOL previousPictureHeaderRepetition; + ASN1BOOL nextPictureHeaderRepetition; + ASN1BOOL pictureNumber; + ASN1BOOL spareReferencePictures; +} H245H263Version3Options; + +EXTERN int asn1PE_H245H263Version3Options (OOCTXT* pctxt, H245H263Version3Options* pvalue); + +EXTERN int asn1PD_H245H263Version3Options (OOCTXT* pctxt, H245H263Version3Options* pvalue); + +/**************************************************************/ +/* */ +/* H263ModeComboFlags */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H263ModeComboFlags { + struct { + unsigned enhancedReferencePicSelectPresent : 1; + unsigned h263Version3OptionsPresent : 1; + } m; + ASN1BOOL unrestrictedVector; + ASN1BOOL arithmeticCoding; + ASN1BOOL advancedPrediction; + ASN1BOOL pbFrames; + ASN1BOOL advancedIntraCodingMode; + ASN1BOOL deblockingFilterMode; + ASN1BOOL unlimitedMotionVectors; + ASN1BOOL slicesInOrder_NonRect; + ASN1BOOL slicesInOrder_Rect; + ASN1BOOL slicesNoOrder_NonRect; + ASN1BOOL slicesNoOrder_Rect; + ASN1BOOL improvedPBFramesMode; + ASN1BOOL referencePicSelect; + ASN1BOOL dynamicPictureResizingByFour; + ASN1BOOL dynamicPictureResizingSixteenthPel; + ASN1BOOL dynamicWarpingHalfPel; + ASN1BOOL dynamicWarpingSixteenthPel; + ASN1BOOL reducedResolutionUpdate; + ASN1BOOL independentSegmentDecoding; + ASN1BOOL alternateInterVLCMode; + ASN1BOOL modifiedQuantizationMode; + ASN1BOOL enhancedReferencePicSelect; + H245H263Version3Options h263Version3Options; +} H245H263ModeComboFlags; + +EXTERN int asn1PE_H245H263ModeComboFlags (OOCTXT* pctxt, H245H263ModeComboFlags* pvalue); + +EXTERN int asn1PD_H245H263ModeComboFlags (OOCTXT* pctxt, H245H263ModeComboFlags* pvalue); + +/**************************************************************/ +/* */ +/* H263VideoModeCombos_h263VideoCoupledModes */ +/* */ +/**************************************************************/ + +/* List of H245H263ModeComboFlags */ +typedef DList H245H263VideoModeCombos_h263VideoCoupledModes; + +EXTERN int asn1PE_H245H263VideoModeCombos_h263VideoCoupledModes (OOCTXT* pctxt, H245H263VideoModeCombos_h263VideoCoupledModes* pvalue); + +EXTERN int asn1PD_H245H263VideoModeCombos_h263VideoCoupledModes (OOCTXT* pctxt, H245H263VideoModeCombos_h263VideoCoupledModes* pvalue); + +/**************************************************************/ +/* */ +/* H263VideoModeCombos */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H263VideoModeCombos { + H245H263ModeComboFlags h263VideoUncoupledModes; + H245H263VideoModeCombos_h263VideoCoupledModes h263VideoCoupledModes; +} H245H263VideoModeCombos; + +EXTERN int asn1PE_H245H263VideoModeCombos (OOCTXT* pctxt, H245H263VideoModeCombos* pvalue); + +EXTERN int asn1PD_H245H263VideoModeCombos (OOCTXT* pctxt, H245H263VideoModeCombos* pvalue); + +/**************************************************************/ +/* */ +/* H263Options_modeCombos */ +/* */ +/**************************************************************/ + +/* List of H245H263VideoModeCombos */ +typedef DList H245H263Options_modeCombos; + +EXTERN int asn1PE_H245H263Options_modeCombos (OOCTXT* pctxt, H245H263Options_modeCombos* pvalue); + +EXTERN int asn1PD_H245H263Options_modeCombos (OOCTXT* pctxt, H245H263Options_modeCombos* pvalue); + +/**************************************************************/ +/* */ +/* H263Options */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H263Options { + struct { + unsigned transparencyParametersPresent : 1; + unsigned refPictureSelectionPresent : 1; + unsigned customPictureClockFrequencyPresent : 1; + unsigned customPictureFormatPresent : 1; + unsigned modeCombosPresent : 1; + unsigned videoBadMBsCapPresent : 1; + unsigned h263Version3OptionsPresent : 1; + } m; + ASN1BOOL advancedIntraCodingMode; + ASN1BOOL deblockingFilterMode; + ASN1BOOL improvedPBFramesMode; + ASN1BOOL unlimitedMotionVectors; + ASN1BOOL fullPictureFreeze; + ASN1BOOL partialPictureFreezeAndRelease; + ASN1BOOL resizingPartPicFreezeAndRelease; + ASN1BOOL fullPictureSnapshot; + ASN1BOOL partialPictureSnapshot; + ASN1BOOL videoSegmentTagging; + ASN1BOOL progressiveRefinement; + ASN1BOOL dynamicPictureResizingByFour; + ASN1BOOL dynamicPictureResizingSixteenthPel; + ASN1BOOL dynamicWarpingHalfPel; + ASN1BOOL dynamicWarpingSixteenthPel; + ASN1BOOL independentSegmentDecoding; + ASN1BOOL slicesInOrder_NonRect; + ASN1BOOL slicesInOrder_Rect; + ASN1BOOL slicesNoOrder_NonRect; + ASN1BOOL slicesNoOrder_Rect; + ASN1BOOL alternateInterVLCMode; + ASN1BOOL modifiedQuantizationMode; + ASN1BOOL reducedResolutionUpdate; + H245TransparencyParameters transparencyParameters; + ASN1BOOL separateVideoBackChannel; + H245RefPictureSelection refPictureSelection; + H245H263Options_customPictureClockFrequency customPictureClockFrequency; + H245H263Options_customPictureFormat customPictureFormat; + H245H263Options_modeCombos modeCombos; + ASN1BOOL videoBadMBsCap; + H245H263Version3Options h263Version3Options; +} H245H263Options; + +EXTERN int asn1PE_H245H263Options (OOCTXT* pctxt, H245H263Options* pvalue); + +EXTERN int asn1PD_H245H263Options (OOCTXT* pctxt, H245H263Options* pvalue); + +/**************************************************************/ +/* */ +/* EnhancementOptions */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245EnhancementOptions { + struct { + unsigned sqcifMPIPresent : 1; + unsigned qcifMPIPresent : 1; + unsigned cifMPIPresent : 1; + unsigned cif4MPIPresent : 1; + unsigned cif16MPIPresent : 1; + unsigned slowSqcifMPIPresent : 1; + unsigned slowQcifMPIPresent : 1; + unsigned slowCifMPIPresent : 1; + unsigned slowCif4MPIPresent : 1; + unsigned slowCif16MPIPresent : 1; + unsigned h263OptionsPresent : 1; + } m; + ASN1UINT8 sqcifMPI; + ASN1UINT8 qcifMPI; + ASN1UINT8 cifMPI; + ASN1UINT8 cif4MPI; + ASN1UINT8 cif16MPI; + ASN1UINT maxBitRate; + ASN1BOOL unrestrictedVector; + ASN1BOOL arithmeticCoding; + ASN1BOOL temporalSpatialTradeOffCapability; + ASN1USINT slowSqcifMPI; + ASN1USINT slowQcifMPI; + ASN1USINT slowCifMPI; + ASN1USINT slowCif4MPI; + ASN1USINT slowCif16MPI; + ASN1BOOL errorCompensation; + H245H263Options h263Options; +} H245EnhancementOptions; + +EXTERN int asn1PE_H245EnhancementOptions (OOCTXT* pctxt, H245EnhancementOptions* pvalue); + +EXTERN int asn1PD_H245EnhancementOptions (OOCTXT* pctxt, H245EnhancementOptions* pvalue); + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_snrEnhancement */ +/* */ +/**************************************************************/ + +/* List of H245EnhancementOptions */ +typedef DList H245EnhancementLayerInfo_snrEnhancement; + +EXTERN int asn1PE_H245EnhancementLayerInfo_snrEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_snrEnhancement* pvalue); + +EXTERN int asn1PD_H245EnhancementLayerInfo_snrEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_snrEnhancement* pvalue); + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_spatialEnhancement */ +/* */ +/**************************************************************/ + +/* List of H245EnhancementOptions */ +typedef DList H245EnhancementLayerInfo_spatialEnhancement; + +EXTERN int asn1PE_H245EnhancementLayerInfo_spatialEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_spatialEnhancement* pvalue); + +EXTERN int asn1PD_H245EnhancementLayerInfo_spatialEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_spatialEnhancement* pvalue); + +/**************************************************************/ +/* */ +/* BEnhancementParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245BEnhancementParameters { + H245EnhancementOptions enhancementOptions; + ASN1UINT8 numberOfBPictures; +} H245BEnhancementParameters; + +EXTERN int asn1PE_H245BEnhancementParameters (OOCTXT* pctxt, H245BEnhancementParameters* pvalue); + +EXTERN int asn1PD_H245BEnhancementParameters (OOCTXT* pctxt, H245BEnhancementParameters* pvalue); + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_bPictureEnhancement */ +/* */ +/**************************************************************/ + +/* List of H245BEnhancementParameters */ +typedef DList H245EnhancementLayerInfo_bPictureEnhancement; + +EXTERN int asn1PE_H245EnhancementLayerInfo_bPictureEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_bPictureEnhancement* pvalue); + +EXTERN int asn1PD_H245EnhancementLayerInfo_bPictureEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_bPictureEnhancement* pvalue); + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245EnhancementLayerInfo { + struct { + unsigned snrEnhancementPresent : 1; + unsigned spatialEnhancementPresent : 1; + unsigned bPictureEnhancementPresent : 1; + } m; + ASN1BOOL baseBitRateConstrained; + H245EnhancementLayerInfo_snrEnhancement snrEnhancement; + H245EnhancementLayerInfo_spatialEnhancement spatialEnhancement; + H245EnhancementLayerInfo_bPictureEnhancement bPictureEnhancement; +} H245EnhancementLayerInfo; + +EXTERN int asn1PE_H245EnhancementLayerInfo (OOCTXT* pctxt, H245EnhancementLayerInfo* pvalue); + +EXTERN int asn1PD_H245EnhancementLayerInfo (OOCTXT* pctxt, H245EnhancementLayerInfo* pvalue); + +/**************************************************************/ +/* */ +/* H263VideoCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H263VideoCapability { + struct { + unsigned sqcifMPIPresent : 1; + unsigned qcifMPIPresent : 1; + unsigned cifMPIPresent : 1; + unsigned cif4MPIPresent : 1; + unsigned cif16MPIPresent : 1; + unsigned hrd_BPresent : 1; + unsigned bppMaxKbPresent : 1; + unsigned slowSqcifMPIPresent : 1; + unsigned slowQcifMPIPresent : 1; + unsigned slowCifMPIPresent : 1; + unsigned slowCif4MPIPresent : 1; + unsigned slowCif16MPIPresent : 1; + unsigned errorCompensationPresent : 1; + unsigned enhancementLayerInfoPresent : 1; + unsigned h263OptionsPresent : 1; + } m; + ASN1UINT8 sqcifMPI; + ASN1UINT8 qcifMPI; + ASN1UINT8 cifMPI; + ASN1UINT8 cif4MPI; + ASN1UINT8 cif16MPI; + ASN1UINT maxBitRate; + ASN1BOOL unrestrictedVector; + ASN1BOOL arithmeticCoding; + ASN1BOOL advancedPrediction; + ASN1BOOL pbFrames; + ASN1BOOL temporalSpatialTradeOffCapability; + ASN1UINT hrd_B; + ASN1USINT bppMaxKb; + ASN1USINT slowSqcifMPI; + ASN1USINT slowQcifMPI; + ASN1USINT slowCifMPI; + ASN1USINT slowCif4MPI; + ASN1USINT slowCif16MPI; + ASN1BOOL errorCompensation; + H245EnhancementLayerInfo enhancementLayerInfo; + H245H263Options h263Options; +} H245H263VideoCapability; + +EXTERN int asn1PE_H245H263VideoCapability (OOCTXT* pctxt, H245H263VideoCapability* pvalue); + +EXTERN int asn1PD_H245H263VideoCapability (OOCTXT* pctxt, H245H263VideoCapability* pvalue); + +/**************************************************************/ +/* */ +/* IS11172VideoCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245IS11172VideoCapability { + struct { + unsigned videoBitRatePresent : 1; + unsigned vbvBufferSizePresent : 1; + unsigned samplesPerLinePresent : 1; + unsigned linesPerFramePresent : 1; + unsigned pictureRatePresent : 1; + unsigned luminanceSampleRatePresent : 1; + unsigned videoBadMBsCapPresent : 1; + } m; + ASN1BOOL constrainedBitstream; + ASN1UINT videoBitRate; + ASN1UINT vbvBufferSize; + ASN1USINT samplesPerLine; + ASN1USINT linesPerFrame; + ASN1UINT8 pictureRate; + ASN1UINT luminanceSampleRate; + ASN1BOOL videoBadMBsCap; +} H245IS11172VideoCapability; + +EXTERN int asn1PE_H245IS11172VideoCapability (OOCTXT* pctxt, H245IS11172VideoCapability* pvalue); + +EXTERN int asn1PD_H245IS11172VideoCapability (OOCTXT* pctxt, H245IS11172VideoCapability* pvalue); + +/**************************************************************/ +/* */ +/* VideoCapability */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245VideoCapability_nonStandard 1 +#define T_H245VideoCapability_h261VideoCapability 2 +#define T_H245VideoCapability_h262VideoCapability 3 +#define T_H245VideoCapability_h263VideoCapability 4 +#define T_H245VideoCapability_is11172VideoCapability 5 +#define T_H245VideoCapability_genericVideoCapability 6 +#define T_H245VideoCapability_extElem1 7 + +typedef struct EXTERN H245VideoCapability { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245H261VideoCapability *h261VideoCapability; + /* t = 3 */ + H245H262VideoCapability *h262VideoCapability; + /* t = 4 */ + H245H263VideoCapability *h263VideoCapability; + /* t = 5 */ + H245IS11172VideoCapability *is11172VideoCapability; + /* t = 6 */ + H245GenericCapability *genericVideoCapability; + /* t = 7 */ + } u; +} H245VideoCapability; + +EXTERN int asn1PE_H245VideoCapability (OOCTXT* pctxt, H245VideoCapability* pvalue); + +EXTERN int asn1PD_H245VideoCapability (OOCTXT* pctxt, H245VideoCapability* pvalue); + +/**************************************************************/ +/* */ +/* AudioCapability_g7231 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245AudioCapability_g7231 { + ASN1USINT maxAl_sduAudioFrames; + ASN1BOOL silenceSuppression; +} H245AudioCapability_g7231; + +EXTERN int asn1PE_H245AudioCapability_g7231 (OOCTXT* pctxt, H245AudioCapability_g7231* pvalue); + +EXTERN int asn1PD_H245AudioCapability_g7231 (OOCTXT* pctxt, H245AudioCapability_g7231* pvalue); + +/**************************************************************/ +/* */ +/* IS11172AudioCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245IS11172AudioCapability { + ASN1BOOL audioLayer1; + ASN1BOOL audioLayer2; + ASN1BOOL audioLayer3; + ASN1BOOL audioSampling32k; + ASN1BOOL audioSampling44k1; + ASN1BOOL audioSampling48k; + ASN1BOOL singleChannel; + ASN1BOOL twoChannels; + ASN1USINT bitRate; +} H245IS11172AudioCapability; + +EXTERN int asn1PE_H245IS11172AudioCapability (OOCTXT* pctxt, H245IS11172AudioCapability* pvalue); + +EXTERN int asn1PD_H245IS11172AudioCapability (OOCTXT* pctxt, H245IS11172AudioCapability* pvalue); + +/**************************************************************/ +/* */ +/* IS13818AudioCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245IS13818AudioCapability { + ASN1BOOL audioLayer1; + ASN1BOOL audioLayer2; + ASN1BOOL audioLayer3; + ASN1BOOL audioSampling16k; + ASN1BOOL audioSampling22k05; + ASN1BOOL audioSampling24k; + ASN1BOOL audioSampling32k; + ASN1BOOL audioSampling44k1; + ASN1BOOL audioSampling48k; + ASN1BOOL singleChannel; + ASN1BOOL twoChannels; + ASN1BOOL threeChannels2_1; + ASN1BOOL threeChannels3_0; + ASN1BOOL fourChannels2_0_2_0; + ASN1BOOL fourChannels2_2; + ASN1BOOL fourChannels3_1; + ASN1BOOL fiveChannels3_0_2_0; + ASN1BOOL fiveChannels3_2; + ASN1BOOL lowFrequencyEnhancement; + ASN1BOOL multilingual; + ASN1USINT bitRate; +} H245IS13818AudioCapability; + +EXTERN int asn1PE_H245IS13818AudioCapability (OOCTXT* pctxt, H245IS13818AudioCapability* pvalue); + +EXTERN int asn1PD_H245IS13818AudioCapability (OOCTXT* pctxt, H245IS13818AudioCapability* pvalue); + +/**************************************************************/ +/* */ +/* G7231AnnexCCapability_g723AnnexCAudioMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245G7231AnnexCCapability_g723AnnexCAudioMode { + ASN1UINT8 highRateMode0; + ASN1UINT8 highRateMode1; + ASN1UINT8 lowRateMode0; + ASN1UINT8 lowRateMode1; + ASN1UINT8 sidMode0; + ASN1UINT8 sidMode1; +} H245G7231AnnexCCapability_g723AnnexCAudioMode; + +EXTERN int asn1PE_H245G7231AnnexCCapability_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCCapability_g723AnnexCAudioMode* pvalue); + +EXTERN int asn1PD_H245G7231AnnexCCapability_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCCapability_g723AnnexCAudioMode* pvalue); + +/**************************************************************/ +/* */ +/* G7231AnnexCCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245G7231AnnexCCapability { + struct { + unsigned g723AnnexCAudioModePresent : 1; + } m; + ASN1USINT maxAl_sduAudioFrames; + ASN1BOOL silenceSuppression; + H245G7231AnnexCCapability_g723AnnexCAudioMode g723AnnexCAudioMode; +} H245G7231AnnexCCapability; + +EXTERN int asn1PE_H245G7231AnnexCCapability (OOCTXT* pctxt, H245G7231AnnexCCapability* pvalue); + +EXTERN int asn1PD_H245G7231AnnexCCapability (OOCTXT* pctxt, H245G7231AnnexCCapability* pvalue); + +/**************************************************************/ +/* */ +/* GSMAudioCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245GSMAudioCapability { + ASN1USINT audioUnitSize; + ASN1BOOL comfortNoise; + ASN1BOOL scrambled; +} H245GSMAudioCapability; + +EXTERN int asn1PE_H245GSMAudioCapability (OOCTXT* pctxt, H245GSMAudioCapability* pvalue); + +EXTERN int asn1PD_H245GSMAudioCapability (OOCTXT* pctxt, H245GSMAudioCapability* pvalue); + +/**************************************************************/ +/* */ +/* G729Extensions */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245G729Extensions { + struct { + unsigned audioUnitPresent : 1; + } m; + ASN1USINT audioUnit; + ASN1BOOL annexA; + ASN1BOOL annexB; + ASN1BOOL annexD; + ASN1BOOL annexE; + ASN1BOOL annexF; + ASN1BOOL annexG; + ASN1BOOL annexH; +} H245G729Extensions; + +EXTERN int asn1PE_H245G729Extensions (OOCTXT* pctxt, H245G729Extensions* pvalue); + +EXTERN int asn1PD_H245G729Extensions (OOCTXT* pctxt, H245G729Extensions* pvalue); + +/**************************************************************/ +/* */ +/* VBDCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VBDCapability { + struct H245AudioCapability *type; +} H245VBDCapability; + +EXTERN int asn1PE_H245VBDCapability (OOCTXT* pctxt, H245VBDCapability* pvalue); + +EXTERN int asn1PD_H245VBDCapability (OOCTXT* pctxt, H245VBDCapability* pvalue); + +/**************************************************************/ +/* */ +/* NoPTAudioTelephonyEventCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NoPTAudioTelephonyEventCapability { + ASN1GeneralString audioTelephoneEvent; +} H245NoPTAudioTelephonyEventCapability; + +EXTERN int asn1PE_H245NoPTAudioTelephonyEventCapability (OOCTXT* pctxt, H245NoPTAudioTelephonyEventCapability* pvalue); + +EXTERN int asn1PD_H245NoPTAudioTelephonyEventCapability (OOCTXT* pctxt, H245NoPTAudioTelephonyEventCapability* pvalue); + +/**************************************************************/ +/* */ +/* NoPTAudioToneCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NoPTAudioToneCapability { + ASN1OCTET __dummy__; +} H245NoPTAudioToneCapability; + +EXTERN int asn1PE_H245NoPTAudioToneCapability (OOCTXT* pctxt, H245NoPTAudioToneCapability* pvalue); + +EXTERN int asn1PD_H245NoPTAudioToneCapability (OOCTXT* pctxt, H245NoPTAudioToneCapability* pvalue); + +/**************************************************************/ +/* */ +/* AudioCapability */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245AudioCapability_nonStandard 1 +#define T_H245AudioCapability_g711Alaw64k 2 +#define T_H245AudioCapability_g711Alaw56k 3 +#define T_H245AudioCapability_g711Ulaw64k 4 +#define T_H245AudioCapability_g711Ulaw56k 5 +#define T_H245AudioCapability_g722_64k 6 +#define T_H245AudioCapability_g722_56k 7 +#define T_H245AudioCapability_g722_48k 8 +#define T_H245AudioCapability_g7231 9 +#define T_H245AudioCapability_g728 10 +#define T_H245AudioCapability_g729 11 +#define T_H245AudioCapability_g729AnnexA 12 +#define T_H245AudioCapability_is11172AudioCapability 13 +#define T_H245AudioCapability_is13818AudioCapability 14 +#define T_H245AudioCapability_g729wAnnexB 15 +#define T_H245AudioCapability_g729AnnexAwAnnexB 16 +#define T_H245AudioCapability_g7231AnnexCCapability 17 +#define T_H245AudioCapability_gsmFullRate 18 +#define T_H245AudioCapability_gsmHalfRate 19 +#define T_H245AudioCapability_gsmEnhancedFullRate 20 +#define T_H245AudioCapability_genericAudioCapability 21 +#define T_H245AudioCapability_g729Extensions 22 +#define T_H245AudioCapability_vbd 23 +#define T_H245AudioCapability_audioTelephonyEvent 24 +#define T_H245AudioCapability_audioTone 25 +#define T_H245AudioCapability_extElem1 26 + +typedef struct EXTERN H245AudioCapability { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + ASN1USINT g711Alaw64k; + /* t = 3 */ + ASN1USINT g711Alaw56k; + /* t = 4 */ + ASN1USINT g711Ulaw64k; + /* t = 5 */ + ASN1USINT g711Ulaw56k; + /* t = 6 */ + ASN1USINT g722_64k; + /* t = 7 */ + ASN1USINT g722_56k; + /* t = 8 */ + ASN1USINT g722_48k; + /* t = 9 */ + H245AudioCapability_g7231 *g7231; + /* t = 10 */ + ASN1USINT g728; + /* t = 11 */ + ASN1USINT g729; + /* t = 12 */ + ASN1USINT g729AnnexA; + /* t = 13 */ + H245IS11172AudioCapability *is11172AudioCapability; + /* t = 14 */ + H245IS13818AudioCapability *is13818AudioCapability; + /* t = 15 */ + ASN1USINT g729wAnnexB; + /* t = 16 */ + ASN1USINT g729AnnexAwAnnexB; + /* t = 17 */ + H245G7231AnnexCCapability *g7231AnnexCCapability; + /* t = 18 */ + H245GSMAudioCapability *gsmFullRate; + /* t = 19 */ + H245GSMAudioCapability *gsmHalfRate; + /* t = 20 */ + H245GSMAudioCapability *gsmEnhancedFullRate; + /* t = 21 */ + H245GenericCapability *genericAudioCapability; + /* t = 22 */ + H245G729Extensions *g729Extensions; + /* t = 23 */ + H245VBDCapability *vbd; + /* t = 24 */ + H245NoPTAudioTelephonyEventCapability *audioTelephonyEvent; + /* t = 25 */ + H245NoPTAudioToneCapability *audioTone; + /* t = 26 */ + } u; +} H245AudioCapability; + +EXTERN int asn1PE_H245AudioCapability (OOCTXT* pctxt, H245AudioCapability* pvalue); + +EXTERN int asn1PD_H245AudioCapability (OOCTXT* pctxt, H245AudioCapability* pvalue); + +/**************************************************************/ +/* */ +/* Capability_h233EncryptionReceiveCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245Capability_h233EncryptionReceiveCapability { + ASN1UINT8 h233IVResponseTime; +} H245Capability_h233EncryptionReceiveCapability; + +EXTERN int asn1PE_H245Capability_h233EncryptionReceiveCapability (OOCTXT* pctxt, H245Capability_h233EncryptionReceiveCapability* pvalue); + +EXTERN int asn1PD_H245Capability_h233EncryptionReceiveCapability (OOCTXT* pctxt, H245Capability_h233EncryptionReceiveCapability* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245NonStandardParameter */ +/* */ +/**************************************************************/ + +/* List of H245NonStandardParameter */ +typedef DList H245_SeqOfH245NonStandardParameter; + +EXTERN int asn1PE_H245_SeqOfH245NonStandardParameter (OOCTXT* pctxt, H245_SeqOfH245NonStandardParameter* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245NonStandardParameter (OOCTXT* pctxt, H245_SeqOfH245NonStandardParameter* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceCapability { + struct { + unsigned nonStandardDataPresent : 1; + unsigned videoIndicateMixingCapabilityPresent : 1; + unsigned multipointVisualizationCapabilityPresent : 1; + } m; + H245_SeqOfH245NonStandardParameter nonStandardData; + ASN1BOOL chairControlCapability; + ASN1BOOL videoIndicateMixingCapability; + ASN1BOOL multipointVisualizationCapability; +} H245ConferenceCapability; + +EXTERN int asn1PE_H245ConferenceCapability (OOCTXT* pctxt, H245ConferenceCapability* pvalue); + +EXTERN int asn1PD_H245ConferenceCapability (OOCTXT* pctxt, H245ConferenceCapability* pvalue); + +/**************************************************************/ +/* */ +/* MediaEncryptionAlgorithm */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MediaEncryptionAlgorithm_nonStandard 1 +#define T_H245MediaEncryptionAlgorithm_algorithm 2 +#define T_H245MediaEncryptionAlgorithm_extElem1 3 + +typedef struct EXTERN H245MediaEncryptionAlgorithm { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + ASN1OBJID *algorithm; + /* t = 3 */ + } u; +} H245MediaEncryptionAlgorithm; + +EXTERN int asn1PE_H245MediaEncryptionAlgorithm (OOCTXT* pctxt, H245MediaEncryptionAlgorithm* pvalue); + +EXTERN int asn1PD_H245MediaEncryptionAlgorithm (OOCTXT* pctxt, H245MediaEncryptionAlgorithm* pvalue); + +/**************************************************************/ +/* */ +/* EncryptionCapability */ +/* */ +/**************************************************************/ + +/* List of H245MediaEncryptionAlgorithm */ +typedef DList H245EncryptionCapability; + +EXTERN int asn1PE_H245EncryptionCapability (OOCTXT* pctxt, H245EncryptionCapability* pvalue); + +EXTERN int asn1PD_H245EncryptionCapability (OOCTXT* pctxt, H245EncryptionCapability* pvalue); + +/**************************************************************/ +/* */ +/* AuthenticationCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245AuthenticationCapability { + struct { + unsigned nonStandardPresent : 1; + unsigned antiSpamAlgorithmPresent : 1; + } m; + H245NonStandardParameter nonStandard; + ASN1OBJID antiSpamAlgorithm; +} H245AuthenticationCapability; + +EXTERN int asn1PE_H245AuthenticationCapability (OOCTXT* pctxt, H245AuthenticationCapability* pvalue); + +EXTERN int asn1PD_H245AuthenticationCapability (OOCTXT* pctxt, H245AuthenticationCapability* pvalue); + +/**************************************************************/ +/* */ +/* IntegrityCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245IntegrityCapability { + struct { + unsigned nonStandardPresent : 1; + } m; + H245NonStandardParameter nonStandard; +} H245IntegrityCapability; + +EXTERN int asn1PE_H245IntegrityCapability (OOCTXT* pctxt, H245IntegrityCapability* pvalue); + +EXTERN int asn1PD_H245IntegrityCapability (OOCTXT* pctxt, H245IntegrityCapability* pvalue); + +/**************************************************************/ +/* */ +/* EncryptionAuthenticationAndIntegrity */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245EncryptionAuthenticationAndIntegrity { + struct { + unsigned encryptionCapabilityPresent : 1; + unsigned authenticationCapabilityPresent : 1; + unsigned integrityCapabilityPresent : 1; + } m; + H245EncryptionCapability encryptionCapability; + H245AuthenticationCapability authenticationCapability; + H245IntegrityCapability integrityCapability; +} H245EncryptionAuthenticationAndIntegrity; + +EXTERN int asn1PE_H245EncryptionAuthenticationAndIntegrity (OOCTXT* pctxt, H245EncryptionAuthenticationAndIntegrity* pvalue); + +EXTERN int asn1PD_H245EncryptionAuthenticationAndIntegrity (OOCTXT* pctxt, H245EncryptionAuthenticationAndIntegrity* pvalue); + +/**************************************************************/ +/* */ +/* H235SecurityCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H235SecurityCapability { + H245EncryptionAuthenticationAndIntegrity encryptionAuthenticationAndIntegrity; + H245CapabilityTableEntryNumber mediaCapability; +} H245H235SecurityCapability; + +EXTERN int asn1PE_H245H235SecurityCapability (OOCTXT* pctxt, H245H235SecurityCapability* pvalue); + +EXTERN int asn1PD_H245H235SecurityCapability (OOCTXT* pctxt, H245H235SecurityCapability* pvalue); + +/**************************************************************/ +/* */ +/* UserInputCapability_nonStandard */ +/* */ +/**************************************************************/ + +/* List of H245NonStandardParameter */ +typedef DList H245UserInputCapability_nonStandard; + +EXTERN int asn1PE_H245UserInputCapability_nonStandard (OOCTXT* pctxt, H245UserInputCapability_nonStandard* pvalue); + +EXTERN int asn1PD_H245UserInputCapability_nonStandard (OOCTXT* pctxt, H245UserInputCapability_nonStandard* pvalue); + +/**************************************************************/ +/* */ +/* UserInputCapability */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245UserInputCapability_nonStandard 1 +#define T_H245UserInputCapability_basicString 2 +#define T_H245UserInputCapability_iA5String 3 +#define T_H245UserInputCapability_generalString 4 +#define T_H245UserInputCapability_dtmf 5 +#define T_H245UserInputCapability_hookflash 6 +#define T_H245UserInputCapability_extendedAlphanumeric 7 +#define T_H245UserInputCapability_extElem1 8 + +typedef struct EXTERN H245UserInputCapability { + int t; + union { + /* t = 1 */ + H245UserInputCapability_nonStandard *nonStandard; + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + } u; +} H245UserInputCapability; + +EXTERN int asn1PE_H245UserInputCapability (OOCTXT* pctxt, H245UserInputCapability* pvalue); + +EXTERN int asn1PD_H245UserInputCapability (OOCTXT* pctxt, H245UserInputCapability* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexFormat */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultiplexFormat_nonStandard 1 +#define T_H245MultiplexFormat_h222Capability 2 +#define T_H245MultiplexFormat_h223Capability 3 +#define T_H245MultiplexFormat_extElem1 4 + +typedef struct EXTERN H245MultiplexFormat { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245H222Capability *h222Capability; + /* t = 3 */ + H245H223Capability *h223Capability; + /* t = 4 */ + } u; +} H245MultiplexFormat; + +EXTERN int asn1PE_H245MultiplexFormat (OOCTXT* pctxt, H245MultiplexFormat* pvalue); + +EXTERN int asn1PD_H245MultiplexFormat (OOCTXT* pctxt, H245MultiplexFormat* pvalue); + +/**************************************************************/ +/* */ +/* AlternativeCapabilitySet */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245AlternativeCapabilitySet { + ASN1UINT n; + H245CapabilityTableEntryNumber elem[256]; +} H245AlternativeCapabilitySet; + +EXTERN int asn1PE_H245AlternativeCapabilitySet (OOCTXT* pctxt, H245AlternativeCapabilitySet* pvalue); + +EXTERN int asn1PD_H245AlternativeCapabilitySet (OOCTXT* pctxt, H245AlternativeCapabilitySet* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexedStreamCapability_capabilityOnMuxStream */ +/* */ +/**************************************************************/ + +/* List of H245AlternativeCapabilitySet */ +typedef DList H245MultiplexedStreamCapability_capabilityOnMuxStream; + +EXTERN int asn1PE_H245MultiplexedStreamCapability_capabilityOnMuxStream (OOCTXT* pctxt, H245MultiplexedStreamCapability_capabilityOnMuxStream* pvalue); + +EXTERN int asn1PD_H245MultiplexedStreamCapability_capabilityOnMuxStream (OOCTXT* pctxt, H245MultiplexedStreamCapability_capabilityOnMuxStream* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexedStreamCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexedStreamCapability { + struct { + unsigned capabilityOnMuxStreamPresent : 1; + } m; + H245MultiplexFormat multiplexFormat; + ASN1BOOL controlOnMuxStream; + H245MultiplexedStreamCapability_capabilityOnMuxStream capabilityOnMuxStream; +} H245MultiplexedStreamCapability; + +EXTERN int asn1PE_H245MultiplexedStreamCapability (OOCTXT* pctxt, H245MultiplexedStreamCapability* pvalue); + +EXTERN int asn1PD_H245MultiplexedStreamCapability (OOCTXT* pctxt, H245MultiplexedStreamCapability* pvalue); + +/**************************************************************/ +/* */ +/* AudioTelephonyEventCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245AudioTelephonyEventCapability { + ASN1UINT8 dynamicRTPPayloadType; + ASN1GeneralString audioTelephoneEvent; +} H245AudioTelephonyEventCapability; + +EXTERN int asn1PE_H245AudioTelephonyEventCapability (OOCTXT* pctxt, H245AudioTelephonyEventCapability* pvalue); + +EXTERN int asn1PD_H245AudioTelephonyEventCapability (OOCTXT* pctxt, H245AudioTelephonyEventCapability* pvalue); + +/**************************************************************/ +/* */ +/* AudioToneCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245AudioToneCapability { + ASN1UINT8 dynamicRTPPayloadType; +} H245AudioToneCapability; + +EXTERN int asn1PE_H245AudioToneCapability (OOCTXT* pctxt, H245AudioToneCapability* pvalue); + +EXTERN int asn1PD_H245AudioToneCapability (OOCTXT* pctxt, H245AudioToneCapability* pvalue); + +/**************************************************************/ +/* */ +/* FECCapability_rfc2733_separateStream */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FECCapability_rfc2733_separateStream { + ASN1BOOL separatePort; + ASN1BOOL samePort; +} H245FECCapability_rfc2733_separateStream; + +EXTERN int asn1PE_H245FECCapability_rfc2733_separateStream (OOCTXT* pctxt, H245FECCapability_rfc2733_separateStream* pvalue); + +EXTERN int asn1PD_H245FECCapability_rfc2733_separateStream (OOCTXT* pctxt, H245FECCapability_rfc2733_separateStream* pvalue); + +/**************************************************************/ +/* */ +/* FECCapability_rfc2733 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FECCapability_rfc2733 { + ASN1BOOL redundancyEncoding; + H245FECCapability_rfc2733_separateStream separateStream; +} H245FECCapability_rfc2733; + +EXTERN int asn1PE_H245FECCapability_rfc2733 (OOCTXT* pctxt, H245FECCapability_rfc2733* pvalue); + +EXTERN int asn1PD_H245FECCapability_rfc2733 (OOCTXT* pctxt, H245FECCapability_rfc2733* pvalue); + +/**************************************************************/ +/* */ +/* FECCapability */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FECCapability_rfc2733 1 +#define T_H245FECCapability_extElem1 2 + +typedef struct EXTERN H245FECCapability { + int t; + union { + /* t = 1 */ + H245FECCapability_rfc2733 *rfc2733; + /* t = 2 */ + } u; +} H245FECCapability; + +EXTERN int asn1PE_H245FECCapability (OOCTXT* pctxt, H245FECCapability* pvalue); + +EXTERN int asn1PD_H245FECCapability (OOCTXT* pctxt, H245FECCapability* pvalue); + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamCapability_capabilities */ +/* */ +/**************************************************************/ + +/* List of H245AlternativeCapabilitySet */ +typedef DList H245MultiplePayloadStreamCapability_capabilities; + +EXTERN int asn1PE_H245MultiplePayloadStreamCapability_capabilities (OOCTXT* pctxt, H245MultiplePayloadStreamCapability_capabilities* pvalue); + +EXTERN int asn1PD_H245MultiplePayloadStreamCapability_capabilities (OOCTXT* pctxt, H245MultiplePayloadStreamCapability_capabilities* pvalue); + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamCapability */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplePayloadStreamCapability { + H245MultiplePayloadStreamCapability_capabilities capabilities; +} H245MultiplePayloadStreamCapability; + +EXTERN int asn1PE_H245MultiplePayloadStreamCapability (OOCTXT* pctxt, H245MultiplePayloadStreamCapability* pvalue); + +EXTERN int asn1PD_H245MultiplePayloadStreamCapability (OOCTXT* pctxt, H245MultiplePayloadStreamCapability* pvalue); + +/**************************************************************/ +/* */ +/* Capability */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245Capability_nonStandard 1 +#define T_H245Capability_receiveVideoCapability 2 +#define T_H245Capability_transmitVideoCapability 3 +#define T_H245Capability_receiveAndTransmitVideoCapability 4 +#define T_H245Capability_receiveAudioCapability 5 +#define T_H245Capability_transmitAudioCapability 6 +#define T_H245Capability_receiveAndTransmitAudioCapability 7 +#define T_H245Capability_receiveDataApplicationCapability 8 +#define T_H245Capability_transmitDataApplicationCapability 9 +#define T_H245Capability_receiveAndTransmitDataApplicationCapability 10 +#define T_H245Capability_h233EncryptionTransmitCapability 11 +#define T_H245Capability_h233EncryptionReceiveCapability 12 +#define T_H245Capability_conferenceCapability 13 +#define T_H245Capability_h235SecurityCapability 14 +#define T_H245Capability_maxPendingReplacementFor 15 +#define T_H245Capability_receiveUserInputCapability 16 +#define T_H245Capability_transmitUserInputCapability 17 +#define T_H245Capability_receiveAndTransmitUserInputCapability 18 +#define T_H245Capability_genericControlCapability 19 +#define T_H245Capability_receiveMultiplexedStreamCapability 20 +#define T_H245Capability_transmitMultiplexedStreamCapability 21 +#define T_H245Capability_receiveAndTransmitMultiplexedStreamCapability 22 +#define T_H245Capability_receiveRTPAudioTelephonyEventCapability 23 +#define T_H245Capability_receiveRTPAudioToneCapability 24 +#define T_H245Capability_fecCapability 25 +#define T_H245Capability_multiplePayloadStreamCapability 26 +#define T_H245Capability_extElem1 27 + +typedef struct EXTERN H245Capability { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245VideoCapability *receiveVideoCapability; + /* t = 3 */ + H245VideoCapability *transmitVideoCapability; + /* t = 4 */ + H245VideoCapability *receiveAndTransmitVideoCapability; + /* t = 5 */ + H245AudioCapability *receiveAudioCapability; + /* t = 6 */ + H245AudioCapability *transmitAudioCapability; + /* t = 7 */ + H245AudioCapability *receiveAndTransmitAudioCapability; + /* t = 8 */ + H245DataApplicationCapability *receiveDataApplicationCapability; + /* t = 9 */ + H245DataApplicationCapability *transmitDataApplicationCapability; + /* t = 10 */ + H245DataApplicationCapability *receiveAndTransmitDataApplicationCapability; + /* t = 11 */ + ASN1BOOL h233EncryptionTransmitCapability; + /* t = 12 */ + H245Capability_h233EncryptionReceiveCapability *h233EncryptionReceiveCapability; + /* t = 13 */ + H245ConferenceCapability *conferenceCapability; + /* t = 14 */ + H245H235SecurityCapability *h235SecurityCapability; + /* t = 15 */ + ASN1UINT8 maxPendingReplacementFor; + /* t = 16 */ + H245UserInputCapability *receiveUserInputCapability; + /* t = 17 */ + H245UserInputCapability *transmitUserInputCapability; + /* t = 18 */ + H245UserInputCapability *receiveAndTransmitUserInputCapability; + /* t = 19 */ + H245GenericCapability *genericControlCapability; + /* t = 20 */ + H245MultiplexedStreamCapability *receiveMultiplexedStreamCapability; + /* t = 21 */ + H245MultiplexedStreamCapability *transmitMultiplexedStreamCapability; + /* t = 22 */ + H245MultiplexedStreamCapability *receiveAndTransmitMultiplexedStreamCapability; + /* t = 23 */ + H245AudioTelephonyEventCapability *receiveRTPAudioTelephonyEventCapability; + /* t = 24 */ + H245AudioToneCapability *receiveRTPAudioToneCapability; + /* t = 25 */ + H245FECCapability *fecCapability; + /* t = 26 */ + H245MultiplePayloadStreamCapability *multiplePayloadStreamCapability; + /* t = 27 */ + } u; +} H245Capability; + +EXTERN int asn1PE_H245Capability (OOCTXT* pctxt, H245Capability* pvalue); + +EXTERN int asn1PD_H245Capability (OOCTXT* pctxt, H245Capability* pvalue); + +/**************************************************************/ +/* */ +/* CapabilityTableEntry */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CapabilityTableEntry { + struct { + unsigned capabilityPresent : 1; + } m; + H245CapabilityTableEntryNumber capabilityTableEntryNumber; + H245Capability capability; +} H245CapabilityTableEntry; + +EXTERN int asn1PE_H245CapabilityTableEntry (OOCTXT* pctxt, H245CapabilityTableEntry* pvalue); + +EXTERN int asn1PD_H245CapabilityTableEntry (OOCTXT* pctxt, H245CapabilityTableEntry* pvalue); + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet_capabilityTable */ +/* */ +/**************************************************************/ + +/* List of H245CapabilityTableEntry */ +typedef DList H245TerminalCapabilitySet_capabilityTable; + +EXTERN int asn1PE_H245TerminalCapabilitySet_capabilityTable (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityTable* pvalue); + +EXTERN int asn1PD_H245TerminalCapabilitySet_capabilityTable (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityTable* pvalue); + +/**************************************************************/ +/* */ +/* CapabilityDescriptorNumber */ +/* */ +/**************************************************************/ + +typedef ASN1UINT8 H245CapabilityDescriptorNumber; + +EXTERN int asn1PE_H245CapabilityDescriptorNumber (OOCTXT* pctxt, H245CapabilityDescriptorNumber value); + +EXTERN int asn1PD_H245CapabilityDescriptorNumber (OOCTXT* pctxt, H245CapabilityDescriptorNumber* pvalue); + +/**************************************************************/ +/* */ +/* CapabilityDescriptor_simultaneousCapabilities */ +/* */ +/**************************************************************/ + +/* List of H245AlternativeCapabilitySet */ +typedef DList H245CapabilityDescriptor_simultaneousCapabilities; + +EXTERN int asn1PE_H245CapabilityDescriptor_simultaneousCapabilities (OOCTXT* pctxt, H245CapabilityDescriptor_simultaneousCapabilities* pvalue); + +EXTERN int asn1PD_H245CapabilityDescriptor_simultaneousCapabilities (OOCTXT* pctxt, H245CapabilityDescriptor_simultaneousCapabilities* pvalue); + +/**************************************************************/ +/* */ +/* CapabilityDescriptor */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CapabilityDescriptor { + struct { + unsigned simultaneousCapabilitiesPresent : 1; + } m; + H245CapabilityDescriptorNumber capabilityDescriptorNumber; + H245CapabilityDescriptor_simultaneousCapabilities simultaneousCapabilities; +} H245CapabilityDescriptor; + +EXTERN int asn1PE_H245CapabilityDescriptor (OOCTXT* pctxt, H245CapabilityDescriptor* pvalue); + +EXTERN int asn1PD_H245CapabilityDescriptor (OOCTXT* pctxt, H245CapabilityDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet_capabilityDescriptors */ +/* */ +/**************************************************************/ + +/* List of H245CapabilityDescriptor */ +typedef DList H245TerminalCapabilitySet_capabilityDescriptors; + +EXTERN int asn1PE_H245TerminalCapabilitySet_capabilityDescriptors (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityDescriptors* pvalue); + +EXTERN int asn1PD_H245TerminalCapabilitySet_capabilityDescriptors (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityDescriptors* pvalue); + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TerminalCapabilitySet { + struct { + unsigned multiplexCapabilityPresent : 1; + unsigned capabilityTablePresent : 1; + unsigned capabilityDescriptorsPresent : 1; + } m; + H245SequenceNumber sequenceNumber; + ASN1OBJID protocolIdentifier; + H245MultiplexCapability multiplexCapability; + H245TerminalCapabilitySet_capabilityTable capabilityTable; + H245TerminalCapabilitySet_capabilityDescriptors capabilityDescriptors; +} H245TerminalCapabilitySet; + +EXTERN int asn1PE_H245TerminalCapabilitySet (OOCTXT* pctxt, H245TerminalCapabilitySet* pvalue); + +EXTERN int asn1PD_H245TerminalCapabilitySet (OOCTXT* pctxt, H245TerminalCapabilitySet* pvalue); + +/**************************************************************/ +/* */ +/* LogicalChannelNumber */ +/* */ +/**************************************************************/ + +typedef ASN1USINT H245LogicalChannelNumber; + +EXTERN int asn1PE_H245LogicalChannelNumber (OOCTXT* pctxt, H245LogicalChannelNumber value); + +EXTERN int asn1PD_H245LogicalChannelNumber (OOCTXT* pctxt, H245LogicalChannelNumber* pvalue); + +/**************************************************************/ +/* */ +/* EncryptionMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245EncryptionMode_nonStandard 1 +#define T_H245EncryptionMode_h233Encryption 2 +#define T_H245EncryptionMode_extElem1 3 + +typedef struct EXTERN H245EncryptionMode { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + } u; +} H245EncryptionMode; + +EXTERN int asn1PE_H245EncryptionMode (OOCTXT* pctxt, H245EncryptionMode* pvalue); + +EXTERN int asn1PD_H245EncryptionMode (OOCTXT* pctxt, H245EncryptionMode* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingElement */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RedundancyEncodingElement { + struct { + unsigned payloadTypePresent : 1; + } m; + struct H245DataType *dataType; + ASN1UINT8 payloadType; +} H245RedundancyEncodingElement; + +EXTERN int asn1PE_H245RedundancyEncodingElement (OOCTXT* pctxt, H245RedundancyEncodingElement* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingElement (OOCTXT* pctxt, H245RedundancyEncodingElement* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245RedundancyEncodingElement */ +/* */ +/**************************************************************/ + +/* List of H245RedundancyEncodingElement */ +typedef DList H245_SeqOfH245RedundancyEncodingElement; + +EXTERN int asn1PE_H245_SeqOfH245RedundancyEncodingElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingElement* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245RedundancyEncodingElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingElement* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncoding_rtpRedundancyEncoding */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RedundancyEncoding_rtpRedundancyEncoding { + struct { + unsigned primaryPresent : 1; + unsigned secondaryPresent : 1; + } m; + H245RedundancyEncodingElement primary; + H245_SeqOfH245RedundancyEncodingElement secondary; +} H245RedundancyEncoding_rtpRedundancyEncoding; + +EXTERN int asn1PE_H245RedundancyEncoding_rtpRedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding_rtpRedundancyEncoding* pvalue); + +EXTERN int asn1PD_H245RedundancyEncoding_rtpRedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding_rtpRedundancyEncoding* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncoding */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RedundancyEncoding { + struct { + unsigned secondaryEncodingPresent : 1; + unsigned rtpRedundancyEncodingPresent : 1; + } m; + H245RedundancyEncodingMethod redundancyEncodingMethod; + struct H245DataType *secondaryEncoding; + H245RedundancyEncoding_rtpRedundancyEncoding rtpRedundancyEncoding; +} H245RedundancyEncoding; + +EXTERN int asn1PE_H245RedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding* pvalue); + +EXTERN int asn1PD_H245RedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding* pvalue); + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamElement */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplePayloadStreamElement { + struct { + unsigned payloadTypePresent : 1; + } m; + struct H245DataType *dataType; + ASN1UINT8 payloadType; +} H245MultiplePayloadStreamElement; + +EXTERN int asn1PE_H245MultiplePayloadStreamElement (OOCTXT* pctxt, H245MultiplePayloadStreamElement* pvalue); + +EXTERN int asn1PD_H245MultiplePayloadStreamElement (OOCTXT* pctxt, H245MultiplePayloadStreamElement* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245MultiplePayloadStreamElement */ +/* */ +/**************************************************************/ + +/* List of H245MultiplePayloadStreamElement */ +typedef DList H245_SeqOfH245MultiplePayloadStreamElement; + +EXTERN int asn1PE_H245_SeqOfH245MultiplePayloadStreamElement (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElement* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245MultiplePayloadStreamElement (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElement* pvalue); + +/**************************************************************/ +/* */ +/* MultiplePayloadStream */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplePayloadStream { + H245_SeqOfH245MultiplePayloadStreamElement elements; +} H245MultiplePayloadStream; + +EXTERN int asn1PE_H245MultiplePayloadStream (OOCTXT* pctxt, H245MultiplePayloadStream* pvalue); + +EXTERN int asn1PD_H245MultiplePayloadStream (OOCTXT* pctxt, H245MultiplePayloadStream* pvalue); + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream_differentPort */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FECData_rfc2733_mode_separateStream_differentPort { + struct { + unsigned protectedPayloadTypePresent : 1; + } m; + ASN1UINT8 protectedSessionID; + ASN1UINT8 protectedPayloadType; +} H245FECData_rfc2733_mode_separateStream_differentPort; + +EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_differentPort* pvalue); + +EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_differentPort* pvalue); + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream_samePort */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FECData_rfc2733_mode_separateStream_samePort { + ASN1UINT8 protectedPayloadType; +} H245FECData_rfc2733_mode_separateStream_samePort; + +EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream_samePort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_samePort* pvalue); + +EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream_samePort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_samePort* pvalue); + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FECData_rfc2733_mode_separateStream_differentPort 1 +#define T_H245FECData_rfc2733_mode_separateStream_samePort 2 +#define T_H245FECData_rfc2733_mode_separateStream_extElem1 3 + +typedef struct EXTERN H245FECData_rfc2733_mode_separateStream { + int t; + union { + /* t = 1 */ + H245FECData_rfc2733_mode_separateStream_differentPort *differentPort; + /* t = 2 */ + H245FECData_rfc2733_mode_separateStream_samePort *samePort; + /* t = 3 */ + } u; +} H245FECData_rfc2733_mode_separateStream; + +EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream* pvalue); + +EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream* pvalue); + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FECData_rfc2733_mode_redundancyEncoding 1 +#define T_H245FECData_rfc2733_mode_separateStream 2 +#define T_H245FECData_rfc2733_mode_extElem1 3 + +typedef struct EXTERN H245FECData_rfc2733_mode { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245FECData_rfc2733_mode_separateStream *separateStream; + /* t = 3 */ + } u; +} H245FECData_rfc2733_mode; + +EXTERN int asn1PE_H245FECData_rfc2733_mode (OOCTXT* pctxt, H245FECData_rfc2733_mode* pvalue); + +EXTERN int asn1PD_H245FECData_rfc2733_mode (OOCTXT* pctxt, H245FECData_rfc2733_mode* pvalue); + +/**************************************************************/ +/* */ +/* FECData_rfc2733 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FECData_rfc2733 { + H245FECData_rfc2733_mode mode; +} H245FECData_rfc2733; + +EXTERN int asn1PE_H245FECData_rfc2733 (OOCTXT* pctxt, H245FECData_rfc2733* pvalue); + +EXTERN int asn1PD_H245FECData_rfc2733 (OOCTXT* pctxt, H245FECData_rfc2733* pvalue); + +/**************************************************************/ +/* */ +/* FECData */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FECData_rfc2733 1 + +typedef struct EXTERN H245FECData { + int t; + union { + /* t = 1 */ + H245FECData_rfc2733 *rfc2733; + } u; +} H245FECData; + +EXTERN int asn1PE_H245FECData (OOCTXT* pctxt, H245FECData* pvalue); + +EXTERN int asn1PD_H245FECData (OOCTXT* pctxt, H245FECData* pvalue); + +/**************************************************************/ +/* */ +/* H235Media_mediaType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H235Media_mediaType_nonStandard 1 +#define T_H245H235Media_mediaType_videoData 2 +#define T_H245H235Media_mediaType_audioData 3 +#define T_H245H235Media_mediaType_data 4 +#define T_H245H235Media_mediaType_redundancyEncoding 5 +#define T_H245H235Media_mediaType_multiplePayloadStream 6 +#define T_H245H235Media_mediaType_fec 7 +#define T_H245H235Media_mediaType_extElem1 8 + +typedef struct EXTERN H245H235Media_mediaType { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245VideoCapability *videoData; + /* t = 3 */ + H245AudioCapability *audioData; + /* t = 4 */ + H245DataApplicationCapability *data; + /* t = 5 */ + H245RedundancyEncoding *redundancyEncoding; + /* t = 6 */ + H245MultiplePayloadStream *multiplePayloadStream; + /* t = 7 */ + H245FECData *fec; + /* t = 8 */ + } u; +} H245H235Media_mediaType; + +EXTERN int asn1PE_H245H235Media_mediaType (OOCTXT* pctxt, H245H235Media_mediaType* pvalue); + +EXTERN int asn1PD_H245H235Media_mediaType (OOCTXT* pctxt, H245H235Media_mediaType* pvalue); + +/**************************************************************/ +/* */ +/* H235Media */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H235Media { + H245EncryptionAuthenticationAndIntegrity encryptionAuthenticationAndIntegrity; + H245H235Media_mediaType mediaType; +} H245H235Media; + +EXTERN int asn1PE_H245H235Media (OOCTXT* pctxt, H245H235Media* pvalue); + +EXTERN int asn1PD_H245H235Media (OOCTXT* pctxt, H245H235Media* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexedStreamParameter */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexedStreamParameter { + H245MultiplexFormat multiplexFormat; + ASN1BOOL controlOnMuxStream; +} H245MultiplexedStreamParameter; + +EXTERN int asn1PE_H245MultiplexedStreamParameter (OOCTXT* pctxt, H245MultiplexedStreamParameter* pvalue); + +EXTERN int asn1PD_H245MultiplexedStreamParameter (OOCTXT* pctxt, H245MultiplexedStreamParameter* pvalue); + +/**************************************************************/ +/* */ +/* DataType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245DataType_nonStandard 1 +#define T_H245DataType_nullData 2 +#define T_H245DataType_videoData 3 +#define T_H245DataType_audioData 4 +#define T_H245DataType_data 5 +#define T_H245DataType_encryptionData 6 +#define T_H245DataType_h235Control 7 +#define T_H245DataType_h235Media 8 +#define T_H245DataType_multiplexedStream 9 +#define T_H245DataType_redundancyEncoding 10 +#define T_H245DataType_multiplePayloadStream 11 +#define T_H245DataType_fec 12 +#define T_H245DataType_extElem1 13 + +typedef struct EXTERN H245DataType { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + H245VideoCapability *videoData; + /* t = 4 */ + H245AudioCapability *audioData; + /* t = 5 */ + H245DataApplicationCapability *data; + /* t = 6 */ + H245EncryptionMode *encryptionData; + /* t = 7 */ + H245NonStandardParameter *h235Control; + /* t = 8 */ + H245H235Media *h235Media; + /* t = 9 */ + H245MultiplexedStreamParameter *multiplexedStream; + /* t = 10 */ + H245RedundancyEncoding *redundancyEncoding; + /* t = 11 */ + H245MultiplePayloadStream *multiplePayloadStream; + /* t = 12 */ + H245FECData *fec; + /* t = 13 */ + } u; +} H245DataType; + +EXTERN int asn1PE_H245DataType (OOCTXT* pctxt, H245DataType* pvalue); + +EXTERN int asn1PD_H245DataType (OOCTXT* pctxt, H245DataType* pvalue); + +/**************************************************************/ +/* */ +/* H222LogicalChannelParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H222LogicalChannelParameters { + struct { + unsigned pcr_pidPresent : 1; + unsigned programDescriptorsPresent : 1; + unsigned streamDescriptorsPresent : 1; + } m; + ASN1USINT resourceID; + ASN1USINT subChannelID; + ASN1USINT pcr_pid; + ASN1DynOctStr programDescriptors; + ASN1DynOctStr streamDescriptors; +} H245H222LogicalChannelParameters; + +EXTERN int asn1PE_H245H222LogicalChannelParameters (OOCTXT* pctxt, H245H222LogicalChannelParameters* pvalue); + +EXTERN int asn1PD_H245H222LogicalChannelParameters (OOCTXT* pctxt, H245H222LogicalChannelParameters* pvalue); + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters_adaptationLayerType_al3 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223LogicalChannelParameters_adaptationLayerType_al3 { + ASN1UINT8 controlFieldOctets; + ASN1UINT sendBufferSize; +} H245H223LogicalChannelParameters_adaptationLayerType_al3; + +EXTERN int asn1PE_H245H223LogicalChannelParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3* pvalue); + +EXTERN int asn1PD_H245H223LogicalChannelParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3* pvalue); + +/**************************************************************/ +/* */ +/* H223AL1MParameters_transferMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AL1MParameters_transferMode_framed 1 +#define T_H245H223AL1MParameters_transferMode_unframed 2 +#define T_H245H223AL1MParameters_transferMode_extElem1 3 + +typedef struct EXTERN H245H223AL1MParameters_transferMode { + int t; +} H245H223AL1MParameters_transferMode; + +EXTERN int asn1PE_H245H223AL1MParameters_transferMode (OOCTXT* pctxt, H245H223AL1MParameters_transferMode* pvalue); + +EXTERN int asn1PD_H245H223AL1MParameters_transferMode (OOCTXT* pctxt, H245H223AL1MParameters_transferMode* pvalue); + +/**************************************************************/ +/* */ +/* H223AL1MParameters_headerFEC */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AL1MParameters_headerFEC_sebch16_7 1 +#define T_H245H223AL1MParameters_headerFEC_golay24_12 2 +#define T_H245H223AL1MParameters_headerFEC_extElem1 3 + +typedef struct EXTERN H245H223AL1MParameters_headerFEC { + int t; +} H245H223AL1MParameters_headerFEC; + +EXTERN int asn1PE_H245H223AL1MParameters_headerFEC (OOCTXT* pctxt, H245H223AL1MParameters_headerFEC* pvalue); + +EXTERN int asn1PD_H245H223AL1MParameters_headerFEC (OOCTXT* pctxt, H245H223AL1MParameters_headerFEC* pvalue); + +/**************************************************************/ +/* */ +/* H223AL1MParameters_crcLength */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AL1MParameters_crcLength_crc4bit 1 +#define T_H245H223AL1MParameters_crcLength_crc12bit 2 +#define T_H245H223AL1MParameters_crcLength_crc20bit 3 +#define T_H245H223AL1MParameters_crcLength_crc28bit 4 +#define T_H245H223AL1MParameters_crcLength_crc8bit 5 +#define T_H245H223AL1MParameters_crcLength_crc16bit 6 +#define T_H245H223AL1MParameters_crcLength_crc32bit 7 +#define T_H245H223AL1MParameters_crcLength_crcNotUsed 8 +#define T_H245H223AL1MParameters_crcLength_extElem1 9 + +typedef struct EXTERN H245H223AL1MParameters_crcLength { + int t; +} H245H223AL1MParameters_crcLength; + +EXTERN int asn1PE_H245H223AL1MParameters_crcLength (OOCTXT* pctxt, H245H223AL1MParameters_crcLength* pvalue); + +EXTERN int asn1PD_H245H223AL1MParameters_crcLength (OOCTXT* pctxt, H245H223AL1MParameters_crcLength* pvalue); + +/**************************************************************/ +/* */ +/* H223AnnexCArqParameters_numberOfRetransmissions */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AnnexCArqParameters_numberOfRetransmissions_finite 1 +#define T_H245H223AnnexCArqParameters_numberOfRetransmissions_infinite 2 +#define T_H245H223AnnexCArqParameters_numberOfRetransmissions_extElem1 3 + +typedef struct EXTERN H245H223AnnexCArqParameters_numberOfRetransmissions { + int t; + union { + /* t = 1 */ + ASN1UINT8 finite; + /* t = 2 */ + /* t = 3 */ + } u; +} H245H223AnnexCArqParameters_numberOfRetransmissions; + +EXTERN int asn1PE_H245H223AnnexCArqParameters_numberOfRetransmissions (OOCTXT* pctxt, H245H223AnnexCArqParameters_numberOfRetransmissions* pvalue); + +EXTERN int asn1PD_H245H223AnnexCArqParameters_numberOfRetransmissions (OOCTXT* pctxt, H245H223AnnexCArqParameters_numberOfRetransmissions* pvalue); + +/**************************************************************/ +/* */ +/* H223AnnexCArqParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223AnnexCArqParameters { + H245H223AnnexCArqParameters_numberOfRetransmissions numberOfRetransmissions; + ASN1UINT sendBufferSize; +} H245H223AnnexCArqParameters; + +EXTERN int asn1PE_H245H223AnnexCArqParameters (OOCTXT* pctxt, H245H223AnnexCArqParameters* pvalue); + +EXTERN int asn1PD_H245H223AnnexCArqParameters (OOCTXT* pctxt, H245H223AnnexCArqParameters* pvalue); + +/**************************************************************/ +/* */ +/* H223AL1MParameters_arqType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AL1MParameters_arqType_noArq 1 +#define T_H245H223AL1MParameters_arqType_typeIArq 2 +#define T_H245H223AL1MParameters_arqType_typeIIArq 3 +#define T_H245H223AL1MParameters_arqType_extElem1 4 + +typedef struct EXTERN H245H223AL1MParameters_arqType { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245H223AnnexCArqParameters *typeIArq; + /* t = 3 */ + H245H223AnnexCArqParameters *typeIIArq; + /* t = 4 */ + } u; +} H245H223AL1MParameters_arqType; + +EXTERN int asn1PE_H245H223AL1MParameters_arqType (OOCTXT* pctxt, H245H223AL1MParameters_arqType* pvalue); + +EXTERN int asn1PD_H245H223AL1MParameters_arqType (OOCTXT* pctxt, H245H223AL1MParameters_arqType* pvalue); + +/**************************************************************/ +/* */ +/* H223AL1MParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223AL1MParameters { + struct { + unsigned rsCodeCorrectionPresent : 1; + } m; + H245H223AL1MParameters_transferMode transferMode; + H245H223AL1MParameters_headerFEC headerFEC; + H245H223AL1MParameters_crcLength crcLength; + ASN1UINT8 rcpcCodeRate; + H245H223AL1MParameters_arqType arqType; + ASN1BOOL alpduInterleaving; + ASN1BOOL alsduSplitting; + ASN1UINT8 rsCodeCorrection; +} H245H223AL1MParameters; + +EXTERN int asn1PE_H245H223AL1MParameters (OOCTXT* pctxt, H245H223AL1MParameters* pvalue); + +EXTERN int asn1PD_H245H223AL1MParameters (OOCTXT* pctxt, H245H223AL1MParameters* pvalue); + +/**************************************************************/ +/* */ +/* H223AL2MParameters_headerFEC */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AL2MParameters_headerFEC_sebch16_5 1 +#define T_H245H223AL2MParameters_headerFEC_golay24_12 2 +#define T_H245H223AL2MParameters_headerFEC_extElem1 3 + +typedef struct EXTERN H245H223AL2MParameters_headerFEC { + int t; +} H245H223AL2MParameters_headerFEC; + +EXTERN int asn1PE_H245H223AL2MParameters_headerFEC (OOCTXT* pctxt, H245H223AL2MParameters_headerFEC* pvalue); + +EXTERN int asn1PD_H245H223AL2MParameters_headerFEC (OOCTXT* pctxt, H245H223AL2MParameters_headerFEC* pvalue); + +/**************************************************************/ +/* */ +/* H223AL2MParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223AL2MParameters { + H245H223AL2MParameters_headerFEC headerFEC; + ASN1BOOL alpduInterleaving; +} H245H223AL2MParameters; + +EXTERN int asn1PE_H245H223AL2MParameters (OOCTXT* pctxt, H245H223AL2MParameters* pvalue); + +EXTERN int asn1PD_H245H223AL2MParameters (OOCTXT* pctxt, H245H223AL2MParameters* pvalue); + +/**************************************************************/ +/* */ +/* H223AL3MParameters_headerFormat */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AL3MParameters_headerFormat_sebch16_7 1 +#define T_H245H223AL3MParameters_headerFormat_golay24_12 2 +#define T_H245H223AL3MParameters_headerFormat_extElem1 3 + +typedef struct EXTERN H245H223AL3MParameters_headerFormat { + int t; +} H245H223AL3MParameters_headerFormat; + +EXTERN int asn1PE_H245H223AL3MParameters_headerFormat (OOCTXT* pctxt, H245H223AL3MParameters_headerFormat* pvalue); + +EXTERN int asn1PD_H245H223AL3MParameters_headerFormat (OOCTXT* pctxt, H245H223AL3MParameters_headerFormat* pvalue); + +/**************************************************************/ +/* */ +/* H223AL3MParameters_crcLength */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AL3MParameters_crcLength_crc4bit 1 +#define T_H245H223AL3MParameters_crcLength_crc12bit 2 +#define T_H245H223AL3MParameters_crcLength_crc20bit 3 +#define T_H245H223AL3MParameters_crcLength_crc28bit 4 +#define T_H245H223AL3MParameters_crcLength_crc8bit 5 +#define T_H245H223AL3MParameters_crcLength_crc16bit 6 +#define T_H245H223AL3MParameters_crcLength_crc32bit 7 +#define T_H245H223AL3MParameters_crcLength_crcNotUsed 8 +#define T_H245H223AL3MParameters_crcLength_extElem1 9 + +typedef struct EXTERN H245H223AL3MParameters_crcLength { + int t; +} H245H223AL3MParameters_crcLength; + +EXTERN int asn1PE_H245H223AL3MParameters_crcLength (OOCTXT* pctxt, H245H223AL3MParameters_crcLength* pvalue); + +EXTERN int asn1PD_H245H223AL3MParameters_crcLength (OOCTXT* pctxt, H245H223AL3MParameters_crcLength* pvalue); + +/**************************************************************/ +/* */ +/* H223AL3MParameters_arqType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223AL3MParameters_arqType_noArq 1 +#define T_H245H223AL3MParameters_arqType_typeIArq 2 +#define T_H245H223AL3MParameters_arqType_typeIIArq 3 +#define T_H245H223AL3MParameters_arqType_extElem1 4 + +typedef struct EXTERN H245H223AL3MParameters_arqType { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245H223AnnexCArqParameters *typeIArq; + /* t = 3 */ + H245H223AnnexCArqParameters *typeIIArq; + /* t = 4 */ + } u; +} H245H223AL3MParameters_arqType; + +EXTERN int asn1PE_H245H223AL3MParameters_arqType (OOCTXT* pctxt, H245H223AL3MParameters_arqType* pvalue); + +EXTERN int asn1PD_H245H223AL3MParameters_arqType (OOCTXT* pctxt, H245H223AL3MParameters_arqType* pvalue); + +/**************************************************************/ +/* */ +/* H223AL3MParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223AL3MParameters { + struct { + unsigned rsCodeCorrectionPresent : 1; + } m; + H245H223AL3MParameters_headerFormat headerFormat; + H245H223AL3MParameters_crcLength crcLength; + ASN1UINT8 rcpcCodeRate; + H245H223AL3MParameters_arqType arqType; + ASN1BOOL alpduInterleaving; + ASN1UINT8 rsCodeCorrection; +} H245H223AL3MParameters; + +EXTERN int asn1PE_H245H223AL3MParameters (OOCTXT* pctxt, H245H223AL3MParameters* pvalue); + +EXTERN int asn1PD_H245H223AL3MParameters (OOCTXT* pctxt, H245H223AL3MParameters* pvalue); + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters_adaptationLayerType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223LogicalChannelParameters_adaptationLayerType_nonStandard 1 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_al1Framed 2 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_al1NotFramed 3 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_al2WithoutSequenceNumbers 4 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_al2WithSequenceNumbers 5 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_al3 6 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_al1M 7 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_al2M 8 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_al3M 9 +#define T_H245H223LogicalChannelParameters_adaptationLayerType_extElem1 10 + +typedef struct EXTERN H245H223LogicalChannelParameters_adaptationLayerType { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + H245H223LogicalChannelParameters_adaptationLayerType_al3 *al3; + /* t = 7 */ + H245H223AL1MParameters *al1M; + /* t = 8 */ + H245H223AL2MParameters *al2M; + /* t = 9 */ + H245H223AL3MParameters *al3M; + /* t = 10 */ + } u; +} H245H223LogicalChannelParameters_adaptationLayerType; + +EXTERN int asn1PE_H245H223LogicalChannelParameters_adaptationLayerType (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType* pvalue); + +EXTERN int asn1PD_H245H223LogicalChannelParameters_adaptationLayerType (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType* pvalue); + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223LogicalChannelParameters { + H245H223LogicalChannelParameters_adaptationLayerType adaptationLayerType; + ASN1BOOL segmentableFlag; +} H245H223LogicalChannelParameters; + +EXTERN int asn1PE_H245H223LogicalChannelParameters (OOCTXT* pctxt, H245H223LogicalChannelParameters* pvalue); + +EXTERN int asn1PD_H245H223LogicalChannelParameters (OOCTXT* pctxt, H245H223LogicalChannelParameters* pvalue); + +/**************************************************************/ +/* */ +/* CRCLength */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CRCLength_crc8bit 1 +#define T_H245CRCLength_crc16bit 2 +#define T_H245CRCLength_crc32bit 3 +#define T_H245CRCLength_extElem1 4 + +typedef struct EXTERN H245CRCLength { + int t; +} H245CRCLength; + +EXTERN int asn1PE_H245CRCLength (OOCTXT* pctxt, H245CRCLength* pvalue); + +EXTERN int asn1PD_H245CRCLength (OOCTXT* pctxt, H245CRCLength* pvalue); + +/**************************************************************/ +/* */ +/* V76HDLCParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245V76HDLCParameters { + H245CRCLength crcLength; + ASN1USINT n401; + ASN1BOOL loopbackTestProcedure; +} H245V76HDLCParameters; + +EXTERN int asn1PE_H245V76HDLCParameters (OOCTXT* pctxt, H245V76HDLCParameters* pvalue); + +EXTERN int asn1PD_H245V76HDLCParameters (OOCTXT* pctxt, H245V76HDLCParameters* pvalue); + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_suspendResume */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245V76LogicalChannelParameters_suspendResume_noSuspendResume 1 +#define T_H245V76LogicalChannelParameters_suspendResume_suspendResumewAddress 2 +#define T_H245V76LogicalChannelParameters_suspendResume_suspendResumewoAddress 3 +#define T_H245V76LogicalChannelParameters_suspendResume_extElem1 4 + +typedef struct EXTERN H245V76LogicalChannelParameters_suspendResume { + int t; +} H245V76LogicalChannelParameters_suspendResume; + +EXTERN int asn1PE_H245V76LogicalChannelParameters_suspendResume (OOCTXT* pctxt, H245V76LogicalChannelParameters_suspendResume* pvalue); + +EXTERN int asn1PD_H245V76LogicalChannelParameters_suspendResume (OOCTXT* pctxt, H245V76LogicalChannelParameters_suspendResume* pvalue); + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode_eRM_recovery */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245V76LogicalChannelParameters_mode_eRM_recovery_rej 1 +#define T_H245V76LogicalChannelParameters_mode_eRM_recovery_sREJ 2 +#define T_H245V76LogicalChannelParameters_mode_eRM_recovery_mSREJ 3 +#define T_H245V76LogicalChannelParameters_mode_eRM_recovery_extElem1 4 + +typedef struct EXTERN H245V76LogicalChannelParameters_mode_eRM_recovery { + int t; +} H245V76LogicalChannelParameters_mode_eRM_recovery; + +EXTERN int asn1PE_H245V76LogicalChannelParameters_mode_eRM_recovery (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM_recovery* pvalue); + +EXTERN int asn1PD_H245V76LogicalChannelParameters_mode_eRM_recovery (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM_recovery* pvalue); + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode_eRM */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245V76LogicalChannelParameters_mode_eRM { + ASN1UINT8 windowSize; + H245V76LogicalChannelParameters_mode_eRM_recovery recovery; +} H245V76LogicalChannelParameters_mode_eRM; + +EXTERN int asn1PE_H245V76LogicalChannelParameters_mode_eRM (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM* pvalue); + +EXTERN int asn1PD_H245V76LogicalChannelParameters_mode_eRM (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM* pvalue); + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245V76LogicalChannelParameters_mode_eRM 1 +#define T_H245V76LogicalChannelParameters_mode_uNERM 2 +#define T_H245V76LogicalChannelParameters_mode_extElem1 3 + +typedef struct EXTERN H245V76LogicalChannelParameters_mode { + int t; + union { + /* t = 1 */ + H245V76LogicalChannelParameters_mode_eRM *eRM; + /* t = 2 */ + /* t = 3 */ + } u; +} H245V76LogicalChannelParameters_mode; + +EXTERN int asn1PE_H245V76LogicalChannelParameters_mode (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode* pvalue); + +EXTERN int asn1PD_H245V76LogicalChannelParameters_mode (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode* pvalue); + +/**************************************************************/ +/* */ +/* V75Parameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245V75Parameters { + ASN1BOOL audioHeaderPresent; +} H245V75Parameters; + +EXTERN int asn1PE_H245V75Parameters (OOCTXT* pctxt, H245V75Parameters* pvalue); + +EXTERN int asn1PD_H245V75Parameters (OOCTXT* pctxt, H245V75Parameters* pvalue); + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245V76LogicalChannelParameters { + H245V76HDLCParameters hdlcParameters; + H245V76LogicalChannelParameters_suspendResume suspendResume; + ASN1BOOL uIH; + H245V76LogicalChannelParameters_mode mode; + H245V75Parameters v75Parameters; +} H245V76LogicalChannelParameters; + +EXTERN int asn1PE_H245V76LogicalChannelParameters (OOCTXT* pctxt, H245V76LogicalChannelParameters* pvalue); + +EXTERN int asn1PD_H245V76LogicalChannelParameters (OOCTXT* pctxt, H245V76LogicalChannelParameters* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPAddress_network */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPAddress_network { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H245UnicastAddress_iPAddress_network; + +EXTERN int asn1PE_H245UnicastAddress_iPAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPAddress_network* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPAddress_network* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPAddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPAddress { + H245UnicastAddress_iPAddress_network network; + ASN1USINT tsapIdentifier; +} H245UnicastAddress_iPAddress; + +EXTERN int asn1PE_H245UnicastAddress_iPAddress (OOCTXT* pctxt, H245UnicastAddress_iPAddress* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPAddress (OOCTXT* pctxt, H245UnicastAddress_iPAddress* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_node */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPXAddress_node { + ASN1UINT numocts; + ASN1OCTET data[6]; +} H245UnicastAddress_iPXAddress_node; + +EXTERN int asn1PE_H245UnicastAddress_iPXAddress_node (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_node* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPXAddress_node (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_node* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_netnum */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPXAddress_netnum { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H245UnicastAddress_iPXAddress_netnum; + +EXTERN int asn1PE_H245UnicastAddress_iPXAddress_netnum (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_netnum* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPXAddress_netnum (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_netnum* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_tsapIdentifier */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPXAddress_tsapIdentifier { + ASN1UINT numocts; + ASN1OCTET data[2]; +} H245UnicastAddress_iPXAddress_tsapIdentifier; + +EXTERN int asn1PE_H245UnicastAddress_iPXAddress_tsapIdentifier (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_tsapIdentifier* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPXAddress_tsapIdentifier (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_tsapIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPXAddress { + H245UnicastAddress_iPXAddress_node node; + H245UnicastAddress_iPXAddress_netnum netnum; + H245UnicastAddress_iPXAddress_tsapIdentifier tsapIdentifier; +} H245UnicastAddress_iPXAddress; + +EXTERN int asn1PE_H245UnicastAddress_iPXAddress (OOCTXT* pctxt, H245UnicastAddress_iPXAddress* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPXAddress (OOCTXT* pctxt, H245UnicastAddress_iPXAddress* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iP6Address_network */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iP6Address_network { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H245UnicastAddress_iP6Address_network; + +EXTERN int asn1PE_H245UnicastAddress_iP6Address_network (OOCTXT* pctxt, H245UnicastAddress_iP6Address_network* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iP6Address_network (OOCTXT* pctxt, H245UnicastAddress_iP6Address_network* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iP6Address */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iP6Address { + H245UnicastAddress_iP6Address_network network; + ASN1USINT tsapIdentifier; +} H245UnicastAddress_iP6Address; + +EXTERN int asn1PE_H245UnicastAddress_iP6Address (OOCTXT* pctxt, H245UnicastAddress_iP6Address* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iP6Address (OOCTXT* pctxt, H245UnicastAddress_iP6Address* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_netBios */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_netBios { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H245UnicastAddress_netBios; + +EXTERN int asn1PE_H245UnicastAddress_netBios (OOCTXT* pctxt, H245UnicastAddress_netBios* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_netBios (OOCTXT* pctxt, H245UnicastAddress_netBios* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_routing */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245UnicastAddress_iPSourceRouteAddress_routing_strict 1 +#define T_H245UnicastAddress_iPSourceRouteAddress_routing_loose 2 + +typedef struct EXTERN H245UnicastAddress_iPSourceRouteAddress_routing { + int t; +} H245UnicastAddress_iPSourceRouteAddress_routing; + +EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_routing (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_routing* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_routing (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_routing* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_network */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPSourceRouteAddress_network { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H245UnicastAddress_iPSourceRouteAddress_network; + +EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_network* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_network* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_route_element */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPSourceRouteAddress_route_element { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H245UnicastAddress_iPSourceRouteAddress_route_element; + +EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_route_element* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_route_element* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245UnicastAddress_iPSourceRouteAddress_route_elem */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element { + ASN1UINT n; + H245UnicastAddress_iPSourceRouteAddress_route_element *elem; +} H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element; + +EXTERN int asn1PE_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_iPSourceRouteAddress { + H245UnicastAddress_iPSourceRouteAddress_routing routing; + H245UnicastAddress_iPSourceRouteAddress_network network; + ASN1USINT tsapIdentifier; + H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element route; +} H245UnicastAddress_iPSourceRouteAddress; + +EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress_nsap */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UnicastAddress_nsap { + ASN1UINT numocts; + ASN1OCTET data[20]; +} H245UnicastAddress_nsap; + +EXTERN int asn1PE_H245UnicastAddress_nsap (OOCTXT* pctxt, H245UnicastAddress_nsap* pvalue); + +EXTERN int asn1PD_H245UnicastAddress_nsap (OOCTXT* pctxt, H245UnicastAddress_nsap* pvalue); + +/**************************************************************/ +/* */ +/* UnicastAddress */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245UnicastAddress_iPAddress 1 +#define T_H245UnicastAddress_iPXAddress 2 +#define T_H245UnicastAddress_iP6Address 3 +#define T_H245UnicastAddress_netBios 4 +#define T_H245UnicastAddress_iPSourceRouteAddress 5 +#define T_H245UnicastAddress_nsap 6 +#define T_H245UnicastAddress_nonStandardAddress 7 +#define T_H245UnicastAddress_extElem1 8 + +typedef struct EXTERN H245UnicastAddress { + int t; + union { + /* t = 1 */ + H245UnicastAddress_iPAddress *iPAddress; + /* t = 2 */ + H245UnicastAddress_iPXAddress *iPXAddress; + /* t = 3 */ + H245UnicastAddress_iP6Address *iP6Address; + /* t = 4 */ + H245UnicastAddress_netBios *netBios; + /* t = 5 */ + H245UnicastAddress_iPSourceRouteAddress *iPSourceRouteAddress; + /* t = 6 */ + H245UnicastAddress_nsap *nsap; + /* t = 7 */ + H245NonStandardParameter *nonStandardAddress; + /* t = 8 */ + } u; +} H245UnicastAddress; + +EXTERN int asn1PE_H245UnicastAddress (OOCTXT* pctxt, H245UnicastAddress* pvalue); + +EXTERN int asn1PD_H245UnicastAddress (OOCTXT* pctxt, H245UnicastAddress* pvalue); + +/**************************************************************/ +/* */ +/* MulticastAddress_iPAddress_network */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MulticastAddress_iPAddress_network { + ASN1UINT numocts; + ASN1OCTET data[4]; +} H245MulticastAddress_iPAddress_network; + +EXTERN int asn1PE_H245MulticastAddress_iPAddress_network (OOCTXT* pctxt, H245MulticastAddress_iPAddress_network* pvalue); + +EXTERN int asn1PD_H245MulticastAddress_iPAddress_network (OOCTXT* pctxt, H245MulticastAddress_iPAddress_network* pvalue); + +/**************************************************************/ +/* */ +/* MulticastAddress_iPAddress */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MulticastAddress_iPAddress { + H245MulticastAddress_iPAddress_network network; + ASN1USINT tsapIdentifier; +} H245MulticastAddress_iPAddress; + +EXTERN int asn1PE_H245MulticastAddress_iPAddress (OOCTXT* pctxt, H245MulticastAddress_iPAddress* pvalue); + +EXTERN int asn1PD_H245MulticastAddress_iPAddress (OOCTXT* pctxt, H245MulticastAddress_iPAddress* pvalue); + +/**************************************************************/ +/* */ +/* MulticastAddress_iP6Address_network */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MulticastAddress_iP6Address_network { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H245MulticastAddress_iP6Address_network; + +EXTERN int asn1PE_H245MulticastAddress_iP6Address_network (OOCTXT* pctxt, H245MulticastAddress_iP6Address_network* pvalue); + +EXTERN int asn1PD_H245MulticastAddress_iP6Address_network (OOCTXT* pctxt, H245MulticastAddress_iP6Address_network* pvalue); + +/**************************************************************/ +/* */ +/* MulticastAddress_iP6Address */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MulticastAddress_iP6Address { + H245MulticastAddress_iP6Address_network network; + ASN1USINT tsapIdentifier; +} H245MulticastAddress_iP6Address; + +EXTERN int asn1PE_H245MulticastAddress_iP6Address (OOCTXT* pctxt, H245MulticastAddress_iP6Address* pvalue); + +EXTERN int asn1PD_H245MulticastAddress_iP6Address (OOCTXT* pctxt, H245MulticastAddress_iP6Address* pvalue); + +/**************************************************************/ +/* */ +/* MulticastAddress_nsap */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MulticastAddress_nsap { + ASN1UINT numocts; + ASN1OCTET data[20]; +} H245MulticastAddress_nsap; + +EXTERN int asn1PE_H245MulticastAddress_nsap (OOCTXT* pctxt, H245MulticastAddress_nsap* pvalue); + +EXTERN int asn1PD_H245MulticastAddress_nsap (OOCTXT* pctxt, H245MulticastAddress_nsap* pvalue); + +/**************************************************************/ +/* */ +/* MulticastAddress */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MulticastAddress_iPAddress 1 +#define T_H245MulticastAddress_iP6Address 2 +#define T_H245MulticastAddress_nsap 3 +#define T_H245MulticastAddress_nonStandardAddress 4 +#define T_H245MulticastAddress_extElem1 5 + +typedef struct EXTERN H245MulticastAddress { + int t; + union { + /* t = 1 */ + H245MulticastAddress_iPAddress *iPAddress; + /* t = 2 */ + H245MulticastAddress_iP6Address *iP6Address; + /* t = 3 */ + H245MulticastAddress_nsap *nsap; + /* t = 4 */ + H245NonStandardParameter *nonStandardAddress; + /* t = 5 */ + } u; +} H245MulticastAddress; + +EXTERN int asn1PE_H245MulticastAddress (OOCTXT* pctxt, H245MulticastAddress* pvalue); + +EXTERN int asn1PD_H245MulticastAddress (OOCTXT* pctxt, H245MulticastAddress* pvalue); + +/**************************************************************/ +/* */ +/* TransportAddress */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245TransportAddress_unicastAddress 1 +#define T_H245TransportAddress_multicastAddress 2 +#define T_H245TransportAddress_extElem1 3 + +typedef struct EXTERN H245TransportAddress { + int t; + union { + /* t = 1 */ + H245UnicastAddress *unicastAddress; + /* t = 2 */ + H245MulticastAddress *multicastAddress; + /* t = 3 */ + } u; +} H245TransportAddress; + +EXTERN int asn1PE_H245TransportAddress (OOCTXT* pctxt, H245TransportAddress* pvalue); + +EXTERN int asn1PD_H245TransportAddress (OOCTXT* pctxt, H245TransportAddress* pvalue); + +/**************************************************************/ +/* */ +/* McuNumber */ +/* */ +/**************************************************************/ + +typedef ASN1UINT8 H245McuNumber; + +EXTERN int asn1PE_H245McuNumber (OOCTXT* pctxt, H245McuNumber value); + +EXTERN int asn1PD_H245McuNumber (OOCTXT* pctxt, H245McuNumber* pvalue); + +/**************************************************************/ +/* */ +/* TerminalNumber */ +/* */ +/**************************************************************/ + +typedef ASN1UINT8 H245TerminalNumber; + +EXTERN int asn1PE_H245TerminalNumber (OOCTXT* pctxt, H245TerminalNumber value); + +EXTERN int asn1PD_H245TerminalNumber (OOCTXT* pctxt, H245TerminalNumber* pvalue); + +/**************************************************************/ +/* */ +/* TerminalLabel */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TerminalLabel { + H245McuNumber mcuNumber; + H245TerminalNumber terminalNumber; +} H245TerminalLabel; + +EXTERN int asn1PE_H245TerminalLabel (OOCTXT* pctxt, H245TerminalLabel* pvalue); + +EXTERN int asn1PD_H245TerminalLabel (OOCTXT* pctxt, H245TerminalLabel* pvalue); + +/**************************************************************/ +/* */ +/* H2250LogicalChannelParameters_mediaPacketization */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H2250LogicalChannelParameters_mediaPacketization_h261aVideoPacketization 1 +#define T_H245H2250LogicalChannelParameters_mediaPacketization_rtpPayloadType 2 +#define T_H245H2250LogicalChannelParameters_mediaPacketization_extElem1 3 + +typedef struct EXTERN H245H2250LogicalChannelParameters_mediaPacketization { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245RTPPayloadType *rtpPayloadType; + /* t = 3 */ + } u; +} H245H2250LogicalChannelParameters_mediaPacketization; + +EXTERN int asn1PE_H245H2250LogicalChannelParameters_mediaPacketization (OOCTXT* pctxt, H245H2250LogicalChannelParameters_mediaPacketization* pvalue); + +EXTERN int asn1PD_H245H2250LogicalChannelParameters_mediaPacketization (OOCTXT* pctxt, H245H2250LogicalChannelParameters_mediaPacketization* pvalue); + +/**************************************************************/ +/* */ +/* H2250LogicalChannelParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H2250LogicalChannelParameters { + struct { + unsigned nonStandardPresent : 1; + unsigned associatedSessionIDPresent : 1; + unsigned mediaChannelPresent : 1; + unsigned mediaGuaranteedDeliveryPresent : 1; + unsigned mediaControlChannelPresent : 1; + unsigned mediaControlGuaranteedDeliveryPresent : 1; + unsigned silenceSuppressionPresent : 1; + unsigned destinationPresent : 1; + unsigned dynamicRTPPayloadTypePresent : 1; + unsigned mediaPacketizationPresent : 1; + unsigned transportCapabilityPresent : 1; + unsigned redundancyEncodingPresent : 1; + unsigned sourcePresent : 1; + } m; + H245_SeqOfH245NonStandardParameter nonStandard; + ASN1UINT8 sessionID; + ASN1UINT8 associatedSessionID; + H245TransportAddress mediaChannel; + ASN1BOOL mediaGuaranteedDelivery; + H245TransportAddress mediaControlChannel; + ASN1BOOL mediaControlGuaranteedDelivery; + ASN1BOOL silenceSuppression; + H245TerminalLabel destination; + ASN1UINT8 dynamicRTPPayloadType; + H245H2250LogicalChannelParameters_mediaPacketization mediaPacketization; + H245TransportCapability transportCapability; + H245RedundancyEncoding redundancyEncoding; + H245TerminalLabel source; +} H245H2250LogicalChannelParameters; + +EXTERN int asn1PE_H245H2250LogicalChannelParameters (OOCTXT* pctxt, H245H2250LogicalChannelParameters* pvalue); + +EXTERN int asn1PD_H245H2250LogicalChannelParameters (OOCTXT* pctxt, H245H2250LogicalChannelParameters* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_forwardLogicalChannelParameters_multi */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h222LogicalChannelParameters 1 +#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h223LogicalChannelParameters 2 +#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_v76LogicalChannelParameters 3 +#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters 4 +#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_none 5 +#define T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_extElem1 6 + +typedef struct EXTERN H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters { + int t; + union { + /* t = 1 */ + H245H222LogicalChannelParameters *h222LogicalChannelParameters; + /* t = 2 */ + H245H223LogicalChannelParameters *h223LogicalChannelParameters; + /* t = 3 */ + H245V76LogicalChannelParameters *v76LogicalChannelParameters; + /* t = 4 */ + H245H2250LogicalChannelParameters *h2250LogicalChannelParameters; + /* t = 5 */ + /* t = 6 */ + } u; +} H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters; + +EXTERN int asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_forwardLogicalChannelParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245OpenLogicalChannel_forwardLogicalChannelParameters { + struct { + unsigned portNumberPresent : 1; + unsigned forwardLogicalChannelDependencyPresent : 1; + unsigned replacementForPresent : 1; + } m; + ASN1USINT portNumber; + H245DataType dataType; + H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters multiplexParameters; + H245LogicalChannelNumber forwardLogicalChannelDependency; + H245LogicalChannelNumber replacementFor; +} H245OpenLogicalChannel_forwardLogicalChannelParameters; + +EXTERN int asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_reverseLogicalChannelParameters_multi */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h223LogicalChannelParameters 1 +#define T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_v76LogicalChannelParameters 2 +#define T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters 3 +#define T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_extElem1 4 + +typedef struct EXTERN H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters { + int t; + union { + /* t = 1 */ + H245H223LogicalChannelParameters *h223LogicalChannelParameters; + /* t = 2 */ + H245V76LogicalChannelParameters *v76LogicalChannelParameters; + /* t = 3 */ + H245H2250LogicalChannelParameters *h2250LogicalChannelParameters; + /* t = 4 */ + } u; +} H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters; + +EXTERN int asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_reverseLogicalChannelParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245OpenLogicalChannel_reverseLogicalChannelParameters { + struct { + unsigned multiplexParametersPresent : 1; + unsigned reverseLogicalChannelDependencyPresent : 1; + unsigned replacementForPresent : 1; + } m; + H245DataType dataType; + H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters multiplexParameters; + H245LogicalChannelNumber reverseLogicalChannelDependency; + H245LogicalChannelNumber replacementFor; +} H245OpenLogicalChannel_reverseLogicalChannelParameters; + +EXTERN int asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters* pvalue); + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_distribution */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NetworkAccessParameters_distribution_unicast 1 +#define T_H245NetworkAccessParameters_distribution_multicast 2 +#define T_H245NetworkAccessParameters_distribution_extElem1 3 + +typedef struct EXTERN H245NetworkAccessParameters_distribution { + int t; +} H245NetworkAccessParameters_distribution; + +EXTERN int asn1PE_H245NetworkAccessParameters_distribution (OOCTXT* pctxt, H245NetworkAccessParameters_distribution* pvalue); + +EXTERN int asn1PD_H245NetworkAccessParameters_distribution (OOCTXT* pctxt, H245NetworkAccessParameters_distribution* pvalue); + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_networkAddress */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NetworkAccessParameters_networkAddress_q2931Address 1 +#define T_H245NetworkAccessParameters_networkAddress_e164Address 2 +#define T_H245NetworkAccessParameters_networkAddress_localAreaAddress 3 +#define T_H245NetworkAccessParameters_networkAddress_extElem1 4 + +typedef struct EXTERN H245NetworkAccessParameters_networkAddress { + int t; + union { + /* t = 1 */ + H245Q2931Address *q2931Address; + /* t = 2 */ + ASN1IA5String e164Address; + /* t = 3 */ + H245TransportAddress *localAreaAddress; + /* t = 4 */ + } u; +} H245NetworkAccessParameters_networkAddress; + +EXTERN int asn1PE_H245NetworkAccessParameters_networkAddress (OOCTXT* pctxt, H245NetworkAccessParameters_networkAddress* pvalue); + +EXTERN int asn1PD_H245NetworkAccessParameters_networkAddress (OOCTXT* pctxt, H245NetworkAccessParameters_networkAddress* pvalue); + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_externalReference */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NetworkAccessParameters_externalReference { + ASN1UINT numocts; + ASN1OCTET data[255]; +} H245NetworkAccessParameters_externalReference; + +EXTERN int asn1PE_H245NetworkAccessParameters_externalReference (OOCTXT* pctxt, H245NetworkAccessParameters_externalReference* pvalue); + +EXTERN int asn1PD_H245NetworkAccessParameters_externalReference (OOCTXT* pctxt, H245NetworkAccessParameters_externalReference* pvalue); + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_t120SetupProcedure */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NetworkAccessParameters_t120SetupProcedure_originateCall 1 +#define T_H245NetworkAccessParameters_t120SetupProcedure_waitForCall 2 +#define T_H245NetworkAccessParameters_t120SetupProcedure_issueQuery 3 +#define T_H245NetworkAccessParameters_t120SetupProcedure_extElem1 4 + +typedef struct EXTERN H245NetworkAccessParameters_t120SetupProcedure { + int t; +} H245NetworkAccessParameters_t120SetupProcedure; + +EXTERN int asn1PE_H245NetworkAccessParameters_t120SetupProcedure (OOCTXT* pctxt, H245NetworkAccessParameters_t120SetupProcedure* pvalue); + +EXTERN int asn1PD_H245NetworkAccessParameters_t120SetupProcedure (OOCTXT* pctxt, H245NetworkAccessParameters_t120SetupProcedure* pvalue); + +/**************************************************************/ +/* */ +/* NetworkAccessParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NetworkAccessParameters { + struct { + unsigned distributionPresent : 1; + unsigned externalReferencePresent : 1; + unsigned t120SetupProcedurePresent : 1; + } m; + H245NetworkAccessParameters_distribution distribution; + H245NetworkAccessParameters_networkAddress networkAddress; + ASN1BOOL associateConference; + H245NetworkAccessParameters_externalReference externalReference; + H245NetworkAccessParameters_t120SetupProcedure t120SetupProcedure; +} H245NetworkAccessParameters; + +EXTERN int asn1PE_H245NetworkAccessParameters (OOCTXT* pctxt, H245NetworkAccessParameters* pvalue); + +EXTERN int asn1PD_H245NetworkAccessParameters (OOCTXT* pctxt, H245NetworkAccessParameters* pvalue); + +/**************************************************************/ +/* */ +/* EscrowData_escrowValue */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245EscrowData_escrowValue { + ASN1UINT numbits; + ASN1OCTET data[8192]; +} H245EscrowData_escrowValue; + +EXTERN int asn1PE_H245EscrowData_escrowValue (OOCTXT* pctxt, H245EscrowData_escrowValue* pvalue); + +EXTERN int asn1PD_H245EscrowData_escrowValue (OOCTXT* pctxt, H245EscrowData_escrowValue* pvalue); + +/**************************************************************/ +/* */ +/* EscrowData */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245EscrowData { + ASN1OBJID escrowID; + H245EscrowData_escrowValue escrowValue; +} H245EscrowData; + +EXTERN int asn1PE_H245EscrowData (OOCTXT* pctxt, H245EscrowData* pvalue); + +EXTERN int asn1PD_H245EscrowData (OOCTXT* pctxt, H245EscrowData* pvalue); + +/**************************************************************/ +/* */ +/* EncryptionSync_escrowentry */ +/* */ +/**************************************************************/ + +/* List of H245EscrowData */ +typedef DList H245EncryptionSync_escrowentry; + +EXTERN int asn1PE_H245EncryptionSync_escrowentry (OOCTXT* pctxt, H245EncryptionSync_escrowentry* pvalue); + +EXTERN int asn1PD_H245EncryptionSync_escrowentry (OOCTXT* pctxt, H245EncryptionSync_escrowentry* pvalue); + +/**************************************************************/ +/* */ +/* EncryptionSync */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245EncryptionSync { + struct { + unsigned nonStandardPresent : 1; + unsigned escrowentryPresent : 1; + } m; + H245NonStandardParameter nonStandard; + ASN1UINT8 synchFlag; + ASN1DynOctStr h235Key; + H245EncryptionSync_escrowentry escrowentry; +} H245EncryptionSync; + +EXTERN int asn1PE_H245EncryptionSync (OOCTXT* pctxt, H245EncryptionSync* pvalue); + +EXTERN int asn1PD_H245EncryptionSync (OOCTXT* pctxt, H245EncryptionSync* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannel */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245OpenLogicalChannel { + struct { + unsigned reverseLogicalChannelParametersPresent : 1; + unsigned separateStackPresent : 1; + unsigned encryptionSyncPresent : 1; + } m; + H245LogicalChannelNumber forwardLogicalChannelNumber; + H245OpenLogicalChannel_forwardLogicalChannelParameters forwardLogicalChannelParameters; + H245OpenLogicalChannel_reverseLogicalChannelParameters reverseLogicalChannelParameters; + H245NetworkAccessParameters separateStack; + H245EncryptionSync encryptionSync; +} H245OpenLogicalChannel; + +EXTERN int asn1PE_H245OpenLogicalChannel (OOCTXT* pctxt, H245OpenLogicalChannel* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannel (OOCTXT* pctxt, H245OpenLogicalChannel* pvalue); + +/**************************************************************/ +/* */ +/* CloseLogicalChannel_source */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CloseLogicalChannel_source_user 1 +#define T_H245CloseLogicalChannel_source_lcse 2 + +typedef struct EXTERN H245CloseLogicalChannel_source { + int t; +} H245CloseLogicalChannel_source; + +EXTERN int asn1PE_H245CloseLogicalChannel_source (OOCTXT* pctxt, H245CloseLogicalChannel_source* pvalue); + +EXTERN int asn1PD_H245CloseLogicalChannel_source (OOCTXT* pctxt, H245CloseLogicalChannel_source* pvalue); + +/**************************************************************/ +/* */ +/* CloseLogicalChannel_reason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CloseLogicalChannel_reason_unknown 1 +#define T_H245CloseLogicalChannel_reason_reopen 2 +#define T_H245CloseLogicalChannel_reason_reservationFailure 3 +#define T_H245CloseLogicalChannel_reason_extElem1 4 + +typedef struct EXTERN H245CloseLogicalChannel_reason { + int t; +} H245CloseLogicalChannel_reason; + +EXTERN int asn1PE_H245CloseLogicalChannel_reason (OOCTXT* pctxt, H245CloseLogicalChannel_reason* pvalue); + +EXTERN int asn1PD_H245CloseLogicalChannel_reason (OOCTXT* pctxt, H245CloseLogicalChannel_reason* pvalue); + +/**************************************************************/ +/* */ +/* CloseLogicalChannel */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CloseLogicalChannel { + struct { + unsigned reasonPresent : 1; + } m; + H245LogicalChannelNumber forwardLogicalChannelNumber; + H245CloseLogicalChannel_source source; + H245CloseLogicalChannel_reason reason; +} H245CloseLogicalChannel; + +EXTERN int asn1PE_H245CloseLogicalChannel (OOCTXT* pctxt, H245CloseLogicalChannel* pvalue); + +EXTERN int asn1PD_H245CloseLogicalChannel (OOCTXT* pctxt, H245CloseLogicalChannel* pvalue); + +/**************************************************************/ +/* */ +/* RequestChannelClose_reason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RequestChannelClose_reason_unknown 1 +#define T_H245RequestChannelClose_reason_normal 2 +#define T_H245RequestChannelClose_reason_reopen 3 +#define T_H245RequestChannelClose_reason_reservationFailure 4 +#define T_H245RequestChannelClose_reason_extElem1 5 + +typedef struct EXTERN H245RequestChannelClose_reason { + int t; +} H245RequestChannelClose_reason; + +EXTERN int asn1PE_H245RequestChannelClose_reason (OOCTXT* pctxt, H245RequestChannelClose_reason* pvalue); + +EXTERN int asn1PD_H245RequestChannelClose_reason (OOCTXT* pctxt, H245RequestChannelClose_reason* pvalue); + +/**************************************************************/ +/* */ +/* RequestChannelClose */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestChannelClose { + struct { + unsigned qosCapabilityPresent : 1; + unsigned reasonPresent : 1; + } m; + H245LogicalChannelNumber forwardLogicalChannelNumber; + H245QOSCapability qosCapability; + H245RequestChannelClose_reason reason; +} H245RequestChannelClose; + +EXTERN int asn1PE_H245RequestChannelClose (OOCTXT* pctxt, H245RequestChannelClose* pvalue); + +EXTERN int asn1PD_H245RequestChannelClose (OOCTXT* pctxt, H245RequestChannelClose* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +typedef ASN1UINT8 H245MultiplexTableEntryNumber; + +EXTERN int asn1PE_H245MultiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexTableEntryNumber value); + +EXTERN int asn1PD_H245MultiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexTableEntryNumber* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexElement_type_subElementList */ +/* */ +/**************************************************************/ + +/* List of H245MultiplexElement */ +typedef DList H245MultiplexElement_type_subElementList; + +EXTERN int asn1PE_H245MultiplexElement_type_subElementList (OOCTXT* pctxt, H245MultiplexElement_type_subElementList* pvalue); + +EXTERN int asn1PD_H245MultiplexElement_type_subElementList (OOCTXT* pctxt, H245MultiplexElement_type_subElementList* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexElement_type */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultiplexElement_type_logicalChannelNumber 1 +#define T_H245MultiplexElement_type_subElementList 2 + +typedef struct EXTERN H245MultiplexElement_type { + int t; + union { + /* t = 1 */ + ASN1USINT logicalChannelNumber; + /* t = 2 */ + H245MultiplexElement_type_subElementList *subElementList; + } u; +} H245MultiplexElement_type; + +EXTERN int asn1PE_H245MultiplexElement_type (OOCTXT* pctxt, H245MultiplexElement_type* pvalue); + +EXTERN int asn1PD_H245MultiplexElement_type (OOCTXT* pctxt, H245MultiplexElement_type* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexElement_repeatCount */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultiplexElement_repeatCount_finite 1 +#define T_H245MultiplexElement_repeatCount_untilClosingFlag 2 + +typedef struct EXTERN H245MultiplexElement_repeatCount { + int t; + union { + /* t = 1 */ + ASN1USINT finite; + /* t = 2 */ + } u; +} H245MultiplexElement_repeatCount; + +EXTERN int asn1PE_H245MultiplexElement_repeatCount (OOCTXT* pctxt, H245MultiplexElement_repeatCount* pvalue); + +EXTERN int asn1PD_H245MultiplexElement_repeatCount (OOCTXT* pctxt, H245MultiplexElement_repeatCount* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexElement */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexElement { + H245MultiplexElement_type type; + H245MultiplexElement_repeatCount repeatCount; +} H245MultiplexElement; + +EXTERN int asn1PE_H245MultiplexElement (OOCTXT* pctxt, H245MultiplexElement* pvalue); + +EXTERN int asn1PD_H245MultiplexElement (OOCTXT* pctxt, H245MultiplexElement* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntryDescriptor_elementList */ +/* */ +/**************************************************************/ + +/* List of H245MultiplexElement */ +typedef DList H245MultiplexEntryDescriptor_elementList; + +EXTERN int asn1PE_H245MultiplexEntryDescriptor_elementList (OOCTXT* pctxt, H245MultiplexEntryDescriptor_elementList* pvalue); + +EXTERN int asn1PD_H245MultiplexEntryDescriptor_elementList (OOCTXT* pctxt, H245MultiplexEntryDescriptor_elementList* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntryDescriptor */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexEntryDescriptor { + struct { + unsigned elementListPresent : 1; + } m; + H245MultiplexTableEntryNumber multiplexTableEntryNumber; + H245MultiplexEntryDescriptor_elementList elementList; +} H245MultiplexEntryDescriptor; + +EXTERN int asn1PE_H245MultiplexEntryDescriptor (OOCTXT* pctxt, H245MultiplexEntryDescriptor* pvalue); + +EXTERN int asn1PD_H245MultiplexEntryDescriptor (OOCTXT* pctxt, H245MultiplexEntryDescriptor* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntrySend_multiplexEntryDescriptors */ +/* */ +/**************************************************************/ + +/* List of H245MultiplexEntryDescriptor */ +typedef DList H245MultiplexEntrySend_multiplexEntryDescriptors; + +EXTERN int asn1PE_H245MultiplexEntrySend_multiplexEntryDescriptors (OOCTXT* pctxt, H245MultiplexEntrySend_multiplexEntryDescriptors* pvalue); + +EXTERN int asn1PD_H245MultiplexEntrySend_multiplexEntryDescriptors (OOCTXT* pctxt, H245MultiplexEntrySend_multiplexEntryDescriptors* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntrySend */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexEntrySend { + H245SequenceNumber sequenceNumber; + H245MultiplexEntrySend_multiplexEntryDescriptors multiplexEntryDescriptors; +} H245MultiplexEntrySend; + +EXTERN int asn1PE_H245MultiplexEntrySend (OOCTXT* pctxt, H245MultiplexEntrySend* pvalue); + +EXTERN int asn1PD_H245MultiplexEntrySend (OOCTXT* pctxt, H245MultiplexEntrySend* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntry_entryNumbers */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntry_entryNumbers { + ASN1UINT n; + H245MultiplexTableEntryNumber elem[15]; +} H245RequestMultiplexEntry_entryNumbers; + +EXTERN int asn1PE_H245RequestMultiplexEntry_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntry_entryNumbers* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntry_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntry_entryNumbers* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntry */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntry { + H245RequestMultiplexEntry_entryNumbers entryNumbers; +} H245RequestMultiplexEntry; + +EXTERN int asn1PE_H245RequestMultiplexEntry (OOCTXT* pctxt, H245RequestMultiplexEntry* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntry (OOCTXT* pctxt, H245RequestMultiplexEntry* pvalue); + +/**************************************************************/ +/* */ +/* H261VideoMode_resolution */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H261VideoMode_resolution_qcif 1 +#define T_H245H261VideoMode_resolution_cif 2 + +typedef struct EXTERN H245H261VideoMode_resolution { + int t; +} H245H261VideoMode_resolution; + +EXTERN int asn1PE_H245H261VideoMode_resolution (OOCTXT* pctxt, H245H261VideoMode_resolution* pvalue); + +EXTERN int asn1PD_H245H261VideoMode_resolution (OOCTXT* pctxt, H245H261VideoMode_resolution* pvalue); + +/**************************************************************/ +/* */ +/* H261VideoMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H261VideoMode { + H245H261VideoMode_resolution resolution; + ASN1USINT bitRate; + ASN1BOOL stillImageTransmission; +} H245H261VideoMode; + +EXTERN int asn1PE_H245H261VideoMode (OOCTXT* pctxt, H245H261VideoMode* pvalue); + +EXTERN int asn1PD_H245H261VideoMode (OOCTXT* pctxt, H245H261VideoMode* pvalue); + +/**************************************************************/ +/* */ +/* H262VideoMode_profileAndLevel */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_SPatML 1 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_MPatLL 2 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_MPatML 3 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_MPatH_14 4 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_MPatHL 5 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_SNRatLL 6 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_SNRatML 7 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_SpatialatH_14 8 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_HPatML 9 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_HPatH_14 10 +#define T_H245H262VideoMode_profileAndLevel_profileAndLevel_HPatHL 11 +#define T_H245H262VideoMode_profileAndLevel_extElem1 12 + +typedef struct EXTERN H245H262VideoMode_profileAndLevel { + int t; +} H245H262VideoMode_profileAndLevel; + +EXTERN int asn1PE_H245H262VideoMode_profileAndLevel (OOCTXT* pctxt, H245H262VideoMode_profileAndLevel* pvalue); + +EXTERN int asn1PD_H245H262VideoMode_profileAndLevel (OOCTXT* pctxt, H245H262VideoMode_profileAndLevel* pvalue); + +/**************************************************************/ +/* */ +/* H262VideoMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H262VideoMode { + struct { + unsigned videoBitRatePresent : 1; + unsigned vbvBufferSizePresent : 1; + unsigned samplesPerLinePresent : 1; + unsigned linesPerFramePresent : 1; + unsigned framesPerSecondPresent : 1; + unsigned luminanceSampleRatePresent : 1; + } m; + H245H262VideoMode_profileAndLevel profileAndLevel; + ASN1UINT videoBitRate; + ASN1UINT vbvBufferSize; + ASN1USINT samplesPerLine; + ASN1USINT linesPerFrame; + ASN1UINT8 framesPerSecond; + ASN1UINT luminanceSampleRate; +} H245H262VideoMode; + +EXTERN int asn1PE_H245H262VideoMode (OOCTXT* pctxt, H245H262VideoMode* pvalue); + +EXTERN int asn1PD_H245H262VideoMode (OOCTXT* pctxt, H245H262VideoMode* pvalue); + +/**************************************************************/ +/* */ +/* H263VideoMode_resolution */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H263VideoMode_resolution_sqcif 1 +#define T_H245H263VideoMode_resolution_qcif 2 +#define T_H245H263VideoMode_resolution_cif 3 +#define T_H245H263VideoMode_resolution_cif4 4 +#define T_H245H263VideoMode_resolution_cif16 5 +#define T_H245H263VideoMode_resolution_custom 6 +#define T_H245H263VideoMode_resolution_extElem1 7 + +typedef struct EXTERN H245H263VideoMode_resolution { + int t; +} H245H263VideoMode_resolution; + +EXTERN int asn1PE_H245H263VideoMode_resolution (OOCTXT* pctxt, H245H263VideoMode_resolution* pvalue); + +EXTERN int asn1PD_H245H263VideoMode_resolution (OOCTXT* pctxt, H245H263VideoMode_resolution* pvalue); + +/**************************************************************/ +/* */ +/* H263VideoMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H263VideoMode { + struct { + unsigned errorCompensationPresent : 1; + unsigned enhancementLayerInfoPresent : 1; + unsigned h263OptionsPresent : 1; + } m; + H245H263VideoMode_resolution resolution; + ASN1USINT bitRate; + ASN1BOOL unrestrictedVector; + ASN1BOOL arithmeticCoding; + ASN1BOOL advancedPrediction; + ASN1BOOL pbFrames; + ASN1BOOL errorCompensation; + H245EnhancementLayerInfo enhancementLayerInfo; + H245H263Options h263Options; +} H245H263VideoMode; + +EXTERN int asn1PE_H245H263VideoMode (OOCTXT* pctxt, H245H263VideoMode* pvalue); + +EXTERN int asn1PD_H245H263VideoMode (OOCTXT* pctxt, H245H263VideoMode* pvalue); + +/**************************************************************/ +/* */ +/* IS11172VideoMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245IS11172VideoMode { + struct { + unsigned videoBitRatePresent : 1; + unsigned vbvBufferSizePresent : 1; + unsigned samplesPerLinePresent : 1; + unsigned linesPerFramePresent : 1; + unsigned pictureRatePresent : 1; + unsigned luminanceSampleRatePresent : 1; + } m; + ASN1BOOL constrainedBitstream; + ASN1UINT videoBitRate; + ASN1UINT vbvBufferSize; + ASN1USINT samplesPerLine; + ASN1USINT linesPerFrame; + ASN1UINT8 pictureRate; + ASN1UINT luminanceSampleRate; +} H245IS11172VideoMode; + +EXTERN int asn1PE_H245IS11172VideoMode (OOCTXT* pctxt, H245IS11172VideoMode* pvalue); + +EXTERN int asn1PD_H245IS11172VideoMode (OOCTXT* pctxt, H245IS11172VideoMode* pvalue); + +/**************************************************************/ +/* */ +/* VideoMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245VideoMode_nonStandard 1 +#define T_H245VideoMode_h261VideoMode 2 +#define T_H245VideoMode_h262VideoMode 3 +#define T_H245VideoMode_h263VideoMode 4 +#define T_H245VideoMode_is11172VideoMode 5 +#define T_H245VideoMode_genericVideoMode 6 +#define T_H245VideoMode_extElem1 7 + +typedef struct EXTERN H245VideoMode { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245H261VideoMode *h261VideoMode; + /* t = 3 */ + H245H262VideoMode *h262VideoMode; + /* t = 4 */ + H245H263VideoMode *h263VideoMode; + /* t = 5 */ + H245IS11172VideoMode *is11172VideoMode; + /* t = 6 */ + H245GenericCapability *genericVideoMode; + /* t = 7 */ + } u; +} H245VideoMode; + +EXTERN int asn1PE_H245VideoMode (OOCTXT* pctxt, H245VideoMode* pvalue); + +EXTERN int asn1PD_H245VideoMode (OOCTXT* pctxt, H245VideoMode* pvalue); + +/**************************************************************/ +/* */ +/* AudioMode_g7231 */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245AudioMode_g7231_noSilenceSuppressionLowRate 1 +#define T_H245AudioMode_g7231_noSilenceSuppressionHighRate 2 +#define T_H245AudioMode_g7231_silenceSuppressionLowRate 3 +#define T_H245AudioMode_g7231_silenceSuppressionHighRate 4 + +typedef struct EXTERN H245AudioMode_g7231 { + int t; +} H245AudioMode_g7231; + +EXTERN int asn1PE_H245AudioMode_g7231 (OOCTXT* pctxt, H245AudioMode_g7231* pvalue); + +EXTERN int asn1PD_H245AudioMode_g7231 (OOCTXT* pctxt, H245AudioMode_g7231* pvalue); + +/**************************************************************/ +/* */ +/* IS11172AudioMode_audioLayer */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245IS11172AudioMode_audioLayer_audioLayer1 1 +#define T_H245IS11172AudioMode_audioLayer_audioLayer2 2 +#define T_H245IS11172AudioMode_audioLayer_audioLayer3 3 + +typedef struct EXTERN H245IS11172AudioMode_audioLayer { + int t; +} H245IS11172AudioMode_audioLayer; + +EXTERN int asn1PE_H245IS11172AudioMode_audioLayer (OOCTXT* pctxt, H245IS11172AudioMode_audioLayer* pvalue); + +EXTERN int asn1PD_H245IS11172AudioMode_audioLayer (OOCTXT* pctxt, H245IS11172AudioMode_audioLayer* pvalue); + +/**************************************************************/ +/* */ +/* IS11172AudioMode_audioSampling */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245IS11172AudioMode_audioSampling_audioSampling32k 1 +#define T_H245IS11172AudioMode_audioSampling_audioSampling44k1 2 +#define T_H245IS11172AudioMode_audioSampling_audioSampling48k 3 + +typedef struct EXTERN H245IS11172AudioMode_audioSampling { + int t; +} H245IS11172AudioMode_audioSampling; + +EXTERN int asn1PE_H245IS11172AudioMode_audioSampling (OOCTXT* pctxt, H245IS11172AudioMode_audioSampling* pvalue); + +EXTERN int asn1PD_H245IS11172AudioMode_audioSampling (OOCTXT* pctxt, H245IS11172AudioMode_audioSampling* pvalue); + +/**************************************************************/ +/* */ +/* IS11172AudioMode_multichannelType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245IS11172AudioMode_multichannelType_singleChannel 1 +#define T_H245IS11172AudioMode_multichannelType_twoChannelStereo 2 +#define T_H245IS11172AudioMode_multichannelType_twoChannelDual 3 + +typedef struct EXTERN H245IS11172AudioMode_multichannelType { + int t; +} H245IS11172AudioMode_multichannelType; + +EXTERN int asn1PE_H245IS11172AudioMode_multichannelType (OOCTXT* pctxt, H245IS11172AudioMode_multichannelType* pvalue); + +EXTERN int asn1PD_H245IS11172AudioMode_multichannelType (OOCTXT* pctxt, H245IS11172AudioMode_multichannelType* pvalue); + +/**************************************************************/ +/* */ +/* IS11172AudioMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245IS11172AudioMode { + H245IS11172AudioMode_audioLayer audioLayer; + H245IS11172AudioMode_audioSampling audioSampling; + H245IS11172AudioMode_multichannelType multichannelType; + ASN1USINT bitRate; +} H245IS11172AudioMode; + +EXTERN int asn1PE_H245IS11172AudioMode (OOCTXT* pctxt, H245IS11172AudioMode* pvalue); + +EXTERN int asn1PD_H245IS11172AudioMode (OOCTXT* pctxt, H245IS11172AudioMode* pvalue); + +/**************************************************************/ +/* */ +/* IS13818AudioMode_audioLayer */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245IS13818AudioMode_audioLayer_audioLayer1 1 +#define T_H245IS13818AudioMode_audioLayer_audioLayer2 2 +#define T_H245IS13818AudioMode_audioLayer_audioLayer3 3 + +typedef struct EXTERN H245IS13818AudioMode_audioLayer { + int t; +} H245IS13818AudioMode_audioLayer; + +EXTERN int asn1PE_H245IS13818AudioMode_audioLayer (OOCTXT* pctxt, H245IS13818AudioMode_audioLayer* pvalue); + +EXTERN int asn1PD_H245IS13818AudioMode_audioLayer (OOCTXT* pctxt, H245IS13818AudioMode_audioLayer* pvalue); + +/**************************************************************/ +/* */ +/* IS13818AudioMode_audioSampling */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245IS13818AudioMode_audioSampling_audioSampling16k 1 +#define T_H245IS13818AudioMode_audioSampling_audioSampling22k05 2 +#define T_H245IS13818AudioMode_audioSampling_audioSampling24k 3 +#define T_H245IS13818AudioMode_audioSampling_audioSampling32k 4 +#define T_H245IS13818AudioMode_audioSampling_audioSampling44k1 5 +#define T_H245IS13818AudioMode_audioSampling_audioSampling48k 6 + +typedef struct EXTERN H245IS13818AudioMode_audioSampling { + int t; +} H245IS13818AudioMode_audioSampling; + +EXTERN int asn1PE_H245IS13818AudioMode_audioSampling (OOCTXT* pctxt, H245IS13818AudioMode_audioSampling* pvalue); + +EXTERN int asn1PD_H245IS13818AudioMode_audioSampling (OOCTXT* pctxt, H245IS13818AudioMode_audioSampling* pvalue); + +/**************************************************************/ +/* */ +/* IS13818AudioMode_multichannelType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245IS13818AudioMode_multichannelType_singleChannel 1 +#define T_H245IS13818AudioMode_multichannelType_twoChannelStereo 2 +#define T_H245IS13818AudioMode_multichannelType_twoChannelDual 3 +#define T_H245IS13818AudioMode_multichannelType_threeChannels2_1 4 +#define T_H245IS13818AudioMode_multichannelType_threeChannels3_0 5 +#define T_H245IS13818AudioMode_multichannelType_fourChannels2_0_2_0 6 +#define T_H245IS13818AudioMode_multichannelType_fourChannels2_2 7 +#define T_H245IS13818AudioMode_multichannelType_fourChannels3_1 8 +#define T_H245IS13818AudioMode_multichannelType_fiveChannels3_0_2_0 9 +#define T_H245IS13818AudioMode_multichannelType_fiveChannels3_2 10 + +typedef struct EXTERN H245IS13818AudioMode_multichannelType { + int t; +} H245IS13818AudioMode_multichannelType; + +EXTERN int asn1PE_H245IS13818AudioMode_multichannelType (OOCTXT* pctxt, H245IS13818AudioMode_multichannelType* pvalue); + +EXTERN int asn1PD_H245IS13818AudioMode_multichannelType (OOCTXT* pctxt, H245IS13818AudioMode_multichannelType* pvalue); + +/**************************************************************/ +/* */ +/* IS13818AudioMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245IS13818AudioMode { + H245IS13818AudioMode_audioLayer audioLayer; + H245IS13818AudioMode_audioSampling audioSampling; + H245IS13818AudioMode_multichannelType multichannelType; + ASN1BOOL lowFrequencyEnhancement; + ASN1BOOL multilingual; + ASN1USINT bitRate; +} H245IS13818AudioMode; + +EXTERN int asn1PE_H245IS13818AudioMode (OOCTXT* pctxt, H245IS13818AudioMode* pvalue); + +EXTERN int asn1PD_H245IS13818AudioMode (OOCTXT* pctxt, H245IS13818AudioMode* pvalue); + +/**************************************************************/ +/* */ +/* G7231AnnexCMode_g723AnnexCAudioMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245G7231AnnexCMode_g723AnnexCAudioMode { + ASN1UINT8 highRateMode0; + ASN1UINT8 highRateMode1; + ASN1UINT8 lowRateMode0; + ASN1UINT8 lowRateMode1; + ASN1UINT8 sidMode0; + ASN1UINT8 sidMode1; +} H245G7231AnnexCMode_g723AnnexCAudioMode; + +EXTERN int asn1PE_H245G7231AnnexCMode_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCMode_g723AnnexCAudioMode* pvalue); + +EXTERN int asn1PD_H245G7231AnnexCMode_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCMode_g723AnnexCAudioMode* pvalue); + +/**************************************************************/ +/* */ +/* G7231AnnexCMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245G7231AnnexCMode { + ASN1USINT maxAl_sduAudioFrames; + ASN1BOOL silenceSuppression; + H245G7231AnnexCMode_g723AnnexCAudioMode g723AnnexCAudioMode; +} H245G7231AnnexCMode; + +EXTERN int asn1PE_H245G7231AnnexCMode (OOCTXT* pctxt, H245G7231AnnexCMode* pvalue); + +EXTERN int asn1PD_H245G7231AnnexCMode (OOCTXT* pctxt, H245G7231AnnexCMode* pvalue); + +/**************************************************************/ +/* */ +/* VBDMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VBDMode { + struct H245AudioMode *type; +} H245VBDMode; + +EXTERN int asn1PE_H245VBDMode (OOCTXT* pctxt, H245VBDMode* pvalue); + +EXTERN int asn1PD_H245VBDMode (OOCTXT* pctxt, H245VBDMode* pvalue); + +/**************************************************************/ +/* */ +/* AudioMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245AudioMode_nonStandard 1 +#define T_H245AudioMode_g711Alaw64k 2 +#define T_H245AudioMode_g711Alaw56k 3 +#define T_H245AudioMode_g711Ulaw64k 4 +#define T_H245AudioMode_g711Ulaw56k 5 +#define T_H245AudioMode_g722_64k 6 +#define T_H245AudioMode_g722_56k 7 +#define T_H245AudioMode_g722_48k 8 +#define T_H245AudioMode_g728 9 +#define T_H245AudioMode_g729 10 +#define T_H245AudioMode_g729AnnexA 11 +#define T_H245AudioMode_g7231 12 +#define T_H245AudioMode_is11172AudioMode 13 +#define T_H245AudioMode_is13818AudioMode 14 +#define T_H245AudioMode_g729wAnnexB 15 +#define T_H245AudioMode_g729AnnexAwAnnexB 16 +#define T_H245AudioMode_g7231AnnexCMode 17 +#define T_H245AudioMode_gsmFullRate 18 +#define T_H245AudioMode_gsmHalfRate 19 +#define T_H245AudioMode_gsmEnhancedFullRate 20 +#define T_H245AudioMode_genericAudioMode 21 +#define T_H245AudioMode_g729Extensions 22 +#define T_H245AudioMode_vbd 23 +#define T_H245AudioMode_extElem1 24 + +typedef struct EXTERN H245AudioMode { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + /* t = 9 */ + /* t = 10 */ + /* t = 11 */ + /* t = 12 */ + H245AudioMode_g7231 *g7231; + /* t = 13 */ + H245IS11172AudioMode *is11172AudioMode; + /* t = 14 */ + H245IS13818AudioMode *is13818AudioMode; + /* t = 15 */ + ASN1USINT g729wAnnexB; + /* t = 16 */ + ASN1USINT g729AnnexAwAnnexB; + /* t = 17 */ + H245G7231AnnexCMode *g7231AnnexCMode; + /* t = 18 */ + H245GSMAudioCapability *gsmFullRate; + /* t = 19 */ + H245GSMAudioCapability *gsmHalfRate; + /* t = 20 */ + H245GSMAudioCapability *gsmEnhancedFullRate; + /* t = 21 */ + H245GenericCapability *genericAudioMode; + /* t = 22 */ + H245G729Extensions *g729Extensions; + /* t = 23 */ + H245VBDMode *vbd; + /* t = 24 */ + } u; +} H245AudioMode; + +EXTERN int asn1PE_H245AudioMode (OOCTXT* pctxt, H245AudioMode* pvalue); + +EXTERN int asn1PD_H245AudioMode (OOCTXT* pctxt, H245AudioMode* pvalue); + +/**************************************************************/ +/* */ +/* DataMode_application_nlpid */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245DataMode_application_nlpid { + H245DataProtocolCapability nlpidProtocol; + ASN1DynOctStr nlpidData; +} H245DataMode_application_nlpid; + +EXTERN int asn1PE_H245DataMode_application_nlpid (OOCTXT* pctxt, H245DataMode_application_nlpid* pvalue); + +EXTERN int asn1PD_H245DataMode_application_nlpid (OOCTXT* pctxt, H245DataMode_application_nlpid* pvalue); + +/**************************************************************/ +/* */ +/* DataMode_application_t38fax */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245DataMode_application_t38fax { + H245DataProtocolCapability t38FaxProtocol; + H245T38FaxProfile t38FaxProfile; +} H245DataMode_application_t38fax; + +EXTERN int asn1PE_H245DataMode_application_t38fax (OOCTXT* pctxt, H245DataMode_application_t38fax* pvalue); + +EXTERN int asn1PD_H245DataMode_application_t38fax (OOCTXT* pctxt, H245DataMode_application_t38fax* pvalue); + +/**************************************************************/ +/* */ +/* DataMode_application */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245DataMode_application_nonStandard 1 +#define T_H245DataMode_application_t120 2 +#define T_H245DataMode_application_dsm_cc 3 +#define T_H245DataMode_application_userData 4 +#define T_H245DataMode_application_t84 5 +#define T_H245DataMode_application_t434 6 +#define T_H245DataMode_application_h224 7 +#define T_H245DataMode_application_nlpid 8 +#define T_H245DataMode_application_dsvdControl 9 +#define T_H245DataMode_application_h222DataPartitioning 10 +#define T_H245DataMode_application_t30fax 11 +#define T_H245DataMode_application_t140 12 +#define T_H245DataMode_application_t38fax 13 +#define T_H245DataMode_application_genericDataMode 14 +#define T_H245DataMode_application_extElem1 15 + +typedef struct EXTERN H245DataMode_application { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245DataProtocolCapability *t120; + /* t = 3 */ + H245DataProtocolCapability *dsm_cc; + /* t = 4 */ + H245DataProtocolCapability *userData; + /* t = 5 */ + H245DataProtocolCapability *t84; + /* t = 6 */ + H245DataProtocolCapability *t434; + /* t = 7 */ + H245DataProtocolCapability *h224; + /* t = 8 */ + H245DataMode_application_nlpid *nlpid; + /* t = 9 */ + /* t = 10 */ + H245DataProtocolCapability *h222DataPartitioning; + /* t = 11 */ + H245DataProtocolCapability *t30fax; + /* t = 12 */ + H245DataProtocolCapability *t140; + /* t = 13 */ + H245DataMode_application_t38fax *t38fax; + /* t = 14 */ + H245GenericCapability *genericDataMode; + /* t = 15 */ + } u; +} H245DataMode_application; + +EXTERN int asn1PE_H245DataMode_application (OOCTXT* pctxt, H245DataMode_application* pvalue); + +EXTERN int asn1PD_H245DataMode_application (OOCTXT* pctxt, H245DataMode_application* pvalue); + +/**************************************************************/ +/* */ +/* DataMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245DataMode { + H245DataMode_application application; + ASN1UINT bitRate; +} H245DataMode; + +EXTERN int asn1PE_H245DataMode (OOCTXT* pctxt, H245DataMode* pvalue); + +EXTERN int asn1PD_H245DataMode (OOCTXT* pctxt, H245DataMode* pvalue); + +/**************************************************************/ +/* */ +/* H235Mode_mediaMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H235Mode_mediaMode_nonStandard 1 +#define T_H245H235Mode_mediaMode_videoMode 2 +#define T_H245H235Mode_mediaMode_audioMode 3 +#define T_H245H235Mode_mediaMode_dataMode 4 +#define T_H245H235Mode_mediaMode_extElem1 5 + +typedef struct EXTERN H245H235Mode_mediaMode { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245VideoMode *videoMode; + /* t = 3 */ + H245AudioMode *audioMode; + /* t = 4 */ + H245DataMode *dataMode; + /* t = 5 */ + } u; +} H245H235Mode_mediaMode; + +EXTERN int asn1PE_H245H235Mode_mediaMode (OOCTXT* pctxt, H245H235Mode_mediaMode* pvalue); + +EXTERN int asn1PD_H245H235Mode_mediaMode (OOCTXT* pctxt, H245H235Mode_mediaMode* pvalue); + +/**************************************************************/ +/* */ +/* H235Mode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H235Mode { + H245EncryptionAuthenticationAndIntegrity encryptionAuthenticationAndIntegrity; + H245H235Mode_mediaMode mediaMode; +} H245H235Mode; + +EXTERN int asn1PE_H245H235Mode (OOCTXT* pctxt, H245H235Mode* pvalue); + +EXTERN int asn1PD_H245H235Mode (OOCTXT* pctxt, H245H235Mode* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTModeElement_type */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RedundancyEncodingDTModeElement_type_nonStandard 1 +#define T_H245RedundancyEncodingDTModeElement_type_videoMode 2 +#define T_H245RedundancyEncodingDTModeElement_type_audioMode 3 +#define T_H245RedundancyEncodingDTModeElement_type_dataMode 4 +#define T_H245RedundancyEncodingDTModeElement_type_encryptionMode 5 +#define T_H245RedundancyEncodingDTModeElement_type_h235Mode 6 +#define T_H245RedundancyEncodingDTModeElement_type_extElem1 7 + +typedef struct EXTERN H245RedundancyEncodingDTModeElement_type { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245VideoMode *videoMode; + /* t = 3 */ + H245AudioMode *audioMode; + /* t = 4 */ + H245DataMode *dataMode; + /* t = 5 */ + H245EncryptionMode *encryptionMode; + /* t = 6 */ + H245H235Mode *h235Mode; + /* t = 7 */ + } u; +} H245RedundancyEncodingDTModeElement_type; + +EXTERN int asn1PE_H245RedundancyEncodingDTModeElement_type (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement_type* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingDTModeElement_type (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement_type* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTModeElement */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RedundancyEncodingDTModeElement { + H245RedundancyEncodingDTModeElement_type type; +} H245RedundancyEncodingDTModeElement; + +EXTERN int asn1PE_H245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245RedundancyEncodingDTModeElement */ +/* */ +/**************************************************************/ + +/* List of H245RedundancyEncodingDTModeElement */ +typedef DList H245_SeqOfH245RedundancyEncodingDTModeElement; + +EXTERN int asn1PE_H245_SeqOfH245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingDTModeElement* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingDTModeElement* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RedundancyEncodingDTMode { + H245RedundancyEncodingMethod redundancyEncodingMethod; + H245RedundancyEncodingDTModeElement primary; + H245_SeqOfH245RedundancyEncodingDTModeElement secondary; +} H245RedundancyEncodingDTMode; + +EXTERN int asn1PE_H245RedundancyEncodingDTMode (OOCTXT* pctxt, H245RedundancyEncodingDTMode* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingDTMode (OOCTXT* pctxt, H245RedundancyEncodingDTMode* pvalue); + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamElementMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplePayloadStreamElementMode { + struct H245ModeElementType *type; +} H245MultiplePayloadStreamElementMode; + +EXTERN int asn1PE_H245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245MultiplePayloadStreamElementMode* pvalue); + +EXTERN int asn1PD_H245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245MultiplePayloadStreamElementMode* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245MultiplePayloadStreamElementMode */ +/* */ +/**************************************************************/ + +/* List of H245MultiplePayloadStreamElementMode */ +typedef DList H245_SeqOfH245MultiplePayloadStreamElementMode; + +EXTERN int asn1PE_H245_SeqOfH245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElementMode* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElementMode* pvalue); + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplePayloadStreamMode { + H245_SeqOfH245MultiplePayloadStreamElementMode elements; +} H245MultiplePayloadStreamMode; + +EXTERN int asn1PE_H245MultiplePayloadStreamMode (OOCTXT* pctxt, H245MultiplePayloadStreamMode* pvalue); + +EXTERN int asn1PD_H245MultiplePayloadStreamMode (OOCTXT* pctxt, H245MultiplePayloadStreamMode* pvalue); + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream_differentPort */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FECMode_rfc2733Mode_mode_separateStream_differentPort { + struct { + unsigned protectedPayloadTypePresent : 1; + } m; + ASN1UINT8 protectedSessionID; + ASN1UINT8 protectedPayloadType; +} H245FECMode_rfc2733Mode_mode_separateStream_differentPort; + +EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort* pvalue); + +EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort* pvalue); + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream_samePort */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FECMode_rfc2733Mode_mode_separateStream_samePort { + struct H245ModeElementType *protectedType; +} H245FECMode_rfc2733Mode_mode_separateStream_samePort; + +EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_samePort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort* pvalue); + +EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_samePort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort* pvalue); + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FECMode_rfc2733Mode_mode_separateStream_differentPort 1 +#define T_H245FECMode_rfc2733Mode_mode_separateStream_samePort 2 +#define T_H245FECMode_rfc2733Mode_mode_separateStream_extElem1 3 + +typedef struct EXTERN H245FECMode_rfc2733Mode_mode_separateStream { + int t; + union { + /* t = 1 */ + H245FECMode_rfc2733Mode_mode_separateStream_differentPort *differentPort; + /* t = 2 */ + H245FECMode_rfc2733Mode_mode_separateStream_samePort *samePort; + /* t = 3 */ + } u; +} H245FECMode_rfc2733Mode_mode_separateStream; + +EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream* pvalue); + +EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream* pvalue); + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FECMode_rfc2733Mode_mode_redundancyEncoding 1 +#define T_H245FECMode_rfc2733Mode_mode_separateStream 2 +#define T_H245FECMode_rfc2733Mode_mode_extElem1 3 + +typedef struct EXTERN H245FECMode_rfc2733Mode_mode { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245FECMode_rfc2733Mode_mode_separateStream *separateStream; + /* t = 3 */ + } u; +} H245FECMode_rfc2733Mode_mode; + +EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode* pvalue); + +EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode* pvalue); + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FECMode_rfc2733Mode { + H245FECMode_rfc2733Mode_mode mode; +} H245FECMode_rfc2733Mode; + +EXTERN int asn1PE_H245FECMode_rfc2733Mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode* pvalue); + +EXTERN int asn1PD_H245FECMode_rfc2733Mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode* pvalue); + +/**************************************************************/ +/* */ +/* FECMode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FECMode_rfc2733Mode 1 +#define T_H245FECMode_extElem1 2 + +typedef struct EXTERN H245FECMode { + int t; + union { + /* t = 1 */ + H245FECMode_rfc2733Mode *rfc2733Mode; + /* t = 2 */ + } u; +} H245FECMode; + +EXTERN int asn1PE_H245FECMode (OOCTXT* pctxt, H245FECMode* pvalue); + +EXTERN int asn1PD_H245FECMode (OOCTXT* pctxt, H245FECMode* pvalue); + +/**************************************************************/ +/* */ +/* ModeElementType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ModeElementType_nonStandard 1 +#define T_H245ModeElementType_videoMode 2 +#define T_H245ModeElementType_audioMode 3 +#define T_H245ModeElementType_dataMode 4 +#define T_H245ModeElementType_encryptionMode 5 +#define T_H245ModeElementType_h235Mode 6 +#define T_H245ModeElementType_multiplexedStreamMode 7 +#define T_H245ModeElementType_redundancyEncodingDTMode 8 +#define T_H245ModeElementType_multiplePayloadStreamMode 9 +#define T_H245ModeElementType_fecMode 10 +#define T_H245ModeElementType_extElem1 11 + +typedef struct EXTERN H245ModeElementType { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245VideoMode *videoMode; + /* t = 3 */ + H245AudioMode *audioMode; + /* t = 4 */ + H245DataMode *dataMode; + /* t = 5 */ + H245EncryptionMode *encryptionMode; + /* t = 6 */ + H245H235Mode *h235Mode; + /* t = 7 */ + H245MultiplexedStreamParameter *multiplexedStreamMode; + /* t = 8 */ + H245RedundancyEncodingDTMode *redundancyEncodingDTMode; + /* t = 9 */ + H245MultiplePayloadStreamMode *multiplePayloadStreamMode; + /* t = 10 */ + H245FECMode *fecMode; + /* t = 11 */ + } u; +} H245ModeElementType; + +EXTERN int asn1PE_H245ModeElementType (OOCTXT* pctxt, H245ModeElementType* pvalue); + +EXTERN int asn1PD_H245ModeElementType (OOCTXT* pctxt, H245ModeElementType* pvalue); + +/**************************************************************/ +/* */ +/* H223ModeParameters_adaptationLayerType_al3 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223ModeParameters_adaptationLayerType_al3 { + ASN1UINT8 controlFieldOctets; + ASN1UINT sendBufferSize; +} H245H223ModeParameters_adaptationLayerType_al3; + +EXTERN int asn1PE_H245H223ModeParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType_al3* pvalue); + +EXTERN int asn1PD_H245H223ModeParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType_al3* pvalue); + +/**************************************************************/ +/* */ +/* H223ModeParameters_adaptationLayerType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223ModeParameters_adaptationLayerType_nonStandard 1 +#define T_H245H223ModeParameters_adaptationLayerType_al1Framed 2 +#define T_H245H223ModeParameters_adaptationLayerType_al1NotFramed 3 +#define T_H245H223ModeParameters_adaptationLayerType_al2WithoutSequenceNumbers 4 +#define T_H245H223ModeParameters_adaptationLayerType_al2WithSequenceNumbers 5 +#define T_H245H223ModeParameters_adaptationLayerType_al3 6 +#define T_H245H223ModeParameters_adaptationLayerType_al1M 7 +#define T_H245H223ModeParameters_adaptationLayerType_al2M 8 +#define T_H245H223ModeParameters_adaptationLayerType_al3M 9 +#define T_H245H223ModeParameters_adaptationLayerType_extElem1 10 + +typedef struct EXTERN H245H223ModeParameters_adaptationLayerType { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + H245H223ModeParameters_adaptationLayerType_al3 *al3; + /* t = 7 */ + H245H223AL1MParameters *al1M; + /* t = 8 */ + H245H223AL2MParameters *al2M; + /* t = 9 */ + H245H223AL3MParameters *al3M; + /* t = 10 */ + } u; +} H245H223ModeParameters_adaptationLayerType; + +EXTERN int asn1PE_H245H223ModeParameters_adaptationLayerType (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType* pvalue); + +EXTERN int asn1PD_H245H223ModeParameters_adaptationLayerType (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType* pvalue); + +/**************************************************************/ +/* */ +/* H223ModeParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223ModeParameters { + H245H223ModeParameters_adaptationLayerType adaptationLayerType; + ASN1BOOL segmentableFlag; +} H245H223ModeParameters; + +EXTERN int asn1PE_H245H223ModeParameters (OOCTXT* pctxt, H245H223ModeParameters* pvalue); + +EXTERN int asn1PD_H245H223ModeParameters (OOCTXT* pctxt, H245H223ModeParameters* pvalue); + +/**************************************************************/ +/* */ +/* V76ModeParameters */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245V76ModeParameters_suspendResumewAddress 1 +#define T_H245V76ModeParameters_suspendResumewoAddress 2 +#define T_H245V76ModeParameters_extElem1 3 + +typedef struct EXTERN H245V76ModeParameters { + int t; +} H245V76ModeParameters; + +EXTERN int asn1PE_H245V76ModeParameters (OOCTXT* pctxt, H245V76ModeParameters* pvalue); + +EXTERN int asn1PD_H245V76ModeParameters (OOCTXT* pctxt, H245V76ModeParameters* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingMode_secondaryEncoding */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RedundancyEncodingMode_secondaryEncoding_nonStandard 1 +#define T_H245RedundancyEncodingMode_secondaryEncoding_audioData 2 +#define T_H245RedundancyEncodingMode_secondaryEncoding_extElem1 3 + +typedef struct EXTERN H245RedundancyEncodingMode_secondaryEncoding { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + H245AudioMode *audioData; + /* t = 3 */ + } u; +} H245RedundancyEncodingMode_secondaryEncoding; + +EXTERN int asn1PE_H245RedundancyEncodingMode_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingMode_secondaryEncoding* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingMode_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingMode_secondaryEncoding* pvalue); + +/**************************************************************/ +/* */ +/* RedundancyEncodingMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RedundancyEncodingMode { + struct { + unsigned secondaryEncodingPresent : 1; + } m; + H245RedundancyEncodingMethod redundancyEncodingMethod; + H245RedundancyEncodingMode_secondaryEncoding secondaryEncoding; +} H245RedundancyEncodingMode; + +EXTERN int asn1PE_H245RedundancyEncodingMode (OOCTXT* pctxt, H245RedundancyEncodingMode* pvalue); + +EXTERN int asn1PD_H245RedundancyEncodingMode (OOCTXT* pctxt, H245RedundancyEncodingMode* pvalue); + +/**************************************************************/ +/* */ +/* H2250ModeParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H2250ModeParameters { + struct { + unsigned redundancyEncodingModePresent : 1; + } m; + H245RedundancyEncodingMode redundancyEncodingMode; +} H245H2250ModeParameters; + +EXTERN int asn1PE_H245H2250ModeParameters (OOCTXT* pctxt, H245H2250ModeParameters* pvalue); + +EXTERN int asn1PD_H245H2250ModeParameters (OOCTXT* pctxt, H245H2250ModeParameters* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexedStreamModeParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexedStreamModeParameters { + H245LogicalChannelNumber logicalChannelNumber; +} H245MultiplexedStreamModeParameters; + +EXTERN int asn1PE_H245MultiplexedStreamModeParameters (OOCTXT* pctxt, H245MultiplexedStreamModeParameters* pvalue); + +EXTERN int asn1PD_H245MultiplexedStreamModeParameters (OOCTXT* pctxt, H245MultiplexedStreamModeParameters* pvalue); + +/**************************************************************/ +/* */ +/* ModeElement */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ModeElement { + struct { + unsigned h223ModeParametersPresent : 1; + unsigned v76ModeParametersPresent : 1; + unsigned h2250ModeParametersPresent : 1; + unsigned genericModeParametersPresent : 1; + unsigned multiplexedStreamModeParametersPresent : 1; + } m; + H245ModeElementType type; + H245H223ModeParameters h223ModeParameters; + H245V76ModeParameters v76ModeParameters; + H245H2250ModeParameters h2250ModeParameters; + H245GenericCapability genericModeParameters; + H245MultiplexedStreamModeParameters multiplexedStreamModeParameters; +} H245ModeElement; + +EXTERN int asn1PE_H245ModeElement (OOCTXT* pctxt, H245ModeElement* pvalue); + +EXTERN int asn1PD_H245ModeElement (OOCTXT* pctxt, H245ModeElement* pvalue); + +/**************************************************************/ +/* */ +/* ModeDescription */ +/* */ +/**************************************************************/ + +/* List of H245ModeElement */ +typedef DList H245ModeDescription; + +EXTERN int asn1PE_H245ModeDescription (OOCTXT* pctxt, H245ModeDescription* pvalue); + +EXTERN int asn1PD_H245ModeDescription (OOCTXT* pctxt, H245ModeDescription* pvalue); + +/**************************************************************/ +/* */ +/* RequestMode_requestedModes */ +/* */ +/**************************************************************/ + +/* List of H245ModeDescription */ +typedef DList H245RequestMode_requestedModes; + +EXTERN int asn1PE_H245RequestMode_requestedModes (OOCTXT* pctxt, H245RequestMode_requestedModes* pvalue); + +EXTERN int asn1PD_H245RequestMode_requestedModes (OOCTXT* pctxt, H245RequestMode_requestedModes* pvalue); + +/**************************************************************/ +/* */ +/* RequestMode */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMode { + H245SequenceNumber sequenceNumber; + H245RequestMode_requestedModes requestedModes; +} H245RequestMode; + +EXTERN int asn1PE_H245RequestMode (OOCTXT* pctxt, H245RequestMode* pvalue); + +EXTERN int asn1PD_H245RequestMode (OOCTXT* pctxt, H245RequestMode* pvalue); + +/**************************************************************/ +/* */ +/* RoundTripDelayRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RoundTripDelayRequest { + H245SequenceNumber sequenceNumber; +} H245RoundTripDelayRequest; + +EXTERN int asn1PE_H245RoundTripDelayRequest (OOCTXT* pctxt, H245RoundTripDelayRequest* pvalue); + +EXTERN int asn1PD_H245RoundTripDelayRequest (OOCTXT* pctxt, H245RoundTripDelayRequest* pvalue); + +/**************************************************************/ +/* */ +/* MaintenanceLoopRequest_type */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MaintenanceLoopRequest_type_systemLoop 1 +#define T_H245MaintenanceLoopRequest_type_mediaLoop 2 +#define T_H245MaintenanceLoopRequest_type_logicalChannelLoop 3 +#define T_H245MaintenanceLoopRequest_type_extElem1 4 + +typedef struct EXTERN H245MaintenanceLoopRequest_type { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245LogicalChannelNumber mediaLoop; + /* t = 3 */ + H245LogicalChannelNumber logicalChannelLoop; + /* t = 4 */ + } u; +} H245MaintenanceLoopRequest_type; + +EXTERN int asn1PE_H245MaintenanceLoopRequest_type (OOCTXT* pctxt, H245MaintenanceLoopRequest_type* pvalue); + +EXTERN int asn1PD_H245MaintenanceLoopRequest_type (OOCTXT* pctxt, H245MaintenanceLoopRequest_type* pvalue); + +/**************************************************************/ +/* */ +/* MaintenanceLoopRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MaintenanceLoopRequest { + H245MaintenanceLoopRequest_type type; +} H245MaintenanceLoopRequest; + +EXTERN int asn1PE_H245MaintenanceLoopRequest (OOCTXT* pctxt, H245MaintenanceLoopRequest* pvalue); + +EXTERN int asn1PD_H245MaintenanceLoopRequest (OOCTXT* pctxt, H245MaintenanceLoopRequest* pvalue); + +/**************************************************************/ +/* */ +/* CommunicationModeRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CommunicationModeRequest { + ASN1OCTET __dummy__; +} H245CommunicationModeRequest; + +EXTERN int asn1PE_H245CommunicationModeRequest (OOCTXT* pctxt, H245CommunicationModeRequest* pvalue); + +EXTERN int asn1PD_H245CommunicationModeRequest (OOCTXT* pctxt, H245CommunicationModeRequest* pvalue); + +/**************************************************************/ +/* */ +/* Criteria */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245Criteria { + ASN1OBJID field; + ASN1DynOctStr value; +} H245Criteria; + +EXTERN int asn1PE_H245Criteria (OOCTXT* pctxt, H245Criteria* pvalue); + +EXTERN int asn1PD_H245Criteria (OOCTXT* pctxt, H245Criteria* pvalue); + +/**************************************************************/ +/* */ +/* CertSelectionCriteria */ +/* */ +/**************************************************************/ + +/* List of H245Criteria */ +typedef DList H245CertSelectionCriteria; + +EXTERN int asn1PE_H245CertSelectionCriteria (OOCTXT* pctxt, H245CertSelectionCriteria* pvalue); + +EXTERN int asn1PD_H245CertSelectionCriteria (OOCTXT* pctxt, H245CertSelectionCriteria* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceRequest_requestTerminalCertificate */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceRequest_requestTerminalCertificate { + struct { + unsigned terminalLabelPresent : 1; + unsigned certSelectionCriteriaPresent : 1; + unsigned sRandomPresent : 1; + } m; + H245TerminalLabel terminalLabel; + H245CertSelectionCriteria certSelectionCriteria; + ASN1UINT sRandom; +} H245ConferenceRequest_requestTerminalCertificate; + +EXTERN int asn1PE_H245ConferenceRequest_requestTerminalCertificate (OOCTXT* pctxt, H245ConferenceRequest_requestTerminalCertificate* pvalue); + +EXTERN int asn1PD_H245ConferenceRequest_requestTerminalCertificate (OOCTXT* pctxt, H245ConferenceRequest_requestTerminalCertificate* pvalue); + +/**************************************************************/ +/* */ +/* RemoteMCRequest */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RemoteMCRequest_masterActivate 1 +#define T_H245RemoteMCRequest_slaveActivate 2 +#define T_H245RemoteMCRequest_deActivate 3 +#define T_H245RemoteMCRequest_extElem1 4 + +typedef struct EXTERN H245RemoteMCRequest { + int t; +} H245RemoteMCRequest; + +EXTERN int asn1PE_H245RemoteMCRequest (OOCTXT* pctxt, H245RemoteMCRequest* pvalue); + +EXTERN int asn1PD_H245RemoteMCRequest (OOCTXT* pctxt, H245RemoteMCRequest* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceRequest */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ConferenceRequest_terminalListRequest 1 +#define T_H245ConferenceRequest_makeMeChair 2 +#define T_H245ConferenceRequest_cancelMakeMeChair 3 +#define T_H245ConferenceRequest_dropTerminal 4 +#define T_H245ConferenceRequest_requestTerminalID 5 +#define T_H245ConferenceRequest_enterH243Password 6 +#define T_H245ConferenceRequest_enterH243TerminalID 7 +#define T_H245ConferenceRequest_enterH243ConferenceID 8 +#define T_H245ConferenceRequest_enterExtensionAddress 9 +#define T_H245ConferenceRequest_requestChairTokenOwner 10 +#define T_H245ConferenceRequest_requestTerminalCertificate 11 +#define T_H245ConferenceRequest_broadcastMyLogicalChannel 12 +#define T_H245ConferenceRequest_makeTerminalBroadcaster 13 +#define T_H245ConferenceRequest_sendThisSource 14 +#define T_H245ConferenceRequest_requestAllTerminalIDs 15 +#define T_H245ConferenceRequest_remoteMCRequest 16 +#define T_H245ConferenceRequest_extElem1 17 + +typedef struct EXTERN H245ConferenceRequest { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + H245TerminalLabel *dropTerminal; + /* t = 5 */ + H245TerminalLabel *requestTerminalID; + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + /* t = 9 */ + /* t = 10 */ + /* t = 11 */ + H245ConferenceRequest_requestTerminalCertificate *requestTerminalCertificate; + /* t = 12 */ + H245LogicalChannelNumber broadcastMyLogicalChannel; + /* t = 13 */ + H245TerminalLabel *makeTerminalBroadcaster; + /* t = 14 */ + H245TerminalLabel *sendThisSource; + /* t = 15 */ + /* t = 16 */ + H245RemoteMCRequest *remoteMCRequest; + /* t = 17 */ + } u; +} H245ConferenceRequest; + +EXTERN int asn1PE_H245ConferenceRequest (OOCTXT* pctxt, H245ConferenceRequest* pvalue); + +EXTERN int asn1PD_H245ConferenceRequest (OOCTXT* pctxt, H245ConferenceRequest* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkRequest_callInformation */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkRequest_callInformation { + ASN1USINT maxNumberOfAdditionalConnections; +} H245MultilinkRequest_callInformation; + +EXTERN int asn1PE_H245MultilinkRequest_callInformation (OOCTXT* pctxt, H245MultilinkRequest_callInformation* pvalue); + +EXTERN int asn1PD_H245MultilinkRequest_callInformation (OOCTXT* pctxt, H245MultilinkRequest_callInformation* pvalue); + +/**************************************************************/ +/* */ +/* DialingInformationNetworkType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245DialingInformationNetworkType_nonStandard 1 +#define T_H245DialingInformationNetworkType_n_isdn 2 +#define T_H245DialingInformationNetworkType_gstn 3 +#define T_H245DialingInformationNetworkType_mobile 4 +#define T_H245DialingInformationNetworkType_extElem1 5 + +typedef struct EXTERN H245DialingInformationNetworkType { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + } u; +} H245DialingInformationNetworkType; + +EXTERN int asn1PE_H245DialingInformationNetworkType (OOCTXT* pctxt, H245DialingInformationNetworkType* pvalue); + +EXTERN int asn1PD_H245DialingInformationNetworkType (OOCTXT* pctxt, H245DialingInformationNetworkType* pvalue); + +/**************************************************************/ +/* */ +/* DialingInformationNumber_networkType */ +/* */ +/**************************************************************/ + +/* List of H245DialingInformationNetworkType */ +typedef DList H245DialingInformationNumber_networkType; + +EXTERN int asn1PE_H245DialingInformationNumber_networkType (OOCTXT* pctxt, H245DialingInformationNumber_networkType* pvalue); + +EXTERN int asn1PD_H245DialingInformationNumber_networkType (OOCTXT* pctxt, H245DialingInformationNumber_networkType* pvalue); + +/**************************************************************/ +/* */ +/* DialingInformationNumber */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245DialingInformationNumber { + struct { + unsigned subAddressPresent : 1; + } m; + ASN1NumericString networkAddress; + ASN1IA5String subAddress; + H245DialingInformationNumber_networkType networkType; +} H245DialingInformationNumber; + +EXTERN int asn1PE_H245DialingInformationNumber (OOCTXT* pctxt, H245DialingInformationNumber* pvalue); + +EXTERN int asn1PD_H245DialingInformationNumber (OOCTXT* pctxt, H245DialingInformationNumber* pvalue); + +/**************************************************************/ +/* */ +/* DialingInformation_differential */ +/* */ +/**************************************************************/ + +/* List of H245DialingInformationNumber */ +typedef DList H245DialingInformation_differential; + +EXTERN int asn1PE_H245DialingInformation_differential (OOCTXT* pctxt, H245DialingInformation_differential* pvalue); + +EXTERN int asn1PD_H245DialingInformation_differential (OOCTXT* pctxt, H245DialingInformation_differential* pvalue); + +/**************************************************************/ +/* */ +/* DialingInformation */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245DialingInformation_nonStandard 1 +#define T_H245DialingInformation_differential 2 +#define T_H245DialingInformation_infoNotAvailable 3 +#define T_H245DialingInformation_extElem1 4 + +typedef struct EXTERN H245DialingInformation { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + H245DialingInformation_differential *differential; + /* t = 3 */ + ASN1USINT infoNotAvailable; + /* t = 4 */ + } u; +} H245DialingInformation; + +EXTERN int asn1PE_H245DialingInformation (OOCTXT* pctxt, H245DialingInformation* pvalue); + +EXTERN int asn1PD_H245DialingInformation (OOCTXT* pctxt, H245DialingInformation* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkRequest_addConnection */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkRequest_addConnection { + H245SequenceNumber sequenceNumber; + H245DialingInformation dialingInformation; +} H245MultilinkRequest_addConnection; + +EXTERN int asn1PE_H245MultilinkRequest_addConnection (OOCTXT* pctxt, H245MultilinkRequest_addConnection* pvalue); + +EXTERN int asn1PD_H245MultilinkRequest_addConnection (OOCTXT* pctxt, H245MultilinkRequest_addConnection* pvalue); + +/**************************************************************/ +/* */ +/* ConnectionIdentifier */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConnectionIdentifier { + ASN1UINT channelTag; + ASN1UINT sequenceNumber; +} H245ConnectionIdentifier; + +EXTERN int asn1PE_H245ConnectionIdentifier (OOCTXT* pctxt, H245ConnectionIdentifier* pvalue); + +EXTERN int asn1PD_H245ConnectionIdentifier (OOCTXT* pctxt, H245ConnectionIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkRequest_removeConnection */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkRequest_removeConnection { + H245ConnectionIdentifier connectionIdentifier; +} H245MultilinkRequest_removeConnection; + +EXTERN int asn1PE_H245MultilinkRequest_removeConnection (OOCTXT* pctxt, H245MultilinkRequest_removeConnection* pvalue); + +EXTERN int asn1PD_H245MultilinkRequest_removeConnection (OOCTXT* pctxt, H245MultilinkRequest_removeConnection* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkRequest_maximumHeaderInterval_requestType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultilinkRequest_maximumHeaderInterval_requestType_currentIntervalInformation 1 +#define T_H245MultilinkRequest_maximumHeaderInterval_requestType_requestedInterval 2 +#define T_H245MultilinkRequest_maximumHeaderInterval_requestType_extElem1 3 + +typedef struct EXTERN H245MultilinkRequest_maximumHeaderInterval_requestType { + int t; + union { + /* t = 1 */ + /* t = 2 */ + ASN1USINT requestedInterval; + /* t = 3 */ + } u; +} H245MultilinkRequest_maximumHeaderInterval_requestType; + +EXTERN int asn1PE_H245MultilinkRequest_maximumHeaderInterval_requestType (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval_requestType* pvalue); + +EXTERN int asn1PD_H245MultilinkRequest_maximumHeaderInterval_requestType (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval_requestType* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkRequest_maximumHeaderInterval */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkRequest_maximumHeaderInterval { + H245MultilinkRequest_maximumHeaderInterval_requestType requestType; +} H245MultilinkRequest_maximumHeaderInterval; + +EXTERN int asn1PE_H245MultilinkRequest_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval* pvalue); + +EXTERN int asn1PD_H245MultilinkRequest_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkRequest */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultilinkRequest_nonStandard 1 +#define T_H245MultilinkRequest_callInformation 2 +#define T_H245MultilinkRequest_addConnection 3 +#define T_H245MultilinkRequest_removeConnection 4 +#define T_H245MultilinkRequest_maximumHeaderInterval 5 +#define T_H245MultilinkRequest_extElem1 6 + +typedef struct EXTERN H245MultilinkRequest { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + H245MultilinkRequest_callInformation *callInformation; + /* t = 3 */ + H245MultilinkRequest_addConnection *addConnection; + /* t = 4 */ + H245MultilinkRequest_removeConnection *removeConnection; + /* t = 5 */ + H245MultilinkRequest_maximumHeaderInterval *maximumHeaderInterval; + /* t = 6 */ + } u; +} H245MultilinkRequest; + +EXTERN int asn1PE_H245MultilinkRequest (OOCTXT* pctxt, H245MultilinkRequest* pvalue); + +EXTERN int asn1PD_H245MultilinkRequest (OOCTXT* pctxt, H245MultilinkRequest* pvalue); + +/**************************************************************/ +/* */ +/* MaximumBitRate */ +/* */ +/**************************************************************/ + +typedef ASN1UINT H245MaximumBitRate; + +EXTERN int asn1PE_H245MaximumBitRate (OOCTXT* pctxt, H245MaximumBitRate value); + +EXTERN int asn1PD_H245MaximumBitRate (OOCTXT* pctxt, H245MaximumBitRate* pvalue); + +/**************************************************************/ +/* */ +/* LogicalChannelRateRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245LogicalChannelRateRequest { + H245SequenceNumber sequenceNumber; + H245LogicalChannelNumber logicalChannelNumber; + H245MaximumBitRate maximumBitRate; +} H245LogicalChannelRateRequest; + +EXTERN int asn1PE_H245LogicalChannelRateRequest (OOCTXT* pctxt, H245LogicalChannelRateRequest* pvalue); + +EXTERN int asn1PD_H245LogicalChannelRateRequest (OOCTXT* pctxt, H245LogicalChannelRateRequest* pvalue); + +/**************************************************************/ +/* */ +/* RequestMessage */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RequestMessage_nonStandard 1 +#define T_H245RequestMessage_masterSlaveDetermination 2 +#define T_H245RequestMessage_terminalCapabilitySet 3 +#define T_H245RequestMessage_openLogicalChannel 4 +#define T_H245RequestMessage_closeLogicalChannel 5 +#define T_H245RequestMessage_requestChannelClose 6 +#define T_H245RequestMessage_multiplexEntrySend 7 +#define T_H245RequestMessage_requestMultiplexEntry 8 +#define T_H245RequestMessage_requestMode 9 +#define T_H245RequestMessage_roundTripDelayRequest 10 +#define T_H245RequestMessage_maintenanceLoopRequest 11 +#define T_H245RequestMessage_communicationModeRequest 12 +#define T_H245RequestMessage_conferenceRequest 13 +#define T_H245RequestMessage_multilinkRequest 14 +#define T_H245RequestMessage_logicalChannelRateRequest 15 +#define T_H245RequestMessage_extElem1 16 + +typedef struct EXTERN H245RequestMessage { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + H245MasterSlaveDetermination *masterSlaveDetermination; + /* t = 3 */ + H245TerminalCapabilitySet *terminalCapabilitySet; + /* t = 4 */ + H245OpenLogicalChannel *openLogicalChannel; + /* t = 5 */ + H245CloseLogicalChannel *closeLogicalChannel; + /* t = 6 */ + H245RequestChannelClose *requestChannelClose; + /* t = 7 */ + H245MultiplexEntrySend *multiplexEntrySend; + /* t = 8 */ + H245RequestMultiplexEntry *requestMultiplexEntry; + /* t = 9 */ + H245RequestMode *requestMode; + /* t = 10 */ + H245RoundTripDelayRequest *roundTripDelayRequest; + /* t = 11 */ + H245MaintenanceLoopRequest *maintenanceLoopRequest; + /* t = 12 */ + H245CommunicationModeRequest *communicationModeRequest; + /* t = 13 */ + H245ConferenceRequest *conferenceRequest; + /* t = 14 */ + H245MultilinkRequest *multilinkRequest; + /* t = 15 */ + H245LogicalChannelRateRequest *logicalChannelRateRequest; + /* t = 16 */ + } u; +} H245RequestMessage; + +EXTERN int asn1PE_H245RequestMessage (OOCTXT* pctxt, H245RequestMessage* pvalue); + +EXTERN int asn1PD_H245RequestMessage (OOCTXT* pctxt, H245RequestMessage* pvalue); + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationAck_decision */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MasterSlaveDeterminationAck_decision_master 1 +#define T_H245MasterSlaveDeterminationAck_decision_slave 2 + +typedef struct EXTERN H245MasterSlaveDeterminationAck_decision { + int t; +} H245MasterSlaveDeterminationAck_decision; + +EXTERN int asn1PE_H245MasterSlaveDeterminationAck_decision (OOCTXT* pctxt, H245MasterSlaveDeterminationAck_decision* pvalue); + +EXTERN int asn1PD_H245MasterSlaveDeterminationAck_decision (OOCTXT* pctxt, H245MasterSlaveDeterminationAck_decision* pvalue); + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MasterSlaveDeterminationAck { + H245MasterSlaveDeterminationAck_decision decision; +} H245MasterSlaveDeterminationAck; + +EXTERN int asn1PE_H245MasterSlaveDeterminationAck (OOCTXT* pctxt, H245MasterSlaveDeterminationAck* pvalue); + +EXTERN int asn1PD_H245MasterSlaveDeterminationAck (OOCTXT* pctxt, H245MasterSlaveDeterminationAck* pvalue); + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationReject_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MasterSlaveDeterminationReject_cause_identicalNumbers 1 +#define T_H245MasterSlaveDeterminationReject_cause_extElem1 2 + +typedef struct EXTERN H245MasterSlaveDeterminationReject_cause { + int t; +} H245MasterSlaveDeterminationReject_cause; + +EXTERN int asn1PE_H245MasterSlaveDeterminationReject_cause (OOCTXT* pctxt, H245MasterSlaveDeterminationReject_cause* pvalue); + +EXTERN int asn1PD_H245MasterSlaveDeterminationReject_cause (OOCTXT* pctxt, H245MasterSlaveDeterminationReject_cause* pvalue); + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MasterSlaveDeterminationReject { + H245MasterSlaveDeterminationReject_cause cause; +} H245MasterSlaveDeterminationReject; + +EXTERN int asn1PE_H245MasterSlaveDeterminationReject (OOCTXT* pctxt, H245MasterSlaveDeterminationReject* pvalue); + +EXTERN int asn1PD_H245MasterSlaveDeterminationReject (OOCTXT* pctxt, H245MasterSlaveDeterminationReject* pvalue); + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TerminalCapabilitySetAck { + H245SequenceNumber sequenceNumber; +} H245TerminalCapabilitySetAck; + +EXTERN int asn1PE_H245TerminalCapabilitySetAck (OOCTXT* pctxt, H245TerminalCapabilitySetAck* pvalue); + +EXTERN int asn1PD_H245TerminalCapabilitySetAck (OOCTXT* pctxt, H245TerminalCapabilitySetAck* pvalue); + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject_cause_tableEntryCapacityExce */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded_highestEntryNumberProcessed 1 +#define T_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded_noneProcessed 2 + +typedef struct EXTERN H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded { + int t; + union { + /* t = 1 */ + H245CapabilityTableEntryNumber highestEntryNumberProcessed; + /* t = 2 */ + } u; +} H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded; + +EXTERN int asn1PE_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded* pvalue); + +EXTERN int asn1PD_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded* pvalue); + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245TerminalCapabilitySetReject_cause_unspecified 1 +#define T_H245TerminalCapabilitySetReject_cause_undefinedTableEntryUsed 2 +#define T_H245TerminalCapabilitySetReject_cause_descriptorCapacityExceeded 3 +#define T_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded 4 +#define T_H245TerminalCapabilitySetReject_cause_extElem1 5 + +typedef struct EXTERN H245TerminalCapabilitySetReject_cause { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded *tableEntryCapacityExceeded; + /* t = 5 */ + } u; +} H245TerminalCapabilitySetReject_cause; + +EXTERN int asn1PE_H245TerminalCapabilitySetReject_cause (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause* pvalue); + +EXTERN int asn1PD_H245TerminalCapabilitySetReject_cause (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause* pvalue); + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TerminalCapabilitySetReject { + H245SequenceNumber sequenceNumber; + H245TerminalCapabilitySetReject_cause cause; +} H245TerminalCapabilitySetReject; + +EXTERN int asn1PE_H245TerminalCapabilitySetReject (OOCTXT* pctxt, H245TerminalCapabilitySetReject* pvalue); + +EXTERN int asn1PD_H245TerminalCapabilitySetReject (OOCTXT* pctxt, H245TerminalCapabilitySetReject* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_reverseLogicalChannelParameters_mu */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h222LogicalChannelParameters 1 +#define T_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters 2 +#define T_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters_extElem1 3 + +typedef struct EXTERN H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters { + int t; + union { + /* t = 1 */ + H245H222LogicalChannelParameters *h222LogicalChannelParameters; + /* t = 2 */ + H245H2250LogicalChannelParameters *h2250LogicalChannelParameters; + /* t = 3 */ + } u; +} H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters; + +EXTERN int asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_reverseLogicalChannelParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245OpenLogicalChannelAck_reverseLogicalChannelParameters { + struct { + unsigned portNumberPresent : 1; + unsigned multiplexParametersPresent : 1; + unsigned replacementForPresent : 1; + } m; + H245LogicalChannelNumber reverseLogicalChannelNumber; + ASN1USINT portNumber; + H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters multiplexParameters; + H245LogicalChannelNumber replacementFor; +} H245OpenLogicalChannelAck_reverseLogicalChannelParameters; + +EXTERN int asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters* pvalue); + +/**************************************************************/ +/* */ +/* H2250LogicalChannelAckParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H2250LogicalChannelAckParameters { + struct { + unsigned nonStandardPresent : 1; + unsigned sessionIDPresent : 1; + unsigned mediaChannelPresent : 1; + unsigned mediaControlChannelPresent : 1; + unsigned dynamicRTPPayloadTypePresent : 1; + unsigned flowControlToZeroPresent : 1; + unsigned portNumberPresent : 1; + } m; + H245_SeqOfH245NonStandardParameter nonStandard; + ASN1UINT8 sessionID; + H245TransportAddress mediaChannel; + H245TransportAddress mediaControlChannel; + ASN1UINT8 dynamicRTPPayloadType; + ASN1BOOL flowControlToZero; + ASN1USINT portNumber; +} H245H2250LogicalChannelAckParameters; + +EXTERN int asn1PE_H245H2250LogicalChannelAckParameters (OOCTXT* pctxt, H245H2250LogicalChannelAckParameters* pvalue); + +EXTERN int asn1PD_H245H2250LogicalChannelAckParameters (OOCTXT* pctxt, H245H2250LogicalChannelAckParameters* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_forwardMultiplexAckParameters */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245OpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters 1 +#define T_H245OpenLogicalChannelAck_forwardMultiplexAckParameters_extElem1 2 + +typedef struct EXTERN H245OpenLogicalChannelAck_forwardMultiplexAckParameters { + int t; + union { + /* t = 1 */ + H245H2250LogicalChannelAckParameters *h2250LogicalChannelAckParameters; + /* t = 2 */ + } u; +} H245OpenLogicalChannelAck_forwardMultiplexAckParameters; + +EXTERN int asn1PE_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_forwardMultiplexAckParameters* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_forwardMultiplexAckParameters* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245OpenLogicalChannelAck { + struct { + unsigned reverseLogicalChannelParametersPresent : 1; + unsigned separateStackPresent : 1; + unsigned forwardMultiplexAckParametersPresent : 1; + unsigned encryptionSyncPresent : 1; + } m; + H245LogicalChannelNumber forwardLogicalChannelNumber; + H245OpenLogicalChannelAck_reverseLogicalChannelParameters reverseLogicalChannelParameters; + H245NetworkAccessParameters separateStack; + H245OpenLogicalChannelAck_forwardMultiplexAckParameters forwardMultiplexAckParameters; + H245EncryptionSync encryptionSync; +} H245OpenLogicalChannelAck; + +EXTERN int asn1PE_H245OpenLogicalChannelAck (OOCTXT* pctxt, H245OpenLogicalChannelAck* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannelAck (OOCTXT* pctxt, H245OpenLogicalChannelAck* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannelReject_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245OpenLogicalChannelReject_cause_unspecified 1 +#define T_H245OpenLogicalChannelReject_cause_unsuitableReverseParameters 2 +#define T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported 3 +#define T_H245OpenLogicalChannelReject_cause_dataTypeNotAvailable 4 +#define T_H245OpenLogicalChannelReject_cause_unknownDataType 5 +#define T_H245OpenLogicalChannelReject_cause_dataTypeALCombinationNotSupported 6 +#define T_H245OpenLogicalChannelReject_cause_multicastChannelNotAllowed 7 +#define T_H245OpenLogicalChannelReject_cause_insufficientBandwidth 8 +#define T_H245OpenLogicalChannelReject_cause_separateStackEstablishmentFailed 9 +#define T_H245OpenLogicalChannelReject_cause_invalidSessionID 10 +#define T_H245OpenLogicalChannelReject_cause_masterSlaveConflict 11 +#define T_H245OpenLogicalChannelReject_cause_waitForCommunicationMode 12 +#define T_H245OpenLogicalChannelReject_cause_invalidDependentChannel 13 +#define T_H245OpenLogicalChannelReject_cause_replacementForRejected 14 +#define T_H245OpenLogicalChannelReject_cause_extElem1 15 + +typedef struct EXTERN H245OpenLogicalChannelReject_cause { + int t; +} H245OpenLogicalChannelReject_cause; + +EXTERN int asn1PE_H245OpenLogicalChannelReject_cause (OOCTXT* pctxt, H245OpenLogicalChannelReject_cause* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannelReject_cause (OOCTXT* pctxt, H245OpenLogicalChannelReject_cause* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannelReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245OpenLogicalChannelReject { + H245LogicalChannelNumber forwardLogicalChannelNumber; + H245OpenLogicalChannelReject_cause cause; +} H245OpenLogicalChannelReject; + +EXTERN int asn1PE_H245OpenLogicalChannelReject (OOCTXT* pctxt, H245OpenLogicalChannelReject* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannelReject (OOCTXT* pctxt, H245OpenLogicalChannelReject* pvalue); + +/**************************************************************/ +/* */ +/* CloseLogicalChannelAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CloseLogicalChannelAck { + H245LogicalChannelNumber forwardLogicalChannelNumber; +} H245CloseLogicalChannelAck; + +EXTERN int asn1PE_H245CloseLogicalChannelAck (OOCTXT* pctxt, H245CloseLogicalChannelAck* pvalue); + +EXTERN int asn1PD_H245CloseLogicalChannelAck (OOCTXT* pctxt, H245CloseLogicalChannelAck* pvalue); + +/**************************************************************/ +/* */ +/* RequestChannelCloseAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestChannelCloseAck { + H245LogicalChannelNumber forwardLogicalChannelNumber; +} H245RequestChannelCloseAck; + +EXTERN int asn1PE_H245RequestChannelCloseAck (OOCTXT* pctxt, H245RequestChannelCloseAck* pvalue); + +EXTERN int asn1PD_H245RequestChannelCloseAck (OOCTXT* pctxt, H245RequestChannelCloseAck* pvalue); + +/**************************************************************/ +/* */ +/* RequestChannelCloseReject_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RequestChannelCloseReject_cause_unspecified 1 +#define T_H245RequestChannelCloseReject_cause_extElem1 2 + +typedef struct EXTERN H245RequestChannelCloseReject_cause { + int t; +} H245RequestChannelCloseReject_cause; + +EXTERN int asn1PE_H245RequestChannelCloseReject_cause (OOCTXT* pctxt, H245RequestChannelCloseReject_cause* pvalue); + +EXTERN int asn1PD_H245RequestChannelCloseReject_cause (OOCTXT* pctxt, H245RequestChannelCloseReject_cause* pvalue); + +/**************************************************************/ +/* */ +/* RequestChannelCloseReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestChannelCloseReject { + H245LogicalChannelNumber forwardLogicalChannelNumber; + H245RequestChannelCloseReject_cause cause; +} H245RequestChannelCloseReject; + +EXTERN int asn1PE_H245RequestChannelCloseReject (OOCTXT* pctxt, H245RequestChannelCloseReject* pvalue); + +EXTERN int asn1PD_H245RequestChannelCloseReject (OOCTXT* pctxt, H245RequestChannelCloseReject* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntrySendAck_multiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexEntrySendAck_multiplexTableEntryNumber { + ASN1UINT n; + H245MultiplexTableEntryNumber elem[15]; +} H245MultiplexEntrySendAck_multiplexTableEntryNumber; + +EXTERN int asn1PE_H245MultiplexEntrySendAck_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendAck_multiplexTableEntryNumber* pvalue); + +EXTERN int asn1PD_H245MultiplexEntrySendAck_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendAck_multiplexTableEntryNumber* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntrySendAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexEntrySendAck { + H245SequenceNumber sequenceNumber; + H245MultiplexEntrySendAck_multiplexTableEntryNumber multiplexTableEntryNumber; +} H245MultiplexEntrySendAck; + +EXTERN int asn1PE_H245MultiplexEntrySendAck (OOCTXT* pctxt, H245MultiplexEntrySendAck* pvalue); + +EXTERN int asn1PD_H245MultiplexEntrySendAck (OOCTXT* pctxt, H245MultiplexEntrySendAck* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntryRejectionDescriptions_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultiplexEntryRejectionDescriptions_cause_unspecifiedCause 1 +#define T_H245MultiplexEntryRejectionDescriptions_cause_descriptorTooComplex 2 +#define T_H245MultiplexEntryRejectionDescriptions_cause_extElem1 3 + +typedef struct EXTERN H245MultiplexEntryRejectionDescriptions_cause { + int t; +} H245MultiplexEntryRejectionDescriptions_cause; + +EXTERN int asn1PE_H245MultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions_cause* pvalue); + +EXTERN int asn1PD_H245MultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions_cause* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntryRejectionDescriptions */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexEntryRejectionDescriptions { + H245MultiplexTableEntryNumber multiplexTableEntryNumber; + H245MultiplexEntryRejectionDescriptions_cause cause; +} H245MultiplexEntryRejectionDescriptions; + +EXTERN int asn1PE_H245MultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions* pvalue); + +EXTERN int asn1PD_H245MultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntrySendReject_rejectionDescriptions */ +/* */ +/**************************************************************/ + +/* List of H245MultiplexEntryRejectionDescriptions */ +typedef DList H245MultiplexEntrySendReject_rejectionDescriptions; + +EXTERN int asn1PE_H245MultiplexEntrySendReject_rejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntrySendReject_rejectionDescriptions* pvalue); + +EXTERN int asn1PD_H245MultiplexEntrySendReject_rejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntrySendReject_rejectionDescriptions* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntrySendReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexEntrySendReject { + H245SequenceNumber sequenceNumber; + H245MultiplexEntrySendReject_rejectionDescriptions rejectionDescriptions; +} H245MultiplexEntrySendReject; + +EXTERN int asn1PE_H245MultiplexEntrySendReject (OOCTXT* pctxt, H245MultiplexEntrySendReject* pvalue); + +EXTERN int asn1PD_H245MultiplexEntrySendReject (OOCTXT* pctxt, H245MultiplexEntrySendReject* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryAck_entryNumbers */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntryAck_entryNumbers { + ASN1UINT n; + H245MultiplexTableEntryNumber elem[15]; +} H245RequestMultiplexEntryAck_entryNumbers; + +EXTERN int asn1PE_H245RequestMultiplexEntryAck_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryAck_entryNumbers* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryAck_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryAck_entryNumbers* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntryAck { + H245RequestMultiplexEntryAck_entryNumbers entryNumbers; +} H245RequestMultiplexEntryAck; + +EXTERN int asn1PE_H245RequestMultiplexEntryAck (OOCTXT* pctxt, H245RequestMultiplexEntryAck* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryAck (OOCTXT* pctxt, H245RequestMultiplexEntryAck* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject_entryNumbers */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntryReject_entryNumbers { + ASN1UINT n; + H245MultiplexTableEntryNumber elem[15]; +} H245RequestMultiplexEntryReject_entryNumbers; + +EXTERN int asn1PE_H245RequestMultiplexEntryReject_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryReject_entryNumbers* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryReject_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryReject_entryNumbers* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRejectionDescriptions_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RequestMultiplexEntryRejectionDescriptions_cause_unspecifiedCause 1 +#define T_H245RequestMultiplexEntryRejectionDescriptions_cause_extElem1 2 + +typedef struct EXTERN H245RequestMultiplexEntryRejectionDescriptions_cause { + int t; +} H245RequestMultiplexEntryRejectionDescriptions_cause; + +EXTERN int asn1PE_H245RequestMultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions_cause* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions_cause* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRejectionDescriptions */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntryRejectionDescriptions { + H245MultiplexTableEntryNumber multiplexTableEntryNumber; + H245RequestMultiplexEntryRejectionDescriptions_cause cause; +} H245RequestMultiplexEntryRejectionDescriptions; + +EXTERN int asn1PE_H245RequestMultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject_rejectionDescriptions */ +/* */ +/**************************************************************/ + +/* List of H245RequestMultiplexEntryRejectionDescriptions */ +typedef DList H245RequestMultiplexEntryReject_rejectionDescriptions; + +EXTERN int asn1PE_H245RequestMultiplexEntryReject_rejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryReject_rejectionDescriptions* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryReject_rejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryReject_rejectionDescriptions* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntryReject { + H245RequestMultiplexEntryReject_entryNumbers entryNumbers; + H245RequestMultiplexEntryReject_rejectionDescriptions rejectionDescriptions; +} H245RequestMultiplexEntryReject; + +EXTERN int asn1PE_H245RequestMultiplexEntryReject (OOCTXT* pctxt, H245RequestMultiplexEntryReject* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryReject (OOCTXT* pctxt, H245RequestMultiplexEntryReject* pvalue); + +/**************************************************************/ +/* */ +/* RequestModeAck_response */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RequestModeAck_response_willTransmitMostPreferredMode 1 +#define T_H245RequestModeAck_response_willTransmitLessPreferredMode 2 +#define T_H245RequestModeAck_response_extElem1 3 + +typedef struct EXTERN H245RequestModeAck_response { + int t; +} H245RequestModeAck_response; + +EXTERN int asn1PE_H245RequestModeAck_response (OOCTXT* pctxt, H245RequestModeAck_response* pvalue); + +EXTERN int asn1PD_H245RequestModeAck_response (OOCTXT* pctxt, H245RequestModeAck_response* pvalue); + +/**************************************************************/ +/* */ +/* RequestModeAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestModeAck { + H245SequenceNumber sequenceNumber; + H245RequestModeAck_response response; +} H245RequestModeAck; + +EXTERN int asn1PE_H245RequestModeAck (OOCTXT* pctxt, H245RequestModeAck* pvalue); + +EXTERN int asn1PD_H245RequestModeAck (OOCTXT* pctxt, H245RequestModeAck* pvalue); + +/**************************************************************/ +/* */ +/* RequestModeReject_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RequestModeReject_cause_modeUnavailable 1 +#define T_H245RequestModeReject_cause_multipointConstraint 2 +#define T_H245RequestModeReject_cause_requestDenied 3 +#define T_H245RequestModeReject_cause_extElem1 4 + +typedef struct EXTERN H245RequestModeReject_cause { + int t; +} H245RequestModeReject_cause; + +EXTERN int asn1PE_H245RequestModeReject_cause (OOCTXT* pctxt, H245RequestModeReject_cause* pvalue); + +EXTERN int asn1PD_H245RequestModeReject_cause (OOCTXT* pctxt, H245RequestModeReject_cause* pvalue); + +/**************************************************************/ +/* */ +/* RequestModeReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestModeReject { + H245SequenceNumber sequenceNumber; + H245RequestModeReject_cause cause; +} H245RequestModeReject; + +EXTERN int asn1PE_H245RequestModeReject (OOCTXT* pctxt, H245RequestModeReject* pvalue); + +EXTERN int asn1PD_H245RequestModeReject (OOCTXT* pctxt, H245RequestModeReject* pvalue); + +/**************************************************************/ +/* */ +/* RoundTripDelayResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RoundTripDelayResponse { + H245SequenceNumber sequenceNumber; +} H245RoundTripDelayResponse; + +EXTERN int asn1PE_H245RoundTripDelayResponse (OOCTXT* pctxt, H245RoundTripDelayResponse* pvalue); + +EXTERN int asn1PD_H245RoundTripDelayResponse (OOCTXT* pctxt, H245RoundTripDelayResponse* pvalue); + +/**************************************************************/ +/* */ +/* MaintenanceLoopAck_type */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MaintenanceLoopAck_type_systemLoop 1 +#define T_H245MaintenanceLoopAck_type_mediaLoop 2 +#define T_H245MaintenanceLoopAck_type_logicalChannelLoop 3 +#define T_H245MaintenanceLoopAck_type_extElem1 4 + +typedef struct EXTERN H245MaintenanceLoopAck_type { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245LogicalChannelNumber mediaLoop; + /* t = 3 */ + H245LogicalChannelNumber logicalChannelLoop; + /* t = 4 */ + } u; +} H245MaintenanceLoopAck_type; + +EXTERN int asn1PE_H245MaintenanceLoopAck_type (OOCTXT* pctxt, H245MaintenanceLoopAck_type* pvalue); + +EXTERN int asn1PD_H245MaintenanceLoopAck_type (OOCTXT* pctxt, H245MaintenanceLoopAck_type* pvalue); + +/**************************************************************/ +/* */ +/* MaintenanceLoopAck */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MaintenanceLoopAck { + H245MaintenanceLoopAck_type type; +} H245MaintenanceLoopAck; + +EXTERN int asn1PE_H245MaintenanceLoopAck (OOCTXT* pctxt, H245MaintenanceLoopAck* pvalue); + +EXTERN int asn1PD_H245MaintenanceLoopAck (OOCTXT* pctxt, H245MaintenanceLoopAck* pvalue); + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject_type */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MaintenanceLoopReject_type_systemLoop 1 +#define T_H245MaintenanceLoopReject_type_mediaLoop 2 +#define T_H245MaintenanceLoopReject_type_logicalChannelLoop 3 +#define T_H245MaintenanceLoopReject_type_extElem1 4 + +typedef struct EXTERN H245MaintenanceLoopReject_type { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245LogicalChannelNumber mediaLoop; + /* t = 3 */ + H245LogicalChannelNumber logicalChannelLoop; + /* t = 4 */ + } u; +} H245MaintenanceLoopReject_type; + +EXTERN int asn1PE_H245MaintenanceLoopReject_type (OOCTXT* pctxt, H245MaintenanceLoopReject_type* pvalue); + +EXTERN int asn1PD_H245MaintenanceLoopReject_type (OOCTXT* pctxt, H245MaintenanceLoopReject_type* pvalue); + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MaintenanceLoopReject_cause_canNotPerformLoop 1 +#define T_H245MaintenanceLoopReject_cause_extElem1 2 + +typedef struct EXTERN H245MaintenanceLoopReject_cause { + int t; +} H245MaintenanceLoopReject_cause; + +EXTERN int asn1PE_H245MaintenanceLoopReject_cause (OOCTXT* pctxt, H245MaintenanceLoopReject_cause* pvalue); + +EXTERN int asn1PD_H245MaintenanceLoopReject_cause (OOCTXT* pctxt, H245MaintenanceLoopReject_cause* pvalue); + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MaintenanceLoopReject { + H245MaintenanceLoopReject_type type; + H245MaintenanceLoopReject_cause cause; +} H245MaintenanceLoopReject; + +EXTERN int asn1PE_H245MaintenanceLoopReject (OOCTXT* pctxt, H245MaintenanceLoopReject* pvalue); + +EXTERN int asn1PD_H245MaintenanceLoopReject (OOCTXT* pctxt, H245MaintenanceLoopReject* pvalue); + +/**************************************************************/ +/* */ +/* CommunicationModeTableEntry_dataType */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CommunicationModeTableEntry_dataType_videoData 1 +#define T_H245CommunicationModeTableEntry_dataType_audioData 2 +#define T_H245CommunicationModeTableEntry_dataType_data 3 +#define T_H245CommunicationModeTableEntry_dataType_extElem1 4 + +typedef struct EXTERN H245CommunicationModeTableEntry_dataType { + int t; + union { + /* t = 1 */ + H245VideoCapability *videoData; + /* t = 2 */ + H245AudioCapability *audioData; + /* t = 3 */ + H245DataApplicationCapability *data; + /* t = 4 */ + } u; +} H245CommunicationModeTableEntry_dataType; + +EXTERN int asn1PE_H245CommunicationModeTableEntry_dataType (OOCTXT* pctxt, H245CommunicationModeTableEntry_dataType* pvalue); + +EXTERN int asn1PD_H245CommunicationModeTableEntry_dataType (OOCTXT* pctxt, H245CommunicationModeTableEntry_dataType* pvalue); + +/**************************************************************/ +/* */ +/* CommunicationModeTableEntry */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CommunicationModeTableEntry { + struct { + unsigned nonStandardPresent : 1; + unsigned associatedSessionIDPresent : 1; + unsigned terminalLabelPresent : 1; + unsigned mediaChannelPresent : 1; + unsigned mediaGuaranteedDeliveryPresent : 1; + unsigned mediaControlChannelPresent : 1; + unsigned mediaControlGuaranteedDeliveryPresent : 1; + unsigned redundancyEncodingPresent : 1; + unsigned sessionDependencyPresent : 1; + unsigned destinationPresent : 1; + } m; + H245_SeqOfH245NonStandardParameter nonStandard; + ASN1UINT8 sessionID; + ASN1UINT8 associatedSessionID; + H245TerminalLabel terminalLabel; + ASN1BMPString sessionDescription; + H245CommunicationModeTableEntry_dataType dataType; + H245TransportAddress mediaChannel; + ASN1BOOL mediaGuaranteedDelivery; + H245TransportAddress mediaControlChannel; + ASN1BOOL mediaControlGuaranteedDelivery; + H245RedundancyEncoding redundancyEncoding; + ASN1UINT8 sessionDependency; + H245TerminalLabel destination; +} H245CommunicationModeTableEntry; + +EXTERN int asn1PE_H245CommunicationModeTableEntry (OOCTXT* pctxt, H245CommunicationModeTableEntry* pvalue); + +EXTERN int asn1PD_H245CommunicationModeTableEntry (OOCTXT* pctxt, H245CommunicationModeTableEntry* pvalue); + +/**************************************************************/ +/* */ +/* CommunicationModeResponse_communicationModeTable */ +/* */ +/**************************************************************/ + +/* List of H245CommunicationModeTableEntry */ +typedef DList H245CommunicationModeResponse_communicationModeTable; + +EXTERN int asn1PE_H245CommunicationModeResponse_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeResponse_communicationModeTable* pvalue); + +EXTERN int asn1PD_H245CommunicationModeResponse_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeResponse_communicationModeTable* pvalue); + +/**************************************************************/ +/* */ +/* CommunicationModeResponse */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CommunicationModeResponse_communicationModeTable 1 +#define T_H245CommunicationModeResponse_extElem1 2 + +typedef struct EXTERN H245CommunicationModeResponse { + int t; + union { + /* t = 1 */ + H245CommunicationModeResponse_communicationModeTable *communicationModeTable; + /* t = 2 */ + } u; +} H245CommunicationModeResponse; + +EXTERN int asn1PE_H245CommunicationModeResponse (OOCTXT* pctxt, H245CommunicationModeResponse* pvalue); + +EXTERN int asn1PD_H245CommunicationModeResponse (OOCTXT* pctxt, H245CommunicationModeResponse* pvalue); + +/**************************************************************/ +/* */ +/* TerminalID */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TerminalID { + ASN1UINT numocts; + ASN1OCTET data[128]; +} H245TerminalID; + +EXTERN int asn1PE_H245TerminalID (OOCTXT* pctxt, H245TerminalID* pvalue); + +EXTERN int asn1PD_H245TerminalID (OOCTXT* pctxt, H245TerminalID* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_mCTerminalIDResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceResponse_mCTerminalIDResponse { + H245TerminalLabel terminalLabel; + H245TerminalID terminalID; +} H245ConferenceResponse_mCTerminalIDResponse; + +EXTERN int asn1PE_H245ConferenceResponse_mCTerminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_mCTerminalIDResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_mCTerminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_mCTerminalIDResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalIDResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceResponse_terminalIDResponse { + H245TerminalLabel terminalLabel; + H245TerminalID terminalID; +} H245ConferenceResponse_terminalIDResponse; + +EXTERN int asn1PE_H245ConferenceResponse_terminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalIDResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_terminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalIDResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceID */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceID { + ASN1UINT numocts; + ASN1OCTET data[32]; +} H245ConferenceID; + +EXTERN int asn1PE_H245ConferenceID (OOCTXT* pctxt, H245ConferenceID* pvalue); + +EXTERN int asn1PD_H245ConferenceID (OOCTXT* pctxt, H245ConferenceID* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_conferenceIDResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceResponse_conferenceIDResponse { + H245TerminalLabel terminalLabel; + H245ConferenceID conferenceID; +} H245ConferenceResponse_conferenceIDResponse; + +EXTERN int asn1PE_H245ConferenceResponse_conferenceIDResponse (OOCTXT* pctxt, H245ConferenceResponse_conferenceIDResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_conferenceIDResponse (OOCTXT* pctxt, H245ConferenceResponse_conferenceIDResponse* pvalue); + +/**************************************************************/ +/* */ +/* Password */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245Password { + ASN1UINT numocts; + ASN1OCTET data[32]; +} H245Password; + +EXTERN int asn1PE_H245Password (OOCTXT* pctxt, H245Password* pvalue); + +EXTERN int asn1PD_H245Password (OOCTXT* pctxt, H245Password* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_passwordResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceResponse_passwordResponse { + H245TerminalLabel terminalLabel; + H245Password password; +} H245ConferenceResponse_passwordResponse; + +EXTERN int asn1PE_H245ConferenceResponse_passwordResponse (OOCTXT* pctxt, H245ConferenceResponse_passwordResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_passwordResponse (OOCTXT* pctxt, H245ConferenceResponse_passwordResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalListResponse */ +/* */ +/**************************************************************/ + +/* List of H245TerminalLabel */ +typedef DList H245ConferenceResponse_terminalListResponse; + +EXTERN int asn1PE_H245ConferenceResponse_terminalListResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalListResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_terminalListResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalListResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_makeMeChairResponse */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ConferenceResponse_makeMeChairResponse_grantedChairToken 1 +#define T_H245ConferenceResponse_makeMeChairResponse_deniedChairToken 2 +#define T_H245ConferenceResponse_makeMeChairResponse_extElem1 3 + +typedef struct EXTERN H245ConferenceResponse_makeMeChairResponse { + int t; +} H245ConferenceResponse_makeMeChairResponse; + +EXTERN int asn1PE_H245ConferenceResponse_makeMeChairResponse (OOCTXT* pctxt, H245ConferenceResponse_makeMeChairResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_makeMeChairResponse (OOCTXT* pctxt, H245ConferenceResponse_makeMeChairResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_extensionAddressResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceResponse_extensionAddressResponse { + H245TerminalID extensionAddress; +} H245ConferenceResponse_extensionAddressResponse; + +EXTERN int asn1PE_H245ConferenceResponse_extensionAddressResponse (OOCTXT* pctxt, H245ConferenceResponse_extensionAddressResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_extensionAddressResponse (OOCTXT* pctxt, H245ConferenceResponse_extensionAddressResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_chairTokenOwnerResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceResponse_chairTokenOwnerResponse { + H245TerminalLabel terminalLabel; + H245TerminalID terminalID; +} H245ConferenceResponse_chairTokenOwnerResponse; + +EXTERN int asn1PE_H245ConferenceResponse_chairTokenOwnerResponse (OOCTXT* pctxt, H245ConferenceResponse_chairTokenOwnerResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_chairTokenOwnerResponse (OOCTXT* pctxt, H245ConferenceResponse_chairTokenOwnerResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalCertificateResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245ConferenceResponse_terminalCertificateResponse { + struct { + unsigned terminalLabelPresent : 1; + unsigned certificateResponsePresent : 1; + } m; + H245TerminalLabel terminalLabel; + ASN1DynOctStr certificateResponse; +} H245ConferenceResponse_terminalCertificateResponse; + +EXTERN int asn1PE_H245ConferenceResponse_terminalCertificateResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalCertificateResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_terminalCertificateResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalCertificateResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_broadcastMyLogicalChannelResponse */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ConferenceResponse_broadcastMyLogicalChannelResponse_grantedBroadcastMyLogicalChannel 1 +#define T_H245ConferenceResponse_broadcastMyLogicalChannelResponse_deniedBroadcastMyLogicalChannel 2 +#define T_H245ConferenceResponse_broadcastMyLogicalChannelResponse_extElem1 3 + +typedef struct EXTERN H245ConferenceResponse_broadcastMyLogicalChannelResponse { + int t; +} H245ConferenceResponse_broadcastMyLogicalChannelResponse; + +EXTERN int asn1PE_H245ConferenceResponse_broadcastMyLogicalChannelResponse (OOCTXT* pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_broadcastMyLogicalChannelResponse (OOCTXT* pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_makeTerminalBroadcasterResponse */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ConferenceResponse_makeTerminalBroadcasterResponse_grantedMakeTerminalBroadcaster 1 +#define T_H245ConferenceResponse_makeTerminalBroadcasterResponse_deniedMakeTerminalBroadcaster 2 +#define T_H245ConferenceResponse_makeTerminalBroadcasterResponse_extElem1 3 + +typedef struct EXTERN H245ConferenceResponse_makeTerminalBroadcasterResponse { + int t; +} H245ConferenceResponse_makeTerminalBroadcasterResponse; + +EXTERN int asn1PE_H245ConferenceResponse_makeTerminalBroadcasterResponse (OOCTXT* pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_makeTerminalBroadcasterResponse (OOCTXT* pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse_sendThisSourceResponse */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ConferenceResponse_sendThisSourceResponse_grantedSendThisSource 1 +#define T_H245ConferenceResponse_sendThisSourceResponse_deniedSendThisSource 2 +#define T_H245ConferenceResponse_sendThisSourceResponse_extElem1 3 + +typedef struct EXTERN H245ConferenceResponse_sendThisSourceResponse { + int t; +} H245ConferenceResponse_sendThisSourceResponse; + +EXTERN int asn1PE_H245ConferenceResponse_sendThisSourceResponse (OOCTXT* pctxt, H245ConferenceResponse_sendThisSourceResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse_sendThisSourceResponse (OOCTXT* pctxt, H245ConferenceResponse_sendThisSourceResponse* pvalue); + +/**************************************************************/ +/* */ +/* TerminalInformation */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TerminalInformation { + H245TerminalLabel terminalLabel; + H245TerminalID terminalID; +} H245TerminalInformation; + +EXTERN int asn1PE_H245TerminalInformation (OOCTXT* pctxt, H245TerminalInformation* pvalue); + +EXTERN int asn1PD_H245TerminalInformation (OOCTXT* pctxt, H245TerminalInformation* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245TerminalInformation */ +/* */ +/**************************************************************/ + +/* List of H245TerminalInformation */ +typedef DList H245_SeqOfH245TerminalInformation; + +EXTERN int asn1PE_H245_SeqOfH245TerminalInformation (OOCTXT* pctxt, H245_SeqOfH245TerminalInformation* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245TerminalInformation (OOCTXT* pctxt, H245_SeqOfH245TerminalInformation* pvalue); + +/**************************************************************/ +/* */ +/* RequestAllTerminalIDsResponse */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestAllTerminalIDsResponse { + H245_SeqOfH245TerminalInformation terminalInformation; +} H245RequestAllTerminalIDsResponse; + +EXTERN int asn1PE_H245RequestAllTerminalIDsResponse (OOCTXT* pctxt, H245RequestAllTerminalIDsResponse* pvalue); + +EXTERN int asn1PD_H245RequestAllTerminalIDsResponse (OOCTXT* pctxt, H245RequestAllTerminalIDsResponse* pvalue); + +/**************************************************************/ +/* */ +/* RemoteMCResponse_reject */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RemoteMCResponse_reject_unspecified 1 +#define T_H245RemoteMCResponse_reject_functionNotSupported 2 +#define T_H245RemoteMCResponse_reject_extElem1 3 + +typedef struct EXTERN H245RemoteMCResponse_reject { + int t; +} H245RemoteMCResponse_reject; + +EXTERN int asn1PE_H245RemoteMCResponse_reject (OOCTXT* pctxt, H245RemoteMCResponse_reject* pvalue); + +EXTERN int asn1PD_H245RemoteMCResponse_reject (OOCTXT* pctxt, H245RemoteMCResponse_reject* pvalue); + +/**************************************************************/ +/* */ +/* RemoteMCResponse */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245RemoteMCResponse_accept 1 +#define T_H245RemoteMCResponse_reject 2 +#define T_H245RemoteMCResponse_extElem1 3 + +typedef struct EXTERN H245RemoteMCResponse { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245RemoteMCResponse_reject *reject; + /* t = 3 */ + } u; +} H245RemoteMCResponse; + +EXTERN int asn1PE_H245RemoteMCResponse (OOCTXT* pctxt, H245RemoteMCResponse* pvalue); + +EXTERN int asn1PD_H245RemoteMCResponse (OOCTXT* pctxt, H245RemoteMCResponse* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceResponse */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ConferenceResponse_mCTerminalIDResponse 1 +#define T_H245ConferenceResponse_terminalIDResponse 2 +#define T_H245ConferenceResponse_conferenceIDResponse 3 +#define T_H245ConferenceResponse_passwordResponse 4 +#define T_H245ConferenceResponse_terminalListResponse 5 +#define T_H245ConferenceResponse_videoCommandReject 6 +#define T_H245ConferenceResponse_terminalDropReject 7 +#define T_H245ConferenceResponse_makeMeChairResponse 8 +#define T_H245ConferenceResponse_extensionAddressResponse 9 +#define T_H245ConferenceResponse_chairTokenOwnerResponse 10 +#define T_H245ConferenceResponse_terminalCertificateResponse 11 +#define T_H245ConferenceResponse_broadcastMyLogicalChannelResponse 12 +#define T_H245ConferenceResponse_makeTerminalBroadcasterResponse 13 +#define T_H245ConferenceResponse_sendThisSourceResponse 14 +#define T_H245ConferenceResponse_requestAllTerminalIDsResponse 15 +#define T_H245ConferenceResponse_remoteMCResponse 16 +#define T_H245ConferenceResponse_extElem1 17 + +typedef struct EXTERN H245ConferenceResponse { + int t; + union { + /* t = 1 */ + H245ConferenceResponse_mCTerminalIDResponse *mCTerminalIDResponse; + /* t = 2 */ + H245ConferenceResponse_terminalIDResponse *terminalIDResponse; + /* t = 3 */ + H245ConferenceResponse_conferenceIDResponse *conferenceIDResponse; + /* t = 4 */ + H245ConferenceResponse_passwordResponse *passwordResponse; + /* t = 5 */ + H245ConferenceResponse_terminalListResponse *terminalListResponse; + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + H245ConferenceResponse_makeMeChairResponse *makeMeChairResponse; + /* t = 9 */ + H245ConferenceResponse_extensionAddressResponse *extensionAddressResponse; + /* t = 10 */ + H245ConferenceResponse_chairTokenOwnerResponse *chairTokenOwnerResponse; + /* t = 11 */ + H245ConferenceResponse_terminalCertificateResponse *terminalCertificateResponse; + /* t = 12 */ + H245ConferenceResponse_broadcastMyLogicalChannelResponse *broadcastMyLogicalChannelResponse; + /* t = 13 */ + H245ConferenceResponse_makeTerminalBroadcasterResponse *makeTerminalBroadcasterResponse; + /* t = 14 */ + H245ConferenceResponse_sendThisSourceResponse *sendThisSourceResponse; + /* t = 15 */ + H245RequestAllTerminalIDsResponse *requestAllTerminalIDsResponse; + /* t = 16 */ + H245RemoteMCResponse *remoteMCResponse; + /* t = 17 */ + } u; +} H245ConferenceResponse; + +EXTERN int asn1PE_H245ConferenceResponse (OOCTXT* pctxt, H245ConferenceResponse* pvalue); + +EXTERN int asn1PD_H245ConferenceResponse (OOCTXT* pctxt, H245ConferenceResponse* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkResponse_callInformation */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkResponse_callInformation { + H245DialingInformation dialingInformation; + ASN1UINT callAssociationNumber; +} H245MultilinkResponse_callInformation; + +EXTERN int asn1PE_H245MultilinkResponse_callInformation (OOCTXT* pctxt, H245MultilinkResponse_callInformation* pvalue); + +EXTERN int asn1PD_H245MultilinkResponse_callInformation (OOCTXT* pctxt, H245MultilinkResponse_callInformation* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection_responseCode_rejected */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultilinkResponse_addConnection_responseCode_rejected_connectionsNotAvailable 1 +#define T_H245MultilinkResponse_addConnection_responseCode_rejected_userRejected 2 +#define T_H245MultilinkResponse_addConnection_responseCode_rejected_extElem1 3 + +typedef struct EXTERN H245MultilinkResponse_addConnection_responseCode_rejected { + int t; +} H245MultilinkResponse_addConnection_responseCode_rejected; + +EXTERN int asn1PE_H245MultilinkResponse_addConnection_responseCode_rejected (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode_rejected* pvalue); + +EXTERN int asn1PD_H245MultilinkResponse_addConnection_responseCode_rejected (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode_rejected* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection_responseCode */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultilinkResponse_addConnection_responseCode_accepted 1 +#define T_H245MultilinkResponse_addConnection_responseCode_rejected 2 +#define T_H245MultilinkResponse_addConnection_responseCode_extElem1 3 + +typedef struct EXTERN H245MultilinkResponse_addConnection_responseCode { + int t; + union { + /* t = 1 */ + /* t = 2 */ + H245MultilinkResponse_addConnection_responseCode_rejected *rejected; + /* t = 3 */ + } u; +} H245MultilinkResponse_addConnection_responseCode; + +EXTERN int asn1PE_H245MultilinkResponse_addConnection_responseCode (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode* pvalue); + +EXTERN int asn1PD_H245MultilinkResponse_addConnection_responseCode (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkResponse_addConnection { + H245SequenceNumber sequenceNumber; + H245MultilinkResponse_addConnection_responseCode responseCode; +} H245MultilinkResponse_addConnection; + +EXTERN int asn1PE_H245MultilinkResponse_addConnection (OOCTXT* pctxt, H245MultilinkResponse_addConnection* pvalue); + +EXTERN int asn1PD_H245MultilinkResponse_addConnection (OOCTXT* pctxt, H245MultilinkResponse_addConnection* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkResponse_removeConnection */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkResponse_removeConnection { + H245ConnectionIdentifier connectionIdentifier; +} H245MultilinkResponse_removeConnection; + +EXTERN int asn1PE_H245MultilinkResponse_removeConnection (OOCTXT* pctxt, H245MultilinkResponse_removeConnection* pvalue); + +EXTERN int asn1PD_H245MultilinkResponse_removeConnection (OOCTXT* pctxt, H245MultilinkResponse_removeConnection* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkResponse_maximumHeaderInterval */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkResponse_maximumHeaderInterval { + ASN1USINT currentInterval; +} H245MultilinkResponse_maximumHeaderInterval; + +EXTERN int asn1PE_H245MultilinkResponse_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkResponse_maximumHeaderInterval* pvalue); + +EXTERN int asn1PD_H245MultilinkResponse_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkResponse_maximumHeaderInterval* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkResponse */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultilinkResponse_nonStandard 1 +#define T_H245MultilinkResponse_callInformation 2 +#define T_H245MultilinkResponse_addConnection 3 +#define T_H245MultilinkResponse_removeConnection 4 +#define T_H245MultilinkResponse_maximumHeaderInterval 5 +#define T_H245MultilinkResponse_extElem1 6 + +typedef struct EXTERN H245MultilinkResponse { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + H245MultilinkResponse_callInformation *callInformation; + /* t = 3 */ + H245MultilinkResponse_addConnection *addConnection; + /* t = 4 */ + H245MultilinkResponse_removeConnection *removeConnection; + /* t = 5 */ + H245MultilinkResponse_maximumHeaderInterval *maximumHeaderInterval; + /* t = 6 */ + } u; +} H245MultilinkResponse; + +EXTERN int asn1PE_H245MultilinkResponse (OOCTXT* pctxt, H245MultilinkResponse* pvalue); + +EXTERN int asn1PD_H245MultilinkResponse (OOCTXT* pctxt, H245MultilinkResponse* pvalue); + +/**************************************************************/ +/* */ +/* LogicalChannelRateAcknowledge */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245LogicalChannelRateAcknowledge { + H245SequenceNumber sequenceNumber; + H245LogicalChannelNumber logicalChannelNumber; + H245MaximumBitRate maximumBitRate; +} H245LogicalChannelRateAcknowledge; + +EXTERN int asn1PE_H245LogicalChannelRateAcknowledge (OOCTXT* pctxt, H245LogicalChannelRateAcknowledge* pvalue); + +EXTERN int asn1PD_H245LogicalChannelRateAcknowledge (OOCTXT* pctxt, H245LogicalChannelRateAcknowledge* pvalue); + +/**************************************************************/ +/* */ +/* LogicalChannelRateRejectReason */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245LogicalChannelRateRejectReason_undefinedReason 1 +#define T_H245LogicalChannelRateRejectReason_insufficientResources 2 +#define T_H245LogicalChannelRateRejectReason_extElem1 3 + +typedef struct EXTERN H245LogicalChannelRateRejectReason { + int t; +} H245LogicalChannelRateRejectReason; + +EXTERN int asn1PE_H245LogicalChannelRateRejectReason (OOCTXT* pctxt, H245LogicalChannelRateRejectReason* pvalue); + +EXTERN int asn1PD_H245LogicalChannelRateRejectReason (OOCTXT* pctxt, H245LogicalChannelRateRejectReason* pvalue); + +/**************************************************************/ +/* */ +/* LogicalChannelRateReject */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245LogicalChannelRateReject { + struct { + unsigned currentMaximumBitRatePresent : 1; + } m; + H245SequenceNumber sequenceNumber; + H245LogicalChannelNumber logicalChannelNumber; + H245LogicalChannelRateRejectReason rejectReason; + H245MaximumBitRate currentMaximumBitRate; +} H245LogicalChannelRateReject; + +EXTERN int asn1PE_H245LogicalChannelRateReject (OOCTXT* pctxt, H245LogicalChannelRateReject* pvalue); + +EXTERN int asn1PD_H245LogicalChannelRateReject (OOCTXT* pctxt, H245LogicalChannelRateReject* pvalue); + +/**************************************************************/ +/* */ +/* ResponseMessage */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ResponseMessage_nonStandard 1 +#define T_H245ResponseMessage_masterSlaveDeterminationAck 2 +#define T_H245ResponseMessage_masterSlaveDeterminationReject 3 +#define T_H245ResponseMessage_terminalCapabilitySetAck 4 +#define T_H245ResponseMessage_terminalCapabilitySetReject 5 +#define T_H245ResponseMessage_openLogicalChannelAck 6 +#define T_H245ResponseMessage_openLogicalChannelReject 7 +#define T_H245ResponseMessage_closeLogicalChannelAck 8 +#define T_H245ResponseMessage_requestChannelCloseAck 9 +#define T_H245ResponseMessage_requestChannelCloseReject 10 +#define T_H245ResponseMessage_multiplexEntrySendAck 11 +#define T_H245ResponseMessage_multiplexEntrySendReject 12 +#define T_H245ResponseMessage_requestMultiplexEntryAck 13 +#define T_H245ResponseMessage_requestMultiplexEntryReject 14 +#define T_H245ResponseMessage_requestModeAck 15 +#define T_H245ResponseMessage_requestModeReject 16 +#define T_H245ResponseMessage_roundTripDelayResponse 17 +#define T_H245ResponseMessage_maintenanceLoopAck 18 +#define T_H245ResponseMessage_maintenanceLoopReject 19 +#define T_H245ResponseMessage_communicationModeResponse 20 +#define T_H245ResponseMessage_conferenceResponse 21 +#define T_H245ResponseMessage_multilinkResponse 22 +#define T_H245ResponseMessage_logicalChannelRateAcknowledge 23 +#define T_H245ResponseMessage_logicalChannelRateReject 24 +#define T_H245ResponseMessage_extElem1 25 + +typedef struct EXTERN H245ResponseMessage { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + H245MasterSlaveDeterminationAck *masterSlaveDeterminationAck; + /* t = 3 */ + H245MasterSlaveDeterminationReject *masterSlaveDeterminationReject; + /* t = 4 */ + H245TerminalCapabilitySetAck *terminalCapabilitySetAck; + /* t = 5 */ + H245TerminalCapabilitySetReject *terminalCapabilitySetReject; + /* t = 6 */ + H245OpenLogicalChannelAck *openLogicalChannelAck; + /* t = 7 */ + H245OpenLogicalChannelReject *openLogicalChannelReject; + /* t = 8 */ + H245CloseLogicalChannelAck *closeLogicalChannelAck; + /* t = 9 */ + H245RequestChannelCloseAck *requestChannelCloseAck; + /* t = 10 */ + H245RequestChannelCloseReject *requestChannelCloseReject; + /* t = 11 */ + H245MultiplexEntrySendAck *multiplexEntrySendAck; + /* t = 12 */ + H245MultiplexEntrySendReject *multiplexEntrySendReject; + /* t = 13 */ + H245RequestMultiplexEntryAck *requestMultiplexEntryAck; + /* t = 14 */ + H245RequestMultiplexEntryReject *requestMultiplexEntryReject; + /* t = 15 */ + H245RequestModeAck *requestModeAck; + /* t = 16 */ + H245RequestModeReject *requestModeReject; + /* t = 17 */ + H245RoundTripDelayResponse *roundTripDelayResponse; + /* t = 18 */ + H245MaintenanceLoopAck *maintenanceLoopAck; + /* t = 19 */ + H245MaintenanceLoopReject *maintenanceLoopReject; + /* t = 20 */ + H245CommunicationModeResponse *communicationModeResponse; + /* t = 21 */ + H245ConferenceResponse *conferenceResponse; + /* t = 22 */ + H245MultilinkResponse *multilinkResponse; + /* t = 23 */ + H245LogicalChannelRateAcknowledge *logicalChannelRateAcknowledge; + /* t = 24 */ + H245LogicalChannelRateReject *logicalChannelRateReject; + /* t = 25 */ + } u; +} H245ResponseMessage; + +EXTERN int asn1PE_H245ResponseMessage (OOCTXT* pctxt, H245ResponseMessage* pvalue); + +EXTERN int asn1PD_H245ResponseMessage (OOCTXT* pctxt, H245ResponseMessage* pvalue); + +/**************************************************************/ +/* */ +/* MaintenanceLoopOffCommand */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MaintenanceLoopOffCommand { + ASN1OCTET __dummy__; +} H245MaintenanceLoopOffCommand; + +EXTERN int asn1PE_H245MaintenanceLoopOffCommand (OOCTXT* pctxt, H245MaintenanceLoopOffCommand* pvalue); + +EXTERN int asn1PD_H245MaintenanceLoopOffCommand (OOCTXT* pctxt, H245MaintenanceLoopOffCommand* pvalue); + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest_capabilityTabl */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers { + ASN1UINT n; + H245CapabilityTableEntryNumber *elem; +} H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers; + +EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers* pvalue); + +EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers* pvalue); + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest_capabilityDesc */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers { + ASN1UINT n; + H245CapabilityDescriptorNumber elem[256]; +} H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers; + +EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers* pvalue); + +EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers* pvalue); + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245SendTerminalCapabilitySet_specificRequest { + struct { + unsigned capabilityTableEntryNumbersPresent : 1; + unsigned capabilityDescriptorNumbersPresent : 1; + } m; + ASN1BOOL multiplexCapability; + H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers capabilityTableEntryNumbers; + H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers capabilityDescriptorNumbers; +} H245SendTerminalCapabilitySet_specificRequest; + +EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest* pvalue); + +EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest* pvalue); + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245SendTerminalCapabilitySet_specificRequest 1 +#define T_H245SendTerminalCapabilitySet_genericRequest 2 +#define T_H245SendTerminalCapabilitySet_extElem1 3 + +typedef struct EXTERN H245SendTerminalCapabilitySet { + int t; + union { + /* t = 1 */ + H245SendTerminalCapabilitySet_specificRequest *specificRequest; + /* t = 2 */ + /* t = 3 */ + } u; +} H245SendTerminalCapabilitySet; + +EXTERN int asn1PE_H245SendTerminalCapabilitySet (OOCTXT* pctxt, H245SendTerminalCapabilitySet* pvalue); + +EXTERN int asn1PD_H245SendTerminalCapabilitySet (OOCTXT* pctxt, H245SendTerminalCapabilitySet* pvalue); + +/**************************************************************/ +/* */ +/* EncryptionCommand_encryptionAlgorithmID */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245EncryptionCommand_encryptionAlgorithmID { + H245SequenceNumber h233AlgorithmIdentifier; + H245NonStandardParameter associatedAlgorithm; +} H245EncryptionCommand_encryptionAlgorithmID; + +EXTERN int asn1PE_H245EncryptionCommand_encryptionAlgorithmID (OOCTXT* pctxt, H245EncryptionCommand_encryptionAlgorithmID* pvalue); + +EXTERN int asn1PD_H245EncryptionCommand_encryptionAlgorithmID (OOCTXT* pctxt, H245EncryptionCommand_encryptionAlgorithmID* pvalue); + +/**************************************************************/ +/* */ +/* EncryptionCommand */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245EncryptionCommand_encryptionSE 1 +#define T_H245EncryptionCommand_encryptionIVRequest 2 +#define T_H245EncryptionCommand_encryptionAlgorithmID 3 +#define T_H245EncryptionCommand_extElem1 4 + +typedef struct EXTERN H245EncryptionCommand { + int t; + union { + /* t = 1 */ + ASN1DynOctStr *encryptionSE; + /* t = 2 */ + /* t = 3 */ + H245EncryptionCommand_encryptionAlgorithmID *encryptionAlgorithmID; + /* t = 4 */ + } u; +} H245EncryptionCommand; + +EXTERN int asn1PE_H245EncryptionCommand (OOCTXT* pctxt, H245EncryptionCommand* pvalue); + +EXTERN int asn1PD_H245EncryptionCommand (OOCTXT* pctxt, H245EncryptionCommand* pvalue); + +/**************************************************************/ +/* */ +/* FlowControlCommand_scope */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FlowControlCommand_scope_logicalChannelNumber 1 +#define T_H245FlowControlCommand_scope_resourceID 2 +#define T_H245FlowControlCommand_scope_wholeMultiplex 3 + +typedef struct EXTERN H245FlowControlCommand_scope { + int t; + union { + /* t = 1 */ + H245LogicalChannelNumber logicalChannelNumber; + /* t = 2 */ + ASN1USINT resourceID; + /* t = 3 */ + } u; +} H245FlowControlCommand_scope; + +EXTERN int asn1PE_H245FlowControlCommand_scope (OOCTXT* pctxt, H245FlowControlCommand_scope* pvalue); + +EXTERN int asn1PD_H245FlowControlCommand_scope (OOCTXT* pctxt, H245FlowControlCommand_scope* pvalue); + +/**************************************************************/ +/* */ +/* FlowControlCommand_restriction */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FlowControlCommand_restriction_maximumBitRate 1 +#define T_H245FlowControlCommand_restriction_noRestriction 2 + +typedef struct EXTERN H245FlowControlCommand_restriction { + int t; + union { + /* t = 1 */ + ASN1UINT maximumBitRate; + /* t = 2 */ + } u; +} H245FlowControlCommand_restriction; + +EXTERN int asn1PE_H245FlowControlCommand_restriction (OOCTXT* pctxt, H245FlowControlCommand_restriction* pvalue); + +EXTERN int asn1PD_H245FlowControlCommand_restriction (OOCTXT* pctxt, H245FlowControlCommand_restriction* pvalue); + +/**************************************************************/ +/* */ +/* FlowControlCommand */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FlowControlCommand { + H245FlowControlCommand_scope scope; + H245FlowControlCommand_restriction restriction; +} H245FlowControlCommand; + +EXTERN int asn1PE_H245FlowControlCommand (OOCTXT* pctxt, H245FlowControlCommand* pvalue); + +EXTERN int asn1PD_H245FlowControlCommand (OOCTXT* pctxt, H245FlowControlCommand* pvalue); + +/**************************************************************/ +/* */ +/* EndSessionCommand_gstnOptions */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245EndSessionCommand_gstnOptions_telephonyMode 1 +#define T_H245EndSessionCommand_gstnOptions_v8bis 2 +#define T_H245EndSessionCommand_gstnOptions_v34DSVD 3 +#define T_H245EndSessionCommand_gstnOptions_v34DuplexFAX 4 +#define T_H245EndSessionCommand_gstnOptions_v34H324 5 +#define T_H245EndSessionCommand_gstnOptions_extElem1 6 + +typedef struct EXTERN H245EndSessionCommand_gstnOptions { + int t; +} H245EndSessionCommand_gstnOptions; + +EXTERN int asn1PE_H245EndSessionCommand_gstnOptions (OOCTXT* pctxt, H245EndSessionCommand_gstnOptions* pvalue); + +EXTERN int asn1PD_H245EndSessionCommand_gstnOptions (OOCTXT* pctxt, H245EndSessionCommand_gstnOptions* pvalue); + +/**************************************************************/ +/* */ +/* EndSessionCommand_isdnOptions */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245EndSessionCommand_isdnOptions_telephonyMode 1 +#define T_H245EndSessionCommand_isdnOptions_v140 2 +#define T_H245EndSessionCommand_isdnOptions_terminalOnHold 3 +#define T_H245EndSessionCommand_isdnOptions_extElem1 4 + +typedef struct EXTERN H245EndSessionCommand_isdnOptions { + int t; +} H245EndSessionCommand_isdnOptions; + +EXTERN int asn1PE_H245EndSessionCommand_isdnOptions (OOCTXT* pctxt, H245EndSessionCommand_isdnOptions* pvalue); + +EXTERN int asn1PD_H245EndSessionCommand_isdnOptions (OOCTXT* pctxt, H245EndSessionCommand_isdnOptions* pvalue); + +/**************************************************************/ +/* */ +/* EndSessionCommand */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245EndSessionCommand_nonStandard 1 +#define T_H245EndSessionCommand_disconnect 2 +#define T_H245EndSessionCommand_gstnOptions 3 +#define T_H245EndSessionCommand_isdnOptions 4 +#define T_H245EndSessionCommand_extElem1 5 + +typedef struct EXTERN H245EndSessionCommand { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + H245EndSessionCommand_gstnOptions *gstnOptions; + /* t = 4 */ + H245EndSessionCommand_isdnOptions *isdnOptions; + /* t = 5 */ + } u; +} H245EndSessionCommand; + +EXTERN int asn1PE_H245EndSessionCommand (OOCTXT* pctxt, H245EndSessionCommand* pvalue); + +EXTERN int asn1PD_H245EndSessionCommand (OOCTXT* pctxt, H245EndSessionCommand* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoFastUpdateGOB */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MiscellaneousCommand_type_videoFastUpdateGOB { + ASN1UINT8 firstGOB; + ASN1UINT8 numberOfGOBs; +} H245MiscellaneousCommand_type_videoFastUpdateGOB; + +EXTERN int asn1PE_H245MiscellaneousCommand_type_videoFastUpdateGOB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB* pvalue); + +EXTERN int asn1PD_H245MiscellaneousCommand_type_videoFastUpdateGOB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoFastUpdateMB */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MiscellaneousCommand_type_videoFastUpdateMB { + struct { + unsigned firstGOBPresent : 1; + unsigned firstMBPresent : 1; + } m; + ASN1UINT8 firstGOB; + ASN1USINT firstMB; + ASN1USINT numberOfMBs; +} H245MiscellaneousCommand_type_videoFastUpdateMB; + +EXTERN int asn1PE_H245MiscellaneousCommand_type_videoFastUpdateMB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB* pvalue); + +EXTERN int asn1PD_H245MiscellaneousCommand_type_videoFastUpdateMB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB* pvalue); + +/**************************************************************/ +/* */ +/* KeyProtectionMethod */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245KeyProtectionMethod { + ASN1BOOL secureChannel; + ASN1BOOL sharedSecret; + ASN1BOOL certProtectedKey; +} H245KeyProtectionMethod; + +EXTERN int asn1PE_H245KeyProtectionMethod (OOCTXT* pctxt, H245KeyProtectionMethod* pvalue); + +EXTERN int asn1PD_H245KeyProtectionMethod (OOCTXT* pctxt, H245KeyProtectionMethod* pvalue); + +/**************************************************************/ +/* */ +/* EncryptionUpdateRequest */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245EncryptionUpdateRequest { + struct { + unsigned keyProtectionMethodPresent : 1; + } m; + H245KeyProtectionMethod keyProtectionMethod; +} H245EncryptionUpdateRequest; + +EXTERN int asn1PE_H245EncryptionUpdateRequest (OOCTXT* pctxt, H245EncryptionUpdateRequest* pvalue); + +EXTERN int asn1PD_H245EncryptionUpdateRequest (OOCTXT* pctxt, H245EncryptionUpdateRequest* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_progressiveRefinementStart_rep */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_doOneProgression 1 +#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_doContinuousProgressions 2 +#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_doOneIndependentProgression 3 +#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_doContinuousIndependentProgressions 4 +#define T_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount_extElem1 5 + +typedef struct EXTERN H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount { + int t; +} H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount; + +EXTERN int asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount* pvalue); + +EXTERN int asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_progressiveRefinementStart */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MiscellaneousCommand_type_progressiveRefinementStart { + H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount repeatCount; +} H245MiscellaneousCommand_type_progressiveRefinementStart; + +EXTERN int asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart* pvalue); + +EXTERN int asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoBadMBs */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MiscellaneousCommand_type_videoBadMBs { + ASN1USINT firstMB; + ASN1USINT numberOfMBs; + ASN1USINT temporalReference; +} H245MiscellaneousCommand_type_videoBadMBs; + +EXTERN int asn1PE_H245MiscellaneousCommand_type_videoBadMBs (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoBadMBs* pvalue); + +EXTERN int asn1PD_H245MiscellaneousCommand_type_videoBadMBs (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoBadMBs* pvalue); + +/**************************************************************/ +/* */ +/* PictureReference */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245PictureReference_pictureNumber 1 +#define T_H245PictureReference_longTermPictureIndex 2 +#define T_H245PictureReference_extElem1 3 + +typedef struct EXTERN H245PictureReference { + int t; + union { + /* t = 1 */ + ASN1USINT pictureNumber; + /* t = 2 */ + ASN1UINT8 longTermPictureIndex; + /* t = 3 */ + } u; +} H245PictureReference; + +EXTERN int asn1PE_H245PictureReference (OOCTXT* pctxt, H245PictureReference* pvalue); + +EXTERN int asn1PD_H245PictureReference (OOCTXT* pctxt, H245PictureReference* pvalue); + +/**************************************************************/ +/* */ +/* _SeqOfH245PictureReference */ +/* */ +/**************************************************************/ + +/* List of H245PictureReference */ +typedef DList H245_SeqOfH245PictureReference; + +EXTERN int asn1PE_H245_SeqOfH245PictureReference (OOCTXT* pctxt, H245_SeqOfH245PictureReference* pvalue); + +EXTERN int asn1PD_H245_SeqOfH245PictureReference (OOCTXT* pctxt, H245_SeqOfH245PictureReference* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_lostPartialPicture */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MiscellaneousCommand_type_lostPartialPicture { + H245PictureReference pictureReference; + ASN1USINT firstMB; + ASN1USINT numberOfMBs; +} H245MiscellaneousCommand_type_lostPartialPicture; + +EXTERN int asn1PE_H245MiscellaneousCommand_type_lostPartialPicture (OOCTXT* pctxt, H245MiscellaneousCommand_type_lostPartialPicture* pvalue); + +EXTERN int asn1PD_H245MiscellaneousCommand_type_lostPartialPicture (OOCTXT* pctxt, H245MiscellaneousCommand_type_lostPartialPicture* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MiscellaneousCommand_type_equaliseDelay 1 +#define T_H245MiscellaneousCommand_type_zeroDelay 2 +#define T_H245MiscellaneousCommand_type_multipointModeCommand 3 +#define T_H245MiscellaneousCommand_type_cancelMultipointModeCommand 4 +#define T_H245MiscellaneousCommand_type_videoFreezePicture 5 +#define T_H245MiscellaneousCommand_type_videoFastUpdatePicture 6 +#define T_H245MiscellaneousCommand_type_videoFastUpdateGOB 7 +#define T_H245MiscellaneousCommand_type_videoTemporalSpatialTradeOff 8 +#define T_H245MiscellaneousCommand_type_videoSendSyncEveryGOB 9 +#define T_H245MiscellaneousCommand_type_videoSendSyncEveryGOBCancel 10 +#define T_H245MiscellaneousCommand_type_videoFastUpdateMB 11 +#define T_H245MiscellaneousCommand_type_maxH223MUXPDUsize 12 +#define T_H245MiscellaneousCommand_type_encryptionUpdate 13 +#define T_H245MiscellaneousCommand_type_encryptionUpdateRequest 14 +#define T_H245MiscellaneousCommand_type_switchReceiveMediaOff 15 +#define T_H245MiscellaneousCommand_type_switchReceiveMediaOn 16 +#define T_H245MiscellaneousCommand_type_progressiveRefinementStart 17 +#define T_H245MiscellaneousCommand_type_progressiveRefinementAbortOne 18 +#define T_H245MiscellaneousCommand_type_progressiveRefinementAbortContinuous 19 +#define T_H245MiscellaneousCommand_type_videoBadMBs 20 +#define T_H245MiscellaneousCommand_type_lostPicture 21 +#define T_H245MiscellaneousCommand_type_lostPartialPicture 22 +#define T_H245MiscellaneousCommand_type_recoveryReferencePicture 23 +#define T_H245MiscellaneousCommand_type_extElem1 24 + +typedef struct EXTERN H245MiscellaneousCommand_type { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + H245MiscellaneousCommand_type_videoFastUpdateGOB *videoFastUpdateGOB; + /* t = 8 */ + ASN1UINT8 videoTemporalSpatialTradeOff; + /* t = 9 */ + /* t = 10 */ + /* t = 11 */ + H245MiscellaneousCommand_type_videoFastUpdateMB *videoFastUpdateMB; + /* t = 12 */ + ASN1USINT maxH223MUXPDUsize; + /* t = 13 */ + H245EncryptionSync *encryptionUpdate; + /* t = 14 */ + H245EncryptionUpdateRequest *encryptionUpdateRequest; + /* t = 15 */ + /* t = 16 */ + /* t = 17 */ + H245MiscellaneousCommand_type_progressiveRefinementStart *progressiveRefinementStart; + /* t = 18 */ + /* t = 19 */ + /* t = 20 */ + H245MiscellaneousCommand_type_videoBadMBs *videoBadMBs; + /* t = 21 */ + H245_SeqOfH245PictureReference *lostPicture; + /* t = 22 */ + H245MiscellaneousCommand_type_lostPartialPicture *lostPartialPicture; + /* t = 23 */ + H245_SeqOfH245PictureReference *recoveryReferencePicture; + /* t = 24 */ + } u; +} H245MiscellaneousCommand_type; + +EXTERN int asn1PE_H245MiscellaneousCommand_type (OOCTXT* pctxt, H245MiscellaneousCommand_type* pvalue); + +EXTERN int asn1PD_H245MiscellaneousCommand_type (OOCTXT* pctxt, H245MiscellaneousCommand_type* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousCommand */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MiscellaneousCommand { + H245LogicalChannelNumber logicalChannelNumber; + H245MiscellaneousCommand_type type; +} H245MiscellaneousCommand; + +EXTERN int asn1PE_H245MiscellaneousCommand (OOCTXT* pctxt, H245MiscellaneousCommand* pvalue); + +EXTERN int asn1PD_H245MiscellaneousCommand (OOCTXT* pctxt, H245MiscellaneousCommand* pvalue); + +/**************************************************************/ +/* */ +/* CommunicationModeCommand_communicationModeTable */ +/* */ +/**************************************************************/ + +/* List of H245CommunicationModeTableEntry */ +typedef DList H245CommunicationModeCommand_communicationModeTable; + +EXTERN int asn1PE_H245CommunicationModeCommand_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeCommand_communicationModeTable* pvalue); + +EXTERN int asn1PD_H245CommunicationModeCommand_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeCommand_communicationModeTable* pvalue); + +/**************************************************************/ +/* */ +/* CommunicationModeCommand */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245CommunicationModeCommand { + H245CommunicationModeCommand_communicationModeTable communicationModeTable; +} H245CommunicationModeCommand; + +EXTERN int asn1PE_H245CommunicationModeCommand (OOCTXT* pctxt, H245CommunicationModeCommand* pvalue); + +EXTERN int asn1PD_H245CommunicationModeCommand (OOCTXT* pctxt, H245CommunicationModeCommand* pvalue); + +/**************************************************************/ +/* */ +/* SubstituteConferenceIDCommand_conferenceIdentifier */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245SubstituteConferenceIDCommand_conferenceIdentifier { + ASN1UINT numocts; + ASN1OCTET data[16]; +} H245SubstituteConferenceIDCommand_conferenceIdentifier; + +EXTERN int asn1PE_H245SubstituteConferenceIDCommand_conferenceIdentifier (OOCTXT* pctxt, H245SubstituteConferenceIDCommand_conferenceIdentifier* pvalue); + +EXTERN int asn1PD_H245SubstituteConferenceIDCommand_conferenceIdentifier (OOCTXT* pctxt, H245SubstituteConferenceIDCommand_conferenceIdentifier* pvalue); + +/**************************************************************/ +/* */ +/* SubstituteConferenceIDCommand */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245SubstituteConferenceIDCommand { + H245SubstituteConferenceIDCommand_conferenceIdentifier conferenceIdentifier; +} H245SubstituteConferenceIDCommand; + +EXTERN int asn1PE_H245SubstituteConferenceIDCommand (OOCTXT* pctxt, H245SubstituteConferenceIDCommand* pvalue); + +EXTERN int asn1PD_H245SubstituteConferenceIDCommand (OOCTXT* pctxt, H245SubstituteConferenceIDCommand* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceCommand */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ConferenceCommand_broadcastMyLogicalChannel 1 +#define T_H245ConferenceCommand_cancelBroadcastMyLogicalChannel 2 +#define T_H245ConferenceCommand_makeTerminalBroadcaster 3 +#define T_H245ConferenceCommand_cancelMakeTerminalBroadcaster 4 +#define T_H245ConferenceCommand_sendThisSource 5 +#define T_H245ConferenceCommand_cancelSendThisSource 6 +#define T_H245ConferenceCommand_dropConference 7 +#define T_H245ConferenceCommand_substituteConferenceIDCommand 8 +#define T_H245ConferenceCommand_extElem1 9 + +typedef struct EXTERN H245ConferenceCommand { + int t; + union { + /* t = 1 */ + H245LogicalChannelNumber broadcastMyLogicalChannel; + /* t = 2 */ + H245LogicalChannelNumber cancelBroadcastMyLogicalChannel; + /* t = 3 */ + H245TerminalLabel *makeTerminalBroadcaster; + /* t = 4 */ + /* t = 5 */ + H245TerminalLabel *sendThisSource; + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + H245SubstituteConferenceIDCommand *substituteConferenceIDCommand; + /* t = 9 */ + } u; +} H245ConferenceCommand; + +EXTERN int asn1PE_H245ConferenceCommand (OOCTXT* pctxt, H245ConferenceCommand* pvalue); + +EXTERN int asn1PD_H245ConferenceCommand (OOCTXT* pctxt, H245ConferenceCommand* pvalue); + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration_h223ModeChange */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223MultiplexReconfiguration_h223ModeChange_toLevel0 1 +#define T_H245H223MultiplexReconfiguration_h223ModeChange_toLevel1 2 +#define T_H245H223MultiplexReconfiguration_h223ModeChange_toLevel2 3 +#define T_H245H223MultiplexReconfiguration_h223ModeChange_toLevel2withOptionalHeader 4 +#define T_H245H223MultiplexReconfiguration_h223ModeChange_extElem1 5 + +typedef struct EXTERN H245H223MultiplexReconfiguration_h223ModeChange { + int t; +} H245H223MultiplexReconfiguration_h223ModeChange; + +EXTERN int asn1PE_H245H223MultiplexReconfiguration_h223ModeChange (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223ModeChange* pvalue); + +EXTERN int asn1PD_H245H223MultiplexReconfiguration_h223ModeChange (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223ModeChange* pvalue); + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration_h223AnnexADoubleFlag */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag_start 1 +#define T_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag_stop 2 +#define T_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag_extElem1 3 + +typedef struct EXTERN H245H223MultiplexReconfiguration_h223AnnexADoubleFlag { + int t; +} H245H223MultiplexReconfiguration_h223AnnexADoubleFlag; + +EXTERN int asn1PE_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag* pvalue); + +EXTERN int asn1PD_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag* pvalue); + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245H223MultiplexReconfiguration_h223ModeChange 1 +#define T_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag 2 +#define T_H245H223MultiplexReconfiguration_extElem1 3 + +typedef struct EXTERN H245H223MultiplexReconfiguration { + int t; + union { + /* t = 1 */ + H245H223MultiplexReconfiguration_h223ModeChange *h223ModeChange; + /* t = 2 */ + H245H223MultiplexReconfiguration_h223AnnexADoubleFlag *h223AnnexADoubleFlag; + /* t = 3 */ + } u; +} H245H223MultiplexReconfiguration; + +EXTERN int asn1PE_H245H223MultiplexReconfiguration (OOCTXT* pctxt, H245H223MultiplexReconfiguration* pvalue); + +EXTERN int asn1PD_H245H223MultiplexReconfiguration (OOCTXT* pctxt, H245H223MultiplexReconfiguration* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1_clockRecovery */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCCommand_aal_aal1_clockRecovery_nullClockRecovery 1 +#define T_H245NewATMVCCommand_aal_aal1_clockRecovery_srtsClockRecovery 2 +#define T_H245NewATMVCCommand_aal_aal1_clockRecovery_adaptiveClockRecovery 3 +#define T_H245NewATMVCCommand_aal_aal1_clockRecovery_extElem1 4 + +typedef struct EXTERN H245NewATMVCCommand_aal_aal1_clockRecovery { + int t; +} H245NewATMVCCommand_aal_aal1_clockRecovery; + +EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_clockRecovery* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_clockRecovery* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1_errorCorrection */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_nullErrorCorrection 1 +#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_longInterleaver 2 +#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_shortInterleaver 3 +#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_errorCorrectionOnly 4 +#define T_H245NewATMVCCommand_aal_aal1_errorCorrection_extElem1 5 + +typedef struct EXTERN H245NewATMVCCommand_aal_aal1_errorCorrection { + int t; +} H245NewATMVCCommand_aal_aal1_errorCorrection; + +EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_errorCorrection* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_errorCorrection* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NewATMVCCommand_aal_aal1 { + H245NewATMVCCommand_aal_aal1_clockRecovery clockRecovery; + H245NewATMVCCommand_aal_aal1_errorCorrection errorCorrection; + ASN1BOOL structuredDataTransfer; + ASN1BOOL partiallyFilledCells; +} H245NewATMVCCommand_aal_aal1; + +EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal5 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NewATMVCCommand_aal_aal5 { + ASN1USINT forwardMaximumSDUSize; + ASN1USINT backwardMaximumSDUSize; +} H245NewATMVCCommand_aal_aal5; + +EXTERN int asn1PE_H245NewATMVCCommand_aal_aal5 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal5* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand_aal_aal5 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal5* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCCommand_aal_aal1 1 +#define T_H245NewATMVCCommand_aal_aal5 2 +#define T_H245NewATMVCCommand_aal_extElem1 3 + +typedef struct EXTERN H245NewATMVCCommand_aal { + int t; + union { + /* t = 1 */ + H245NewATMVCCommand_aal_aal1 *aal1; + /* t = 2 */ + H245NewATMVCCommand_aal_aal5 *aal5; + /* t = 3 */ + } u; +} H245NewATMVCCommand_aal; + +EXTERN int asn1PE_H245NewATMVCCommand_aal (OOCTXT* pctxt, H245NewATMVCCommand_aal* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand_aal (OOCTXT* pctxt, H245NewATMVCCommand_aal* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand_multiplex */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCCommand_multiplex_noMultiplex 1 +#define T_H245NewATMVCCommand_multiplex_transportStream 2 +#define T_H245NewATMVCCommand_multiplex_programStream 3 +#define T_H245NewATMVCCommand_multiplex_extElem1 4 + +typedef struct EXTERN H245NewATMVCCommand_multiplex { + int t; +} H245NewATMVCCommand_multiplex; + +EXTERN int asn1PE_H245NewATMVCCommand_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_multiplex* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_multiplex* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand_reverseParameters_multiplex */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCCommand_reverseParameters_multiplex_noMultiplex 1 +#define T_H245NewATMVCCommand_reverseParameters_multiplex_transportStream 2 +#define T_H245NewATMVCCommand_reverseParameters_multiplex_programStream 3 +#define T_H245NewATMVCCommand_reverseParameters_multiplex_extElem1 4 + +typedef struct EXTERN H245NewATMVCCommand_reverseParameters_multiplex { + int t; +} H245NewATMVCCommand_reverseParameters_multiplex; + +EXTERN int asn1PE_H245NewATMVCCommand_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters_multiplex* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters_multiplex* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand_reverseParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NewATMVCCommand_reverseParameters { + ASN1USINT bitRate; + ASN1BOOL bitRateLockedToPCRClock; + ASN1BOOL bitRateLockedToNetworkClock; + H245NewATMVCCommand_reverseParameters_multiplex multiplex; +} H245NewATMVCCommand_reverseParameters; + +EXTERN int asn1PE_H245NewATMVCCommand_reverseParameters (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand_reverseParameters (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCCommand */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NewATMVCCommand { + ASN1USINT resourceID; + ASN1USINT bitRate; + ASN1BOOL bitRateLockedToPCRClock; + ASN1BOOL bitRateLockedToNetworkClock; + H245NewATMVCCommand_aal aal; + H245NewATMVCCommand_multiplex multiplex; + H245NewATMVCCommand_reverseParameters reverseParameters; +} H245NewATMVCCommand; + +EXTERN int asn1PE_H245NewATMVCCommand (OOCTXT* pctxt, H245NewATMVCCommand* pvalue); + +EXTERN int asn1PD_H245NewATMVCCommand (OOCTXT* pctxt, H245NewATMVCCommand* pvalue); + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationCommand_status */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MobileMultilinkReconfigurationCommand_status_synchronized_ 1 +#define T_H245MobileMultilinkReconfigurationCommand_status_reconfiguration 2 +#define T_H245MobileMultilinkReconfigurationCommand_status_extElem1 3 + +typedef struct EXTERN H245MobileMultilinkReconfigurationCommand_status { + int t; +} H245MobileMultilinkReconfigurationCommand_status; + +EXTERN int asn1PE_H245MobileMultilinkReconfigurationCommand_status (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand_status* pvalue); + +EXTERN int asn1PD_H245MobileMultilinkReconfigurationCommand_status (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand_status* pvalue); + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationCommand */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MobileMultilinkReconfigurationCommand { + ASN1UINT8 sampleSize; + ASN1UINT8 samplesPerFrame; + H245MobileMultilinkReconfigurationCommand_status status; +} H245MobileMultilinkReconfigurationCommand; + +EXTERN int asn1PE_H245MobileMultilinkReconfigurationCommand (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand* pvalue); + +EXTERN int asn1PD_H245MobileMultilinkReconfigurationCommand (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand* pvalue); + +/**************************************************************/ +/* */ +/* CommandMessage */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245CommandMessage_nonStandard 1 +#define T_H245CommandMessage_maintenanceLoopOffCommand 2 +#define T_H245CommandMessage_sendTerminalCapabilitySet 3 +#define T_H245CommandMessage_encryptionCommand 4 +#define T_H245CommandMessage_flowControlCommand 5 +#define T_H245CommandMessage_endSessionCommand 6 +#define T_H245CommandMessage_miscellaneousCommand 7 +#define T_H245CommandMessage_communicationModeCommand 8 +#define T_H245CommandMessage_conferenceCommand 9 +#define T_H245CommandMessage_h223MultiplexReconfiguration 10 +#define T_H245CommandMessage_newATMVCCommand 11 +#define T_H245CommandMessage_mobileMultilinkReconfigurationCommand 12 +#define T_H245CommandMessage_extElem1 13 + +typedef struct EXTERN H245CommandMessage { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + H245MaintenanceLoopOffCommand *maintenanceLoopOffCommand; + /* t = 3 */ + H245SendTerminalCapabilitySet *sendTerminalCapabilitySet; + /* t = 4 */ + H245EncryptionCommand *encryptionCommand; + /* t = 5 */ + H245FlowControlCommand *flowControlCommand; + /* t = 6 */ + H245EndSessionCommand *endSessionCommand; + /* t = 7 */ + H245MiscellaneousCommand *miscellaneousCommand; + /* t = 8 */ + H245CommunicationModeCommand *communicationModeCommand; + /* t = 9 */ + H245ConferenceCommand *conferenceCommand; + /* t = 10 */ + H245H223MultiplexReconfiguration *h223MultiplexReconfiguration; + /* t = 11 */ + H245NewATMVCCommand *newATMVCCommand; + /* t = 12 */ + H245MobileMultilinkReconfigurationCommand *mobileMultilinkReconfigurationCommand; + /* t = 13 */ + } u; +} H245CommandMessage; + +EXTERN int asn1PE_H245CommandMessage (OOCTXT* pctxt, H245CommandMessage* pvalue); + +EXTERN int asn1PD_H245CommandMessage (OOCTXT* pctxt, H245CommandMessage* pvalue); + +/**************************************************************/ +/* */ +/* FunctionNotUnderstood */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FunctionNotUnderstood_request 1 +#define T_H245FunctionNotUnderstood_response 2 +#define T_H245FunctionNotUnderstood_command 3 + +typedef struct EXTERN H245FunctionNotUnderstood { + int t; + union { + /* t = 1 */ + H245RequestMessage *request; + /* t = 2 */ + H245ResponseMessage *response; + /* t = 3 */ + H245CommandMessage *command; + } u; +} H245FunctionNotUnderstood; + +EXTERN int asn1PE_H245FunctionNotUnderstood (OOCTXT* pctxt, H245FunctionNotUnderstood* pvalue); + +EXTERN int asn1PD_H245FunctionNotUnderstood (OOCTXT* pctxt, H245FunctionNotUnderstood* pvalue); + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationRelease */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MasterSlaveDeterminationRelease { + ASN1OCTET __dummy__; +} H245MasterSlaveDeterminationRelease; + +EXTERN int asn1PE_H245MasterSlaveDeterminationRelease (OOCTXT* pctxt, H245MasterSlaveDeterminationRelease* pvalue); + +EXTERN int asn1PD_H245MasterSlaveDeterminationRelease (OOCTXT* pctxt, H245MasterSlaveDeterminationRelease* pvalue); + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetRelease */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TerminalCapabilitySetRelease { + ASN1OCTET __dummy__; +} H245TerminalCapabilitySetRelease; + +EXTERN int asn1PE_H245TerminalCapabilitySetRelease (OOCTXT* pctxt, H245TerminalCapabilitySetRelease* pvalue); + +EXTERN int asn1PD_H245TerminalCapabilitySetRelease (OOCTXT* pctxt, H245TerminalCapabilitySetRelease* pvalue); + +/**************************************************************/ +/* */ +/* OpenLogicalChannelConfirm */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245OpenLogicalChannelConfirm { + H245LogicalChannelNumber forwardLogicalChannelNumber; +} H245OpenLogicalChannelConfirm; + +EXTERN int asn1PE_H245OpenLogicalChannelConfirm (OOCTXT* pctxt, H245OpenLogicalChannelConfirm* pvalue); + +EXTERN int asn1PD_H245OpenLogicalChannelConfirm (OOCTXT* pctxt, H245OpenLogicalChannelConfirm* pvalue); + +/**************************************************************/ +/* */ +/* RequestChannelCloseRelease */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestChannelCloseRelease { + H245LogicalChannelNumber forwardLogicalChannelNumber; +} H245RequestChannelCloseRelease; + +EXTERN int asn1PE_H245RequestChannelCloseRelease (OOCTXT* pctxt, H245RequestChannelCloseRelease* pvalue); + +EXTERN int asn1PD_H245RequestChannelCloseRelease (OOCTXT* pctxt, H245RequestChannelCloseRelease* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntrySendRelease_multiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexEntrySendRelease_multiplexTableEntryNumber { + ASN1UINT n; + H245MultiplexTableEntryNumber elem[15]; +} H245MultiplexEntrySendRelease_multiplexTableEntryNumber; + +EXTERN int asn1PE_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendRelease_multiplexTableEntryNumber* pvalue); + +EXTERN int asn1PD_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendRelease_multiplexTableEntryNumber* pvalue); + +/**************************************************************/ +/* */ +/* MultiplexEntrySendRelease */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultiplexEntrySendRelease { + H245MultiplexEntrySendRelease_multiplexTableEntryNumber multiplexTableEntryNumber; +} H245MultiplexEntrySendRelease; + +EXTERN int asn1PE_H245MultiplexEntrySendRelease (OOCTXT* pctxt, H245MultiplexEntrySendRelease* pvalue); + +EXTERN int asn1PD_H245MultiplexEntrySendRelease (OOCTXT* pctxt, H245MultiplexEntrySendRelease* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRelease_entryNumbers */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntryRelease_entryNumbers { + ASN1UINT n; + H245MultiplexTableEntryNumber elem[15]; +} H245RequestMultiplexEntryRelease_entryNumbers; + +EXTERN int asn1PE_H245RequestMultiplexEntryRelease_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryRelease_entryNumbers* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryRelease_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryRelease_entryNumbers* pvalue); + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRelease */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestMultiplexEntryRelease { + H245RequestMultiplexEntryRelease_entryNumbers entryNumbers; +} H245RequestMultiplexEntryRelease; + +EXTERN int asn1PE_H245RequestMultiplexEntryRelease (OOCTXT* pctxt, H245RequestMultiplexEntryRelease* pvalue); + +EXTERN int asn1PD_H245RequestMultiplexEntryRelease (OOCTXT* pctxt, H245RequestMultiplexEntryRelease* pvalue); + +/**************************************************************/ +/* */ +/* RequestModeRelease */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245RequestModeRelease { + ASN1OCTET __dummy__; +} H245RequestModeRelease; + +EXTERN int asn1PE_H245RequestModeRelease (OOCTXT* pctxt, H245RequestModeRelease* pvalue); + +EXTERN int asn1PD_H245RequestModeRelease (OOCTXT* pctxt, H245RequestModeRelease* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousIndication_type_videoNotDecodedMBs */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MiscellaneousIndication_type_videoNotDecodedMBs { + ASN1USINT firstMB; + ASN1USINT numberOfMBs; + ASN1UINT8 temporalReference; +} H245MiscellaneousIndication_type_videoNotDecodedMBs; + +EXTERN int asn1PE_H245MiscellaneousIndication_type_videoNotDecodedMBs (OOCTXT* pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs* pvalue); + +EXTERN int asn1PD_H245MiscellaneousIndication_type_videoNotDecodedMBs (OOCTXT* pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousIndication_type */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MiscellaneousIndication_type_logicalChannelActive 1 +#define T_H245MiscellaneousIndication_type_logicalChannelInactive 2 +#define T_H245MiscellaneousIndication_type_multipointConference 3 +#define T_H245MiscellaneousIndication_type_cancelMultipointConference 4 +#define T_H245MiscellaneousIndication_type_multipointZeroComm 5 +#define T_H245MiscellaneousIndication_type_cancelMultipointZeroComm 6 +#define T_H245MiscellaneousIndication_type_multipointSecondaryStatus 7 +#define T_H245MiscellaneousIndication_type_cancelMultipointSecondaryStatus 8 +#define T_H245MiscellaneousIndication_type_videoIndicateReadyToActivate 9 +#define T_H245MiscellaneousIndication_type_videoTemporalSpatialTradeOff 10 +#define T_H245MiscellaneousIndication_type_videoNotDecodedMBs 11 +#define T_H245MiscellaneousIndication_type_transportCapability 12 +#define T_H245MiscellaneousIndication_type_extElem1 13 + +typedef struct EXTERN H245MiscellaneousIndication_type { + int t; + union { + /* t = 1 */ + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + /* t = 9 */ + /* t = 10 */ + ASN1UINT8 videoTemporalSpatialTradeOff; + /* t = 11 */ + H245MiscellaneousIndication_type_videoNotDecodedMBs *videoNotDecodedMBs; + /* t = 12 */ + H245TransportCapability *transportCapability; + /* t = 13 */ + } u; +} H245MiscellaneousIndication_type; + +EXTERN int asn1PE_H245MiscellaneousIndication_type (OOCTXT* pctxt, H245MiscellaneousIndication_type* pvalue); + +EXTERN int asn1PD_H245MiscellaneousIndication_type (OOCTXT* pctxt, H245MiscellaneousIndication_type* pvalue); + +/**************************************************************/ +/* */ +/* MiscellaneousIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MiscellaneousIndication { + H245LogicalChannelNumber logicalChannelNumber; + H245MiscellaneousIndication_type type; +} H245MiscellaneousIndication; + +EXTERN int asn1PE_H245MiscellaneousIndication (OOCTXT* pctxt, H245MiscellaneousIndication* pvalue); + +EXTERN int asn1PD_H245MiscellaneousIndication (OOCTXT* pctxt, H245MiscellaneousIndication* pvalue); + +/**************************************************************/ +/* */ +/* JitterIndication_scope */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245JitterIndication_scope_logicalChannelNumber 1 +#define T_H245JitterIndication_scope_resourceID 2 +#define T_H245JitterIndication_scope_wholeMultiplex 3 + +typedef struct EXTERN H245JitterIndication_scope { + int t; + union { + /* t = 1 */ + H245LogicalChannelNumber logicalChannelNumber; + /* t = 2 */ + ASN1USINT resourceID; + /* t = 3 */ + } u; +} H245JitterIndication_scope; + +EXTERN int asn1PE_H245JitterIndication_scope (OOCTXT* pctxt, H245JitterIndication_scope* pvalue); + +EXTERN int asn1PD_H245JitterIndication_scope (OOCTXT* pctxt, H245JitterIndication_scope* pvalue); + +/**************************************************************/ +/* */ +/* JitterIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245JitterIndication { + struct { + unsigned skippedFrameCountPresent : 1; + unsigned additionalDecoderBufferPresent : 1; + } m; + H245JitterIndication_scope scope; + ASN1UINT8 estimatedReceivedJitterMantissa; + ASN1UINT8 estimatedReceivedJitterExponent; + ASN1UINT8 skippedFrameCount; + ASN1UINT additionalDecoderBuffer; +} H245JitterIndication; + +EXTERN int asn1PE_H245JitterIndication (OOCTXT* pctxt, H245JitterIndication* pvalue); + +EXTERN int asn1PD_H245JitterIndication (OOCTXT* pctxt, H245JitterIndication* pvalue); + +/**************************************************************/ +/* */ +/* H223SkewIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H223SkewIndication { + H245LogicalChannelNumber logicalChannelNumber1; + H245LogicalChannelNumber logicalChannelNumber2; + ASN1USINT skew; +} H245H223SkewIndication; + +EXTERN int asn1PE_H245H223SkewIndication (OOCTXT* pctxt, H245H223SkewIndication* pvalue); + +EXTERN int asn1PD_H245H223SkewIndication (OOCTXT* pctxt, H245H223SkewIndication* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1_clockRecovery */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCIndication_aal_aal1_clockRecovery_nullClockRecovery 1 +#define T_H245NewATMVCIndication_aal_aal1_clockRecovery_srtsClockRecovery 2 +#define T_H245NewATMVCIndication_aal_aal1_clockRecovery_adaptiveClockRecovery 3 +#define T_H245NewATMVCIndication_aal_aal1_clockRecovery_extElem1 4 + +typedef struct EXTERN H245NewATMVCIndication_aal_aal1_clockRecovery { + int t; +} H245NewATMVCIndication_aal_aal1_clockRecovery; + +EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_clockRecovery* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_clockRecovery* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1_errorCorrection */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_nullErrorCorrection 1 +#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_longInterleaver 2 +#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_shortInterleaver 3 +#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_errorCorrectionOnly 4 +#define T_H245NewATMVCIndication_aal_aal1_errorCorrection_extElem1 5 + +typedef struct EXTERN H245NewATMVCIndication_aal_aal1_errorCorrection { + int t; +} H245NewATMVCIndication_aal_aal1_errorCorrection; + +EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_errorCorrection* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_errorCorrection* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NewATMVCIndication_aal_aal1 { + H245NewATMVCIndication_aal_aal1_clockRecovery clockRecovery; + H245NewATMVCIndication_aal_aal1_errorCorrection errorCorrection; + ASN1BOOL structuredDataTransfer; + ASN1BOOL partiallyFilledCells; +} H245NewATMVCIndication_aal_aal1; + +EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal5 */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NewATMVCIndication_aal_aal5 { + ASN1USINT forwardMaximumSDUSize; + ASN1USINT backwardMaximumSDUSize; +} H245NewATMVCIndication_aal_aal5; + +EXTERN int asn1PE_H245NewATMVCIndication_aal_aal5 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal5* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication_aal_aal5 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal5* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCIndication_aal_aal1 1 +#define T_H245NewATMVCIndication_aal_aal5 2 +#define T_H245NewATMVCIndication_aal_extElem1 3 + +typedef struct EXTERN H245NewATMVCIndication_aal { + int t; + union { + /* t = 1 */ + H245NewATMVCIndication_aal_aal1 *aal1; + /* t = 2 */ + H245NewATMVCIndication_aal_aal5 *aal5; + /* t = 3 */ + } u; +} H245NewATMVCIndication_aal; + +EXTERN int asn1PE_H245NewATMVCIndication_aal (OOCTXT* pctxt, H245NewATMVCIndication_aal* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication_aal (OOCTXT* pctxt, H245NewATMVCIndication_aal* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication_multiplex */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCIndication_multiplex_noMultiplex 1 +#define T_H245NewATMVCIndication_multiplex_transportStream 2 +#define T_H245NewATMVCIndication_multiplex_programStream 3 +#define T_H245NewATMVCIndication_multiplex_extElem1 4 + +typedef struct EXTERN H245NewATMVCIndication_multiplex { + int t; +} H245NewATMVCIndication_multiplex; + +EXTERN int asn1PE_H245NewATMVCIndication_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_multiplex* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_multiplex* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication_reverseParameters_multiplex */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245NewATMVCIndication_reverseParameters_multiplex_noMultiplex 1 +#define T_H245NewATMVCIndication_reverseParameters_multiplex_transportStream 2 +#define T_H245NewATMVCIndication_reverseParameters_multiplex_programStream 3 +#define T_H245NewATMVCIndication_reverseParameters_multiplex_extElem1 4 + +typedef struct EXTERN H245NewATMVCIndication_reverseParameters_multiplex { + int t; +} H245NewATMVCIndication_reverseParameters_multiplex; + +EXTERN int asn1PE_H245NewATMVCIndication_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters_multiplex* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters_multiplex* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication_reverseParameters */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NewATMVCIndication_reverseParameters { + ASN1USINT bitRate; + ASN1BOOL bitRateLockedToPCRClock; + ASN1BOOL bitRateLockedToNetworkClock; + H245NewATMVCIndication_reverseParameters_multiplex multiplex; +} H245NewATMVCIndication_reverseParameters; + +EXTERN int asn1PE_H245NewATMVCIndication_reverseParameters (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication_reverseParameters (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters* pvalue); + +/**************************************************************/ +/* */ +/* NewATMVCIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245NewATMVCIndication { + struct { + unsigned reverseParametersPresent : 1; + } m; + ASN1USINT resourceID; + ASN1USINT bitRate; + ASN1BOOL bitRateLockedToPCRClock; + ASN1BOOL bitRateLockedToNetworkClock; + H245NewATMVCIndication_aal aal; + H245NewATMVCIndication_multiplex multiplex; + H245NewATMVCIndication_reverseParameters reverseParameters; +} H245NewATMVCIndication; + +EXTERN int asn1PE_H245NewATMVCIndication (OOCTXT* pctxt, H245NewATMVCIndication* pvalue); + +EXTERN int asn1PD_H245NewATMVCIndication (OOCTXT* pctxt, H245NewATMVCIndication* pvalue); + +/**************************************************************/ +/* */ +/* UserInputIndication_userInputSupportIndication */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245UserInputIndication_userInputSupportIndication_nonStandard 1 +#define T_H245UserInputIndication_userInputSupportIndication_basicString 2 +#define T_H245UserInputIndication_userInputSupportIndication_iA5String 3 +#define T_H245UserInputIndication_userInputSupportIndication_generalString 4 +#define T_H245UserInputIndication_userInputSupportIndication_extElem1 5 + +typedef struct EXTERN H245UserInputIndication_userInputSupportIndication { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + /* t = 3 */ + /* t = 4 */ + /* t = 5 */ + } u; +} H245UserInputIndication_userInputSupportIndication; + +EXTERN int asn1PE_H245UserInputIndication_userInputSupportIndication (OOCTXT* pctxt, H245UserInputIndication_userInputSupportIndication* pvalue); + +EXTERN int asn1PD_H245UserInputIndication_userInputSupportIndication (OOCTXT* pctxt, H245UserInputIndication_userInputSupportIndication* pvalue); + +/**************************************************************/ +/* */ +/* UserInputIndication_signal_rtp */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UserInputIndication_signal_rtp { + struct { + unsigned timestampPresent : 1; + unsigned expirationTimePresent : 1; + } m; + ASN1UINT timestamp; + ASN1UINT expirationTime; + H245LogicalChannelNumber logicalChannelNumber; +} H245UserInputIndication_signal_rtp; + +EXTERN int asn1PE_H245UserInputIndication_signal_rtp (OOCTXT* pctxt, H245UserInputIndication_signal_rtp* pvalue); + +EXTERN int asn1PD_H245UserInputIndication_signal_rtp (OOCTXT* pctxt, H245UserInputIndication_signal_rtp* pvalue); + +/**************************************************************/ +/* */ +/* UserInputIndication_signal */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UserInputIndication_signal { + struct { + unsigned durationPresent : 1; + unsigned rtpPresent : 1; + unsigned rtpPayloadIndicationPresent : 1; + } m; + ASN1IA5String signalType; + ASN1USINT duration; + H245UserInputIndication_signal_rtp rtp; +} H245UserInputIndication_signal; + +EXTERN int asn1PE_H245UserInputIndication_signal (OOCTXT* pctxt, H245UserInputIndication_signal* pvalue); + +EXTERN int asn1PD_H245UserInputIndication_signal (OOCTXT* pctxt, H245UserInputIndication_signal* pvalue); + +/**************************************************************/ +/* */ +/* UserInputIndication_signalUpdate_rtp */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UserInputIndication_signalUpdate_rtp { + H245LogicalChannelNumber logicalChannelNumber; +} H245UserInputIndication_signalUpdate_rtp; + +EXTERN int asn1PE_H245UserInputIndication_signalUpdate_rtp (OOCTXT* pctxt, H245UserInputIndication_signalUpdate_rtp* pvalue); + +EXTERN int asn1PD_H245UserInputIndication_signalUpdate_rtp (OOCTXT* pctxt, H245UserInputIndication_signalUpdate_rtp* pvalue); + +/**************************************************************/ +/* */ +/* UserInputIndication_signalUpdate */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UserInputIndication_signalUpdate { + struct { + unsigned rtpPresent : 1; + } m; + ASN1USINT duration; + H245UserInputIndication_signalUpdate_rtp rtp; +} H245UserInputIndication_signalUpdate; + +EXTERN int asn1PE_H245UserInputIndication_signalUpdate (OOCTXT* pctxt, H245UserInputIndication_signalUpdate* pvalue); + +EXTERN int asn1PD_H245UserInputIndication_signalUpdate (OOCTXT* pctxt, H245UserInputIndication_signalUpdate* pvalue); + +/**************************************************************/ +/* */ +/* UserInputIndication_extendedAlphanumeric */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245UserInputIndication_extendedAlphanumeric { + struct { + unsigned rtpPayloadIndicationPresent : 1; + } m; + ASN1GeneralString alphanumeric; +} H245UserInputIndication_extendedAlphanumeric; + +EXTERN int asn1PE_H245UserInputIndication_extendedAlphanumeric (OOCTXT* pctxt, H245UserInputIndication_extendedAlphanumeric* pvalue); + +EXTERN int asn1PD_H245UserInputIndication_extendedAlphanumeric (OOCTXT* pctxt, H245UserInputIndication_extendedAlphanumeric* pvalue); + +/**************************************************************/ +/* */ +/* UserInputIndication */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245UserInputIndication_nonStandard 1 +#define T_H245UserInputIndication_alphanumeric 2 +#define T_H245UserInputIndication_userInputSupportIndication 3 +#define T_H245UserInputIndication_signal 4 +#define T_H245UserInputIndication_signalUpdate 5 +#define T_H245UserInputIndication_extendedAlphanumeric 6 +#define T_H245UserInputIndication_extElem1 7 + +typedef struct EXTERN H245UserInputIndication { + int t; + union { + /* t = 1 */ + H245NonStandardParameter *nonStandard; + /* t = 2 */ + ASN1GeneralString alphanumeric; + /* t = 3 */ + H245UserInputIndication_userInputSupportIndication *userInputSupportIndication; + /* t = 4 */ + H245UserInputIndication_signal *signal; + /* t = 5 */ + H245UserInputIndication_signalUpdate *signalUpdate; + /* t = 6 */ + H245UserInputIndication_extendedAlphanumeric *extendedAlphanumeric; + /* t = 7 */ + } u; +} H245UserInputIndication; + +EXTERN int asn1PE_H245UserInputIndication (OOCTXT* pctxt, H245UserInputIndication* pvalue); + +EXTERN int asn1PD_H245UserInputIndication (OOCTXT* pctxt, H245UserInputIndication* pvalue); + +/**************************************************************/ +/* */ +/* H2250MaximumSkewIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245H2250MaximumSkewIndication { + H245LogicalChannelNumber logicalChannelNumber1; + H245LogicalChannelNumber logicalChannelNumber2; + ASN1USINT maximumSkew; +} H245H2250MaximumSkewIndication; + +EXTERN int asn1PE_H245H2250MaximumSkewIndication (OOCTXT* pctxt, H245H2250MaximumSkewIndication* pvalue); + +EXTERN int asn1PD_H245H2250MaximumSkewIndication (OOCTXT* pctxt, H245H2250MaximumSkewIndication* pvalue); + +/**************************************************************/ +/* */ +/* MCLocationIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MCLocationIndication { + H245TransportAddress signalAddress; +} H245MCLocationIndication; + +EXTERN int asn1PE_H245MCLocationIndication (OOCTXT* pctxt, H245MCLocationIndication* pvalue); + +EXTERN int asn1PD_H245MCLocationIndication (OOCTXT* pctxt, H245MCLocationIndication* pvalue); + +/**************************************************************/ +/* */ +/* TerminalYouAreSeeingInSubPictureNumber */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245TerminalYouAreSeeingInSubPictureNumber { + H245TerminalNumber terminalNumber; + ASN1UINT8 subPictureNumber; +} H245TerminalYouAreSeeingInSubPictureNumber; + +EXTERN int asn1PE_H245TerminalYouAreSeeingInSubPictureNumber (OOCTXT* pctxt, H245TerminalYouAreSeeingInSubPictureNumber* pvalue); + +EXTERN int asn1PD_H245TerminalYouAreSeeingInSubPictureNumber (OOCTXT* pctxt, H245TerminalYouAreSeeingInSubPictureNumber* pvalue); + +/**************************************************************/ +/* */ +/* VideoIndicateCompose */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VideoIndicateCompose { + ASN1UINT8 compositionNumber; +} H245VideoIndicateCompose; + +EXTERN int asn1PE_H245VideoIndicateCompose (OOCTXT* pctxt, H245VideoIndicateCompose* pvalue); + +EXTERN int asn1PD_H245VideoIndicateCompose (OOCTXT* pctxt, H245VideoIndicateCompose* pvalue); + +/**************************************************************/ +/* */ +/* ConferenceIndication */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245ConferenceIndication_sbeNumber 1 +#define T_H245ConferenceIndication_terminalNumberAssign 2 +#define T_H245ConferenceIndication_terminalJoinedConference 3 +#define T_H245ConferenceIndication_terminalLeftConference 4 +#define T_H245ConferenceIndication_seenByAtLeastOneOther 5 +#define T_H245ConferenceIndication_cancelSeenByAtLeastOneOther 6 +#define T_H245ConferenceIndication_seenByAll 7 +#define T_H245ConferenceIndication_cancelSeenByAll 8 +#define T_H245ConferenceIndication_terminalYouAreSeeing 9 +#define T_H245ConferenceIndication_requestForFloor 10 +#define T_H245ConferenceIndication_withdrawChairToken 11 +#define T_H245ConferenceIndication_floorRequested 12 +#define T_H245ConferenceIndication_terminalYouAreSeeingInSubPictureNumber 13 +#define T_H245ConferenceIndication_videoIndicateCompose 14 +#define T_H245ConferenceIndication_extElem1 15 + +typedef struct EXTERN H245ConferenceIndication { + int t; + union { + /* t = 1 */ + ASN1UINT8 sbeNumber; + /* t = 2 */ + H245TerminalLabel *terminalNumberAssign; + /* t = 3 */ + H245TerminalLabel *terminalJoinedConference; + /* t = 4 */ + H245TerminalLabel *terminalLeftConference; + /* t = 5 */ + /* t = 6 */ + /* t = 7 */ + /* t = 8 */ + /* t = 9 */ + H245TerminalLabel *terminalYouAreSeeing; + /* t = 10 */ + /* t = 11 */ + /* t = 12 */ + H245TerminalLabel *floorRequested; + /* t = 13 */ + H245TerminalYouAreSeeingInSubPictureNumber *terminalYouAreSeeingInSubPictureNumber; + /* t = 14 */ + H245VideoIndicateCompose *videoIndicateCompose; + /* t = 15 */ + } u; +} H245ConferenceIndication; + +EXTERN int asn1PE_H245ConferenceIndication (OOCTXT* pctxt, H245ConferenceIndication* pvalue); + +EXTERN int asn1PD_H245ConferenceIndication (OOCTXT* pctxt, H245ConferenceIndication* pvalue); + +/**************************************************************/ +/* */ +/* VendorIdentification_productNumber */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VendorIdentification_productNumber { + ASN1UINT numocts; + ASN1OCTET data[256]; +} H245VendorIdentification_productNumber; + +EXTERN int asn1PE_H245VendorIdentification_productNumber (OOCTXT* pctxt, H245VendorIdentification_productNumber* pvalue); + +EXTERN int asn1PD_H245VendorIdentification_productNumber (OOCTXT* pctxt, H245VendorIdentification_productNumber* pvalue); + +/**************************************************************/ +/* */ +/* VendorIdentification_versionNumber */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VendorIdentification_versionNumber { + ASN1UINT numocts; + ASN1OCTET data[256]; +} H245VendorIdentification_versionNumber; + +EXTERN int asn1PE_H245VendorIdentification_versionNumber (OOCTXT* pctxt, H245VendorIdentification_versionNumber* pvalue); + +EXTERN int asn1PD_H245VendorIdentification_versionNumber (OOCTXT* pctxt, H245VendorIdentification_versionNumber* pvalue); + +/**************************************************************/ +/* */ +/* VendorIdentification */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245VendorIdentification { + struct { + unsigned productNumberPresent : 1; + unsigned versionNumberPresent : 1; + } m; + H245NonStandardIdentifier vendor; + H245VendorIdentification_productNumber productNumber; + H245VendorIdentification_versionNumber versionNumber; +} H245VendorIdentification; + +EXTERN int asn1PE_H245VendorIdentification (OOCTXT* pctxt, H245VendorIdentification* pvalue); + +EXTERN int asn1PD_H245VendorIdentification (OOCTXT* pctxt, H245VendorIdentification* pvalue); + +/**************************************************************/ +/* */ +/* FunctionNotSupported_cause */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FunctionNotSupported_cause_syntaxError 1 +#define T_H245FunctionNotSupported_cause_semanticError 2 +#define T_H245FunctionNotSupported_cause_unknownFunction 3 +#define T_H245FunctionNotSupported_cause_extElem1 4 + +typedef struct EXTERN H245FunctionNotSupported_cause { + int t; +} H245FunctionNotSupported_cause; + +EXTERN int asn1PE_H245FunctionNotSupported_cause (OOCTXT* pctxt, H245FunctionNotSupported_cause* pvalue); + +EXTERN int asn1PD_H245FunctionNotSupported_cause (OOCTXT* pctxt, H245FunctionNotSupported_cause* pvalue); + +/**************************************************************/ +/* */ +/* FunctionNotSupported */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FunctionNotSupported { + struct { + unsigned returnedFunctionPresent : 1; + } m; + H245FunctionNotSupported_cause cause; + ASN1DynOctStr returnedFunction; +} H245FunctionNotSupported; + +EXTERN int asn1PE_H245FunctionNotSupported (OOCTXT* pctxt, H245FunctionNotSupported* pvalue); + +EXTERN int asn1PD_H245FunctionNotSupported (OOCTXT* pctxt, H245FunctionNotSupported* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkIndication_crcDesired */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkIndication_crcDesired { + ASN1OCTET __dummy__; +} H245MultilinkIndication_crcDesired; + +EXTERN int asn1PE_H245MultilinkIndication_crcDesired (OOCTXT* pctxt, H245MultilinkIndication_crcDesired* pvalue); + +EXTERN int asn1PD_H245MultilinkIndication_crcDesired (OOCTXT* pctxt, H245MultilinkIndication_crcDesired* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkIndication_excessiveError */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MultilinkIndication_excessiveError { + H245ConnectionIdentifier connectionIdentifier; +} H245MultilinkIndication_excessiveError; + +EXTERN int asn1PE_H245MultilinkIndication_excessiveError (OOCTXT* pctxt, H245MultilinkIndication_excessiveError* pvalue); + +EXTERN int asn1PD_H245MultilinkIndication_excessiveError (OOCTXT* pctxt, H245MultilinkIndication_excessiveError* pvalue); + +/**************************************************************/ +/* */ +/* MultilinkIndication */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultilinkIndication_nonStandard 1 +#define T_H245MultilinkIndication_crcDesired 2 +#define T_H245MultilinkIndication_excessiveError 3 +#define T_H245MultilinkIndication_extElem1 4 + +typedef struct EXTERN H245MultilinkIndication { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + H245MultilinkIndication_crcDesired *crcDesired; + /* t = 3 */ + H245MultilinkIndication_excessiveError *excessiveError; + /* t = 4 */ + } u; +} H245MultilinkIndication; + +EXTERN int asn1PE_H245MultilinkIndication (OOCTXT* pctxt, H245MultilinkIndication* pvalue); + +EXTERN int asn1PD_H245MultilinkIndication (OOCTXT* pctxt, H245MultilinkIndication* pvalue); + +/**************************************************************/ +/* */ +/* LogicalChannelRateRelease */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245LogicalChannelRateRelease { + ASN1OCTET __dummy__; +} H245LogicalChannelRateRelease; + +EXTERN int asn1PE_H245LogicalChannelRateRelease (OOCTXT* pctxt, H245LogicalChannelRateRelease* pvalue); + +EXTERN int asn1PD_H245LogicalChannelRateRelease (OOCTXT* pctxt, H245LogicalChannelRateRelease* pvalue); + +/**************************************************************/ +/* */ +/* FlowControlIndication_scope */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FlowControlIndication_scope_logicalChannelNumber 1 +#define T_H245FlowControlIndication_scope_resourceID 2 +#define T_H245FlowControlIndication_scope_wholeMultiplex 3 + +typedef struct EXTERN H245FlowControlIndication_scope { + int t; + union { + /* t = 1 */ + H245LogicalChannelNumber logicalChannelNumber; + /* t = 2 */ + ASN1USINT resourceID; + /* t = 3 */ + } u; +} H245FlowControlIndication_scope; + +EXTERN int asn1PE_H245FlowControlIndication_scope (OOCTXT* pctxt, H245FlowControlIndication_scope* pvalue); + +EXTERN int asn1PD_H245FlowControlIndication_scope (OOCTXT* pctxt, H245FlowControlIndication_scope* pvalue); + +/**************************************************************/ +/* */ +/* FlowControlIndication_restriction */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245FlowControlIndication_restriction_maximumBitRate 1 +#define T_H245FlowControlIndication_restriction_noRestriction 2 + +typedef struct EXTERN H245FlowControlIndication_restriction { + int t; + union { + /* t = 1 */ + ASN1UINT maximumBitRate; + /* t = 2 */ + } u; +} H245FlowControlIndication_restriction; + +EXTERN int asn1PE_H245FlowControlIndication_restriction (OOCTXT* pctxt, H245FlowControlIndication_restriction* pvalue); + +EXTERN int asn1PD_H245FlowControlIndication_restriction (OOCTXT* pctxt, H245FlowControlIndication_restriction* pvalue); + +/**************************************************************/ +/* */ +/* FlowControlIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245FlowControlIndication { + H245FlowControlIndication_scope scope; + H245FlowControlIndication_restriction restriction; +} H245FlowControlIndication; + +EXTERN int asn1PE_H245FlowControlIndication (OOCTXT* pctxt, H245FlowControlIndication* pvalue); + +EXTERN int asn1PD_H245FlowControlIndication (OOCTXT* pctxt, H245FlowControlIndication* pvalue); + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationIndication */ +/* */ +/**************************************************************/ + +typedef struct EXTERN H245MobileMultilinkReconfigurationIndication { + ASN1UINT8 sampleSize; + ASN1UINT8 samplesPerFrame; +} H245MobileMultilinkReconfigurationIndication; + +EXTERN int asn1PE_H245MobileMultilinkReconfigurationIndication (OOCTXT* pctxt, H245MobileMultilinkReconfigurationIndication* pvalue); + +EXTERN int asn1PD_H245MobileMultilinkReconfigurationIndication (OOCTXT* pctxt, H245MobileMultilinkReconfigurationIndication* pvalue); + +/**************************************************************/ +/* */ +/* IndicationMessage */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245IndicationMessage_nonStandard 1 +#define T_H245IndicationMessage_functionNotUnderstood 2 +#define T_H245IndicationMessage_masterSlaveDeterminationRelease 3 +#define T_H245IndicationMessage_terminalCapabilitySetRelease 4 +#define T_H245IndicationMessage_openLogicalChannelConfirm 5 +#define T_H245IndicationMessage_requestChannelCloseRelease 6 +#define T_H245IndicationMessage_multiplexEntrySendRelease 7 +#define T_H245IndicationMessage_requestMultiplexEntryRelease 8 +#define T_H245IndicationMessage_requestModeRelease 9 +#define T_H245IndicationMessage_miscellaneousIndication 10 +#define T_H245IndicationMessage_jitterIndication 11 +#define T_H245IndicationMessage_h223SkewIndication 12 +#define T_H245IndicationMessage_newATMVCIndication 13 +#define T_H245IndicationMessage_userInput 14 +#define T_H245IndicationMessage_h2250MaximumSkewIndication 15 +#define T_H245IndicationMessage_mcLocationIndication 16 +#define T_H245IndicationMessage_conferenceIndication 17 +#define T_H245IndicationMessage_vendorIdentification 18 +#define T_H245IndicationMessage_functionNotSupported 19 +#define T_H245IndicationMessage_multilinkIndication 20 +#define T_H245IndicationMessage_logicalChannelRateRelease 21 +#define T_H245IndicationMessage_flowControlIndication 22 +#define T_H245IndicationMessage_mobileMultilinkReconfigurationIndication 23 +#define T_H245IndicationMessage_extElem1 24 + +typedef struct EXTERN H245IndicationMessage { + int t; + union { + /* t = 1 */ + H245NonStandardMessage *nonStandard; + /* t = 2 */ + H245FunctionNotUnderstood *functionNotUnderstood; + /* t = 3 */ + H245MasterSlaveDeterminationRelease *masterSlaveDeterminationRelease; + /* t = 4 */ + H245TerminalCapabilitySetRelease *terminalCapabilitySetRelease; + /* t = 5 */ + H245OpenLogicalChannelConfirm *openLogicalChannelConfirm; + /* t = 6 */ + H245RequestChannelCloseRelease *requestChannelCloseRelease; + /* t = 7 */ + H245MultiplexEntrySendRelease *multiplexEntrySendRelease; + /* t = 8 */ + H245RequestMultiplexEntryRelease *requestMultiplexEntryRelease; + /* t = 9 */ + H245RequestModeRelease *requestModeRelease; + /* t = 10 */ + H245MiscellaneousIndication *miscellaneousIndication; + /* t = 11 */ + H245JitterIndication *jitterIndication; + /* t = 12 */ + H245H223SkewIndication *h223SkewIndication; + /* t = 13 */ + H245NewATMVCIndication *newATMVCIndication; + /* t = 14 */ + H245UserInputIndication *userInput; + /* t = 15 */ + H245H2250MaximumSkewIndication *h2250MaximumSkewIndication; + /* t = 16 */ + H245MCLocationIndication *mcLocationIndication; + /* t = 17 */ + H245ConferenceIndication *conferenceIndication; + /* t = 18 */ + H245VendorIdentification *vendorIdentification; + /* t = 19 */ + H245FunctionNotSupported *functionNotSupported; + /* t = 20 */ + H245MultilinkIndication *multilinkIndication; + /* t = 21 */ + H245LogicalChannelRateRelease *logicalChannelRateRelease; + /* t = 22 */ + H245FlowControlIndication *flowControlIndication; + /* t = 23 */ + H245MobileMultilinkReconfigurationIndication *mobileMultilinkReconfigurationIndication; + /* t = 24 */ + } u; +} H245IndicationMessage; + +EXTERN int asn1PE_H245IndicationMessage (OOCTXT* pctxt, H245IndicationMessage* pvalue); + +EXTERN int asn1PD_H245IndicationMessage (OOCTXT* pctxt, H245IndicationMessage* pvalue); + +/**************************************************************/ +/* */ +/* MultimediaSystemControlMessage */ +/* */ +/**************************************************************/ + +/* Choice tag constants */ + +#define T_H245MultimediaSystemControlMessage_request 1 +#define T_H245MultimediaSystemControlMessage_response 2 +#define T_H245MultimediaSystemControlMessage_command 3 +#define T_H245MultimediaSystemControlMessage_indication 4 +#define T_H245MultimediaSystemControlMessage_extElem1 5 + +typedef struct EXTERN H245MultimediaSystemControlMessage { + int t; + union { + /* t = 1 */ + H245RequestMessage *request; + /* t = 2 */ + H245ResponseMessage *response; + /* t = 3 */ + H245CommandMessage *command; + /* t = 4 */ + H245IndicationMessage *indication; + /* t = 5 */ + } u; +} H245MultimediaSystemControlMessage; + +EXTERN int asn1PE_H245MultimediaSystemControlMessage (OOCTXT* pctxt, H245MultimediaSystemControlMessage* pvalue); + +EXTERN int asn1PD_H245MultimediaSystemControlMessage (OOCTXT* pctxt, H245MultimediaSystemControlMessage* pvalue); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c new file mode 100644 index 000000000..0ec58a82e --- /dev/null +++ b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLDec.c @@ -0,0 +1,42170 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#include "ooasn1.h" +#include "MULTIMEDIA-SYSTEM-CONTROL.h" +#include "eventHandler.h" + +/**************************************************************/ +/* */ +/* NonStandardIdentifier_h221NonStandard */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue) +{ + int stat = ASN_OK; + + /* 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); + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + 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, H245NonStandardIdentifier_h221NonStandard); + + stat = asn1PD_H245NonStandardIdentifier_h221NonStandard (pctxt, pvalue->u.h221NonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h221NonStandard", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue) +{ + int stat = ASN_OK; + + /* decode nonStandardIdentifier */ + + invokeStartElement (pctxt, "nonStandardIdentifier", -1); + + stat = asn1PD_H245NonStandardIdentifier (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); +} + +/**************************************************************/ +/* */ +/* V42bis */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode numberOfCodewords */ + + invokeStartElement (pctxt, "numberOfCodewords", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->numberOfCodewords, 1U, 65536U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfCodewords); + + invokeEndElement (pctxt, "numberOfCodewords", -1); + + /* decode maximumStringLength */ + + invokeStartElement (pctxt, "maximumStringLength", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumStringLength, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumStringLength); + + invokeEndElement (pctxt, "maximumStringLength", -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); +} + +/**************************************************************/ +/* */ +/* CompressionType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* v42bis */ + case 0: + invokeStartElement (pctxt, "v42bis", -1); + + pvalue->u.v42bis = ALLOC_ASN1ELEM (pctxt, H245V42bis); + + stat = asn1PD_H245V42bis (pctxt, pvalue->u.v42bis); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "v42bis", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataProtocolCapability_v76wCompression */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* transmitCompression */ + case 0: + invokeStartElement (pctxt, "transmitCompression", -1); + + pvalue->u.transmitCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType); + + stat = asn1PD_H245CompressionType (pctxt, pvalue->u.transmitCompression); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transmitCompression", -1); + + break; + + /* receiveCompression */ + case 1: + invokeStartElement (pctxt, "receiveCompression", -1); + + pvalue->u.receiveCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType); + + stat = asn1PD_H245CompressionType (pctxt, pvalue->u.receiveCompression); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveCompression", -1); + + break; + + /* transmitAndReceiveCompression */ + case 2: + invokeStartElement (pctxt, "transmitAndReceiveCompression", -1); + + pvalue->u.transmitAndReceiveCompression = ALLOC_ASN1ELEM (pctxt, H245CompressionType); + + stat = asn1PD_H245CompressionType (pctxt, pvalue->u.transmitAndReceiveCompression); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transmitAndReceiveCompression", -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); +} + +/**************************************************************/ +/* */ +/* DataProtocolCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* v14buffered */ + case 1: + invokeStartElement (pctxt, "v14buffered", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "v14buffered", -1); + + break; + + /* v42lapm */ + case 2: + invokeStartElement (pctxt, "v42lapm", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "v42lapm", -1); + + break; + + /* hdlcFrameTunnelling */ + case 3: + invokeStartElement (pctxt, "hdlcFrameTunnelling", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "hdlcFrameTunnelling", -1); + + break; + + /* h310SeparateVCStack */ + case 4: + invokeStartElement (pctxt, "h310SeparateVCStack", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "h310SeparateVCStack", -1); + + break; + + /* h310SingleVCStack */ + case 5: + invokeStartElement (pctxt, "h310SingleVCStack", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "h310SingleVCStack", -1); + + break; + + /* transparent */ + case 6: + invokeStartElement (pctxt, "transparent", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "transparent", -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) { + /* segmentationAndReassembly */ + case 8: + invokeStartElement (pctxt, "segmentationAndReassembly", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "segmentationAndReassembly", -1); + + break; + + /* hdlcFrameTunnelingwSAR */ + case 9: + invokeStartElement (pctxt, "hdlcFrameTunnelingwSAR", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "hdlcFrameTunnelingwSAR", -1); + + break; + + /* v120 */ + case 10: + invokeStartElement (pctxt, "v120", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "v120", -1); + + break; + + /* separateLANStack */ + case 11: + invokeStartElement (pctxt, "separateLANStack", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "separateLANStack", -1); + + break; + + /* v76wCompression */ + case 12: + invokeStartElement (pctxt, "v76wCompression", -1); + + pvalue->u.v76wCompression = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability_v76wCompression); + + stat = asn1PD_H245DataProtocolCapability_v76wCompression (pctxt, pvalue->u.v76wCompression); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "v76wCompression", -1); + + break; + + /* tcp */ + case 13: + invokeStartElement (pctxt, "tcp", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "tcp", -1); + + break; + + /* udp */ + case 14: + invokeStartElement (pctxt, "udp", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "udp", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* T38FaxRateManagement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* localTCF */ + case 0: + invokeStartElement (pctxt, "localTCF", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "localTCF", -1); + + break; + + /* transferredTCF */ + case 1: + invokeStartElement (pctxt, "transferredTCF", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "transferredTCF", -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); +} + +/**************************************************************/ +/* */ +/* T38FaxUdpOptions_t38FaxUdpEC */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* t38UDPFEC */ + case 0: + invokeStartElement (pctxt, "t38UDPFEC", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "t38UDPFEC", -1); + + break; + + /* t38UDPRedundancy */ + case 1: + invokeStartElement (pctxt, "t38UDPRedundancy", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "t38UDPRedundancy", -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); +} + +/**************************************************************/ +/* */ +/* T38FaxUdpOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL optbit; + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.t38FaxMaxBufferPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.t38FaxMaxDatagramPresent = optbit; + + /* decode t38FaxMaxBuffer */ + + if (pvalue->m.t38FaxMaxBufferPresent) { + invokeStartElement (pctxt, "t38FaxMaxBuffer", -1); + + stat = decodeUnconsInteger (pctxt, &pvalue->t38FaxMaxBuffer); + if (stat != ASN_OK) return stat; + invokeIntValue (pctxt, pvalue->t38FaxMaxBuffer); + + invokeEndElement (pctxt, "t38FaxMaxBuffer", -1); + } + + /* decode t38FaxMaxDatagram */ + + if (pvalue->m.t38FaxMaxDatagramPresent) { + invokeStartElement (pctxt, "t38FaxMaxDatagram", -1); + + stat = decodeUnconsInteger (pctxt, &pvalue->t38FaxMaxDatagram); + if (stat != ASN_OK) return stat; + invokeIntValue (pctxt, pvalue->t38FaxMaxDatagram); + + invokeEndElement (pctxt, "t38FaxMaxDatagram", -1); + } + + /* decode t38FaxUdpEC */ + + invokeStartElement (pctxt, "t38FaxUdpEC", -1); + + stat = asn1PD_H245T38FaxUdpOptions_t38FaxUdpEC (pctxt, &pvalue->t38FaxUdpEC); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t38FaxUdpEC", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* T38FaxTcpOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode t38TCPBidirectionalMode */ + + invokeStartElement (pctxt, "t38TCPBidirectionalMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->t38TCPBidirectionalMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->t38TCPBidirectionalMode); + + invokeEndElement (pctxt, "t38TCPBidirectionalMode", -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); +} + +/**************************************************************/ +/* */ +/* T38FaxProfile */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode fillBitRemoval */ + + invokeStartElement (pctxt, "fillBitRemoval", -1); + + stat = DECODEBIT (pctxt, &pvalue->fillBitRemoval); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fillBitRemoval); + + invokeEndElement (pctxt, "fillBitRemoval", -1); + + /* decode transcodingJBIG */ + + invokeStartElement (pctxt, "transcodingJBIG", -1); + + stat = DECODEBIT (pctxt, &pvalue->transcodingJBIG); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->transcodingJBIG); + + invokeEndElement (pctxt, "transcodingJBIG", -1); + + /* decode transcodingMMR */ + + invokeStartElement (pctxt, "transcodingMMR", -1); + + stat = DECODEBIT (pctxt, &pvalue->transcodingMMR); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->transcodingMMR); + + invokeEndElement (pctxt, "transcodingMMR", -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.versionPresent = 1; + + invokeStartElement (pctxt, "version", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->version, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->version); + + invokeEndElement (pctxt, "version", -1); + break; + + case 1: + pvalue->m.t38FaxRateManagementPresent = 1; + + invokeStartElement (pctxt, "t38FaxRateManagement", -1); + + stat = asn1PD_H245T38FaxRateManagement (pctxt, &pvalue->t38FaxRateManagement); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t38FaxRateManagement", -1); + break; + + case 2: + pvalue->m.t38FaxUdpOptionsPresent = 1; + + invokeStartElement (pctxt, "t38FaxUdpOptions", -1); + + stat = asn1PD_H245T38FaxUdpOptions (pctxt, &pvalue->t38FaxUdpOptions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t38FaxUdpOptions", -1); + break; + + case 3: + pvalue->m.t38FaxTcpOptionsPresent = 1; + + invokeStartElement (pctxt, "t38FaxTcpOptions", -1); + + stat = asn1PD_H245T38FaxTcpOptions (pctxt, &pvalue->t38FaxTcpOptions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t38FaxTcpOptions", -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_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode nonStandardData */ + + invokeStartElement (pctxt, "nonStandardData", -1); + + stat = asn1PD_H245NonStandardParameter (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); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDetermination */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalType */ + + invokeStartElement (pctxt, "terminalType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->terminalType, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->terminalType); + + invokeEndElement (pctxt, "terminalType", -1); + + /* decode statusDeterminationNumber */ + + invokeStartElement (pctxt, "statusDeterminationNumber", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->statusDeterminationNumber, 0U, 16777215U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->statusDeterminationNumber); + + invokeEndElement (pctxt, "statusDeterminationNumber", -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); +} + +/**************************************************************/ +/* */ +/* SequenceNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUInt8 (pctxt, pvalue, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_aal1 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode nullClockRecovery */ + + invokeStartElement (pctxt, "nullClockRecovery", -1); + + stat = DECODEBIT (pctxt, &pvalue->nullClockRecovery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->nullClockRecovery); + + invokeEndElement (pctxt, "nullClockRecovery", -1); + + /* decode srtsClockRecovery */ + + invokeStartElement (pctxt, "srtsClockRecovery", -1); + + stat = DECODEBIT (pctxt, &pvalue->srtsClockRecovery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->srtsClockRecovery); + + invokeEndElement (pctxt, "srtsClockRecovery", -1); + + /* decode adaptiveClockRecovery */ + + invokeStartElement (pctxt, "adaptiveClockRecovery", -1); + + stat = DECODEBIT (pctxt, &pvalue->adaptiveClockRecovery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->adaptiveClockRecovery); + + invokeEndElement (pctxt, "adaptiveClockRecovery", -1); + + /* decode nullErrorCorrection */ + + invokeStartElement (pctxt, "nullErrorCorrection", -1); + + stat = DECODEBIT (pctxt, &pvalue->nullErrorCorrection); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->nullErrorCorrection); + + invokeEndElement (pctxt, "nullErrorCorrection", -1); + + /* decode longInterleaver */ + + invokeStartElement (pctxt, "longInterleaver", -1); + + stat = DECODEBIT (pctxt, &pvalue->longInterleaver); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->longInterleaver); + + invokeEndElement (pctxt, "longInterleaver", -1); + + /* decode shortInterleaver */ + + invokeStartElement (pctxt, "shortInterleaver", -1); + + stat = DECODEBIT (pctxt, &pvalue->shortInterleaver); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->shortInterleaver); + + invokeEndElement (pctxt, "shortInterleaver", -1); + + /* decode errorCorrectionOnly */ + + invokeStartElement (pctxt, "errorCorrectionOnly", -1); + + stat = DECODEBIT (pctxt, &pvalue->errorCorrectionOnly); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->errorCorrectionOnly); + + invokeEndElement (pctxt, "errorCorrectionOnly", -1); + + /* decode structuredDataTransfer */ + + invokeStartElement (pctxt, "structuredDataTransfer", -1); + + stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->structuredDataTransfer); + + invokeEndElement (pctxt, "structuredDataTransfer", -1); + + /* decode partiallyFilledCells */ + + invokeStartElement (pctxt, "partiallyFilledCells", -1); + + stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->partiallyFilledCells); + + invokeEndElement (pctxt, "partiallyFilledCells", -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); +} + +/**************************************************************/ +/* */ +/* VCCapability_aal5 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardMaximumSDUSize */ + + invokeStartElement (pctxt, "forwardMaximumSDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->forwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->forwardMaximumSDUSize); + + invokeEndElement (pctxt, "forwardMaximumSDUSize", -1); + + /* decode backwardMaximumSDUSize */ + + invokeStartElement (pctxt, "backwardMaximumSDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->backwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->backwardMaximumSDUSize); + + invokeEndElement (pctxt, "backwardMaximumSDUSize", -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); +} + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates_type_rangeOfBitRates */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue) +{ + int stat = ASN_OK; + + /* decode lowerBitRate */ + + invokeStartElement (pctxt, "lowerBitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->lowerBitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->lowerBitRate); + + invokeEndElement (pctxt, "lowerBitRate", -1); + + /* decode higherBitRate */ + + invokeStartElement (pctxt, "higherBitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->higherBitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->higherBitRate); + + invokeEndElement (pctxt, "higherBitRate", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* singleBitRate */ + case 0: + invokeStartElement (pctxt, "singleBitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.singleBitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.singleBitRate); + + invokeEndElement (pctxt, "singleBitRate", -1); + + break; + + /* rangeOfBitRates */ + case 1: + invokeStartElement (pctxt, "rangeOfBitRates", -1); + + pvalue->u.rangeOfBitRates = ALLOC_ASN1ELEM (pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates); + + stat = asn1PD_H245VCCapability_availableBitRates_type_rangeOfBitRates (pctxt, pvalue->u.rangeOfBitRates); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rangeOfBitRates", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245VCCapability_availableBitRates_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* Q2931Address_address_nsapAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* 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); +} + +/**************************************************************/ +/* */ +/* Q2931Address_address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue) +{ + static Asn1SizeCnst internationalNumber_lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* internationalNumber */ + case 0: + invokeStartElement (pctxt, "internationalNumber", -1); + + addSizeConstraint (pctxt, &internationalNumber_lsize1); + + stat = decodeConstrainedStringEx (pctxt, &pvalue->u.internationalNumber, NUM_CANSET, 4, 4, 4); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->u.internationalNumber); + + invokeEndElement (pctxt, "internationalNumber", -1); + + break; + + /* nsapAddress */ + case 1: + invokeStartElement (pctxt, "nsapAddress", -1); + + pvalue->u.nsapAddress = ALLOC_ASN1ELEM (pctxt, H245Q2931Address_address_nsapAddress); + + stat = asn1PD_H245Q2931Address_address_nsapAddress (pctxt, pvalue->u.nsapAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nsapAddress", -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); +} + +/**************************************************************/ +/* */ +/* Q2931Address_subaddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* 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); +} + +/**************************************************************/ +/* */ +/* Q2931Address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.subaddressPresent = optbit; + + /* decode address */ + + invokeStartElement (pctxt, "address", -1); + + stat = asn1PD_H245Q2931Address_address (pctxt, &pvalue->address); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "address", -1); + + /* decode subaddress */ + + if (pvalue->m.subaddressPresent) { + invokeStartElement (pctxt, "subaddress", -1); + + stat = asn1PD_H245Q2931Address_subaddress (pctxt, &pvalue->subaddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "subaddress", -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); +} + +/**************************************************************/ +/* */ +/* VCCapability_aal1ViaGateway_gatewayAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245Q2931Address* 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, H245Q2931Address); + + stat = asn1PD_H245Q2931Address (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_aal1ViaGateway */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode gatewayAddress */ + + invokeStartElement (pctxt, "gatewayAddress", -1); + + stat = asn1PD_H245VCCapability_aal1ViaGateway_gatewayAddress (pctxt, &pvalue->gatewayAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "gatewayAddress", -1); + + /* decode nullClockRecovery */ + + invokeStartElement (pctxt, "nullClockRecovery", -1); + + stat = DECODEBIT (pctxt, &pvalue->nullClockRecovery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->nullClockRecovery); + + invokeEndElement (pctxt, "nullClockRecovery", -1); + + /* decode srtsClockRecovery */ + + invokeStartElement (pctxt, "srtsClockRecovery", -1); + + stat = DECODEBIT (pctxt, &pvalue->srtsClockRecovery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->srtsClockRecovery); + + invokeEndElement (pctxt, "srtsClockRecovery", -1); + + /* decode adaptiveClockRecovery */ + + invokeStartElement (pctxt, "adaptiveClockRecovery", -1); + + stat = DECODEBIT (pctxt, &pvalue->adaptiveClockRecovery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->adaptiveClockRecovery); + + invokeEndElement (pctxt, "adaptiveClockRecovery", -1); + + /* decode nullErrorCorrection */ + + invokeStartElement (pctxt, "nullErrorCorrection", -1); + + stat = DECODEBIT (pctxt, &pvalue->nullErrorCorrection); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->nullErrorCorrection); + + invokeEndElement (pctxt, "nullErrorCorrection", -1); + + /* decode longInterleaver */ + + invokeStartElement (pctxt, "longInterleaver", -1); + + stat = DECODEBIT (pctxt, &pvalue->longInterleaver); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->longInterleaver); + + invokeEndElement (pctxt, "longInterleaver", -1); + + /* decode shortInterleaver */ + + invokeStartElement (pctxt, "shortInterleaver", -1); + + stat = DECODEBIT (pctxt, &pvalue->shortInterleaver); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->shortInterleaver); + + invokeEndElement (pctxt, "shortInterleaver", -1); + + /* decode errorCorrectionOnly */ + + invokeStartElement (pctxt, "errorCorrectionOnly", -1); + + stat = DECODEBIT (pctxt, &pvalue->errorCorrectionOnly); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->errorCorrectionOnly); + + invokeEndElement (pctxt, "errorCorrectionOnly", -1); + + /* decode structuredDataTransfer */ + + invokeStartElement (pctxt, "structuredDataTransfer", -1); + + stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->structuredDataTransfer); + + invokeEndElement (pctxt, "structuredDataTransfer", -1); + + /* decode partiallyFilledCells */ + + invokeStartElement (pctxt, "partiallyFilledCells", -1); + + stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->partiallyFilledCells); + + invokeEndElement (pctxt, "partiallyFilledCells", -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); +} + +/**************************************************************/ +/* */ +/* VCCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.aal1Present = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.aal5Present = optbit; + + /* decode aal1 */ + + if (pvalue->m.aal1Present) { + invokeStartElement (pctxt, "aal1", -1); + + stat = asn1PD_H245VCCapability_aal1 (pctxt, &pvalue->aal1); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal1", -1); + } + + /* decode aal5 */ + + if (pvalue->m.aal5Present) { + invokeStartElement (pctxt, "aal5", -1); + + stat = asn1PD_H245VCCapability_aal5 (pctxt, &pvalue->aal5); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal5", -1); + } + + /* decode transportStream */ + + invokeStartElement (pctxt, "transportStream", -1); + + stat = DECODEBIT (pctxt, &pvalue->transportStream); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->transportStream); + + invokeEndElement (pctxt, "transportStream", -1); + + /* decode programStream */ + + invokeStartElement (pctxt, "programStream", -1); + + stat = DECODEBIT (pctxt, &pvalue->programStream); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->programStream); + + invokeEndElement (pctxt, "programStream", -1); + + /* decode availableBitRates */ + + invokeStartElement (pctxt, "availableBitRates", -1); + + stat = asn1PD_H245VCCapability_availableBitRates (pctxt, &pvalue->availableBitRates); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "availableBitRates", -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.aal1ViaGatewayPresent = 1; + + invokeStartElement (pctxt, "aal1ViaGateway", -1); + + stat = asn1PD_H245VCCapability_aal1ViaGateway (pctxt, &pvalue->aal1ViaGateway); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal1ViaGateway", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SetOfH245VCCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue) +{ + int stat = ASN_OK; + H245VCCapability* 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, H245VCCapability); + + stat = asn1PD_H245VCCapability (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H222Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode numberOfVCs */ + + invokeStartElement (pctxt, "numberOfVCs", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->numberOfVCs, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfVCs); + + invokeEndElement (pctxt, "numberOfVCs", -1); + + /* decode vcCapability */ + + invokeStartElement (pctxt, "vcCapability", -1); + + stat = asn1PD_H245_SetOfH245VCCapability (pctxt, &pvalue->vcCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "vcCapability", -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); +} + +/**************************************************************/ +/* */ +/* H223Capability_h223MultiplexTableCapability_enhanced */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode maximumNestingDepth */ + + invokeStartElement (pctxt, "maximumNestingDepth", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->maximumNestingDepth, 1U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumNestingDepth); + + invokeEndElement (pctxt, "maximumNestingDepth", -1); + + /* decode maximumElementListSize */ + + invokeStartElement (pctxt, "maximumElementListSize", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->maximumElementListSize, 2U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumElementListSize); + + invokeEndElement (pctxt, "maximumElementListSize", -1); + + /* decode maximumSubElementListSize */ + + invokeStartElement (pctxt, "maximumSubElementListSize", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->maximumSubElementListSize, 2U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumSubElementListSize); + + invokeEndElement (pctxt, "maximumSubElementListSize", -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); +} + +/**************************************************************/ +/* */ +/* H223Capability_h223MultiplexTableCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* basic */ + case 0: + invokeStartElement (pctxt, "basic", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "basic", -1); + + break; + + /* enhanced */ + case 1: + invokeStartElement (pctxt, "enhanced", -1); + + pvalue->u.enhanced = ALLOC_ASN1ELEM (pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced); + + stat = asn1PD_H245H223Capability_h223MultiplexTableCapability_enhanced (pctxt, pvalue->u.enhanced); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "enhanced", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223Capability_mobileOperationTransmitCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode modeChangeCapability */ + + invokeStartElement (pctxt, "modeChangeCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->modeChangeCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->modeChangeCapability); + + invokeEndElement (pctxt, "modeChangeCapability", -1); + + /* decode h223AnnexA */ + + invokeStartElement (pctxt, "h223AnnexA", -1); + + stat = DECODEBIT (pctxt, &pvalue->h223AnnexA); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->h223AnnexA); + + invokeEndElement (pctxt, "h223AnnexA", -1); + + /* decode h223AnnexADoubleFlag */ + + invokeStartElement (pctxt, "h223AnnexADoubleFlag", -1); + + stat = DECODEBIT (pctxt, &pvalue->h223AnnexADoubleFlag); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->h223AnnexADoubleFlag); + + invokeEndElement (pctxt, "h223AnnexADoubleFlag", -1); + + /* decode h223AnnexB */ + + invokeStartElement (pctxt, "h223AnnexB", -1); + + stat = DECODEBIT (pctxt, &pvalue->h223AnnexB); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->h223AnnexB); + + invokeEndElement (pctxt, "h223AnnexB", -1); + + /* decode h223AnnexBwithHeader */ + + invokeStartElement (pctxt, "h223AnnexBwithHeader", -1); + + stat = DECODEBIT (pctxt, &pvalue->h223AnnexBwithHeader); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->h223AnnexBwithHeader); + + invokeEndElement (pctxt, "h223AnnexBwithHeader", -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); +} + +/**************************************************************/ +/* */ +/* H223AnnexCCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode videoWithAL1M */ + + invokeStartElement (pctxt, "videoWithAL1M", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoWithAL1M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoWithAL1M); + + invokeEndElement (pctxt, "videoWithAL1M", -1); + + /* decode videoWithAL2M */ + + invokeStartElement (pctxt, "videoWithAL2M", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoWithAL2M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoWithAL2M); + + invokeEndElement (pctxt, "videoWithAL2M", -1); + + /* decode videoWithAL3M */ + + invokeStartElement (pctxt, "videoWithAL3M", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoWithAL3M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoWithAL3M); + + invokeEndElement (pctxt, "videoWithAL3M", -1); + + /* decode audioWithAL1M */ + + invokeStartElement (pctxt, "audioWithAL1M", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioWithAL1M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioWithAL1M); + + invokeEndElement (pctxt, "audioWithAL1M", -1); + + /* decode audioWithAL2M */ + + invokeStartElement (pctxt, "audioWithAL2M", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioWithAL2M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioWithAL2M); + + invokeEndElement (pctxt, "audioWithAL2M", -1); + + /* decode audioWithAL3M */ + + invokeStartElement (pctxt, "audioWithAL3M", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioWithAL3M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioWithAL3M); + + invokeEndElement (pctxt, "audioWithAL3M", -1); + + /* decode dataWithAL1M */ + + invokeStartElement (pctxt, "dataWithAL1M", -1); + + stat = DECODEBIT (pctxt, &pvalue->dataWithAL1M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dataWithAL1M); + + invokeEndElement (pctxt, "dataWithAL1M", -1); + + /* decode dataWithAL2M */ + + invokeStartElement (pctxt, "dataWithAL2M", -1); + + stat = DECODEBIT (pctxt, &pvalue->dataWithAL2M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dataWithAL2M); + + invokeEndElement (pctxt, "dataWithAL2M", -1); + + /* decode dataWithAL3M */ + + invokeStartElement (pctxt, "dataWithAL3M", -1); + + stat = DECODEBIT (pctxt, &pvalue->dataWithAL3M); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dataWithAL3M); + + invokeEndElement (pctxt, "dataWithAL3M", -1); + + /* decode alpduInterleaving */ + + invokeStartElement (pctxt, "alpduInterleaving", -1); + + stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->alpduInterleaving); + + invokeEndElement (pctxt, "alpduInterleaving", -1); + + /* decode maximumAL1MPDUSize */ + + invokeStartElement (pctxt, "maximumAL1MPDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL1MPDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumAL1MPDUSize); + + invokeEndElement (pctxt, "maximumAL1MPDUSize", -1); + + /* decode maximumAL2MSDUSize */ + + invokeStartElement (pctxt, "maximumAL2MSDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL2MSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumAL2MSDUSize); + + invokeEndElement (pctxt, "maximumAL2MSDUSize", -1); + + /* decode maximumAL3MSDUSize */ + + invokeStartElement (pctxt, "maximumAL3MSDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumAL3MSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumAL3MSDUSize); + + invokeEndElement (pctxt, "maximumAL3MSDUSize", -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.rsCodeCapabilityPresent = 1; + + invokeStartElement (pctxt, "rsCodeCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->rsCodeCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->rsCodeCapability); + + invokeEndElement (pctxt, "rsCodeCapability", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223Capability_mobileMultilinkFrameCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode maximumSampleSize */ + + invokeStartElement (pctxt, "maximumSampleSize", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->maximumSampleSize, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumSampleSize); + + invokeEndElement (pctxt, "maximumSampleSize", -1); + + /* decode maximumPayloadLength */ + + invokeStartElement (pctxt, "maximumPayloadLength", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumPayloadLength, 1U, 65025U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumPayloadLength); + + invokeEndElement (pctxt, "maximumPayloadLength", -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); +} + +/**************************************************************/ +/* */ +/* H223Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode transportWithI_frames */ + + invokeStartElement (pctxt, "transportWithI_frames", -1); + + stat = DECODEBIT (pctxt, &pvalue->transportWithI_frames); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->transportWithI_frames); + + invokeEndElement (pctxt, "transportWithI_frames", -1); + + /* decode videoWithAL1 */ + + invokeStartElement (pctxt, "videoWithAL1", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoWithAL1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoWithAL1); + + invokeEndElement (pctxt, "videoWithAL1", -1); + + /* decode videoWithAL2 */ + + invokeStartElement (pctxt, "videoWithAL2", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoWithAL2); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoWithAL2); + + invokeEndElement (pctxt, "videoWithAL2", -1); + + /* decode videoWithAL3 */ + + invokeStartElement (pctxt, "videoWithAL3", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoWithAL3); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoWithAL3); + + invokeEndElement (pctxt, "videoWithAL3", -1); + + /* decode audioWithAL1 */ + + invokeStartElement (pctxt, "audioWithAL1", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioWithAL1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioWithAL1); + + invokeEndElement (pctxt, "audioWithAL1", -1); + + /* decode audioWithAL2 */ + + invokeStartElement (pctxt, "audioWithAL2", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioWithAL2); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioWithAL2); + + invokeEndElement (pctxt, "audioWithAL2", -1); + + /* decode audioWithAL3 */ + + invokeStartElement (pctxt, "audioWithAL3", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioWithAL3); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioWithAL3); + + invokeEndElement (pctxt, "audioWithAL3", -1); + + /* decode dataWithAL1 */ + + invokeStartElement (pctxt, "dataWithAL1", -1); + + stat = DECODEBIT (pctxt, &pvalue->dataWithAL1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dataWithAL1); + + invokeEndElement (pctxt, "dataWithAL1", -1); + + /* decode dataWithAL2 */ + + invokeStartElement (pctxt, "dataWithAL2", -1); + + stat = DECODEBIT (pctxt, &pvalue->dataWithAL2); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dataWithAL2); + + invokeEndElement (pctxt, "dataWithAL2", -1); + + /* decode dataWithAL3 */ + + invokeStartElement (pctxt, "dataWithAL3", -1); + + stat = DECODEBIT (pctxt, &pvalue->dataWithAL3); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dataWithAL3); + + invokeEndElement (pctxt, "dataWithAL3", -1); + + /* decode maximumAl2SDUSize */ + + invokeStartElement (pctxt, "maximumAl2SDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumAl2SDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumAl2SDUSize); + + invokeEndElement (pctxt, "maximumAl2SDUSize", -1); + + /* decode maximumAl3SDUSize */ + + invokeStartElement (pctxt, "maximumAl3SDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumAl3SDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumAl3SDUSize); + + invokeEndElement (pctxt, "maximumAl3SDUSize", -1); + + /* decode maximumDelayJitter */ + + invokeStartElement (pctxt, "maximumDelayJitter", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumDelayJitter, 0U, 1023U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumDelayJitter); + + invokeEndElement (pctxt, "maximumDelayJitter", -1); + + /* decode h223MultiplexTableCapability */ + + invokeStartElement (pctxt, "h223MultiplexTableCapability", -1); + + stat = asn1PD_H245H223Capability_h223MultiplexTableCapability (pctxt, &pvalue->h223MultiplexTableCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223MultiplexTableCapability", -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.maxMUXPDUSizeCapabilityPresent = 1; + + invokeStartElement (pctxt, "maxMUXPDUSizeCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->maxMUXPDUSizeCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->maxMUXPDUSizeCapability); + + invokeEndElement (pctxt, "maxMUXPDUSizeCapability", -1); + break; + + case 1: + pvalue->m.nsrpSupportPresent = 1; + + invokeStartElement (pctxt, "nsrpSupport", -1); + + stat = DECODEBIT (pctxt, &pvalue->nsrpSupport); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->nsrpSupport); + + invokeEndElement (pctxt, "nsrpSupport", -1); + break; + + case 2: + pvalue->m.mobileOperationTransmitCapabilityPresent = 1; + + invokeStartElement (pctxt, "mobileOperationTransmitCapability", -1); + + stat = asn1PD_H245H223Capability_mobileOperationTransmitCapability (pctxt, &pvalue->mobileOperationTransmitCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mobileOperationTransmitCapability", -1); + break; + + case 3: + pvalue->m.h223AnnexCCapabilityPresent = 1; + + invokeStartElement (pctxt, "h223AnnexCCapability", -1); + + stat = asn1PD_H245H223AnnexCCapability (pctxt, &pvalue->h223AnnexCCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223AnnexCCapability", -1); + break; + + case 4: + pvalue->m.bitRatePresent = 1; + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 19200U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -1); + break; + + case 5: + pvalue->m.mobileMultilinkFrameCapabilityPresent = 1; + + invokeStartElement (pctxt, "mobileMultilinkFrameCapability", -1); + + stat = asn1PD_H245H223Capability_mobileMultilinkFrameCapability (pctxt, &pvalue->mobileMultilinkFrameCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mobileMultilinkFrameCapability", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* V75Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode audioHeader */ + + invokeStartElement (pctxt, "audioHeader", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioHeader); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioHeader); + + invokeEndElement (pctxt, "audioHeader", -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); +} + +/**************************************************************/ +/* */ +/* V76Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode suspendResumeCapabilitywAddress */ + + invokeStartElement (pctxt, "suspendResumeCapabilitywAddress", -1); + + stat = DECODEBIT (pctxt, &pvalue->suspendResumeCapabilitywAddress); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->suspendResumeCapabilitywAddress); + + invokeEndElement (pctxt, "suspendResumeCapabilitywAddress", -1); + + /* decode suspendResumeCapabilitywoAddress */ + + invokeStartElement (pctxt, "suspendResumeCapabilitywoAddress", -1); + + stat = DECODEBIT (pctxt, &pvalue->suspendResumeCapabilitywoAddress); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->suspendResumeCapabilitywoAddress); + + invokeEndElement (pctxt, "suspendResumeCapabilitywoAddress", -1); + + /* decode rejCapability */ + + invokeStartElement (pctxt, "rejCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->rejCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->rejCapability); + + invokeEndElement (pctxt, "rejCapability", -1); + + /* decode sREJCapability */ + + invokeStartElement (pctxt, "sREJCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->sREJCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->sREJCapability); + + invokeEndElement (pctxt, "sREJCapability", -1); + + /* decode mREJCapability */ + + invokeStartElement (pctxt, "mREJCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->mREJCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->mREJCapability); + + invokeEndElement (pctxt, "mREJCapability", -1); + + /* decode crc8bitCapability */ + + invokeStartElement (pctxt, "crc8bitCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->crc8bitCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->crc8bitCapability); + + invokeEndElement (pctxt, "crc8bitCapability", -1); + + /* decode crc16bitCapability */ + + invokeStartElement (pctxt, "crc16bitCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->crc16bitCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->crc16bitCapability); + + invokeEndElement (pctxt, "crc16bitCapability", -1); + + /* decode crc32bitCapability */ + + invokeStartElement (pctxt, "crc32bitCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->crc32bitCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->crc32bitCapability); + + invokeEndElement (pctxt, "crc32bitCapability", -1); + + /* decode uihCapability */ + + invokeStartElement (pctxt, "uihCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->uihCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->uihCapability); + + invokeEndElement (pctxt, "uihCapability", -1); + + /* decode numOfDLCS */ + + invokeStartElement (pctxt, "numOfDLCS", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->numOfDLCS, 2U, 8191U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numOfDLCS); + + invokeEndElement (pctxt, "numOfDLCS", -1); + + /* decode twoOctetAddressFieldCapability */ + + invokeStartElement (pctxt, "twoOctetAddressFieldCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->twoOctetAddressFieldCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->twoOctetAddressFieldCapability); + + invokeEndElement (pctxt, "twoOctetAddressFieldCapability", -1); + + /* decode loopBackTestCapability */ + + invokeStartElement (pctxt, "loopBackTestCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->loopBackTestCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->loopBackTestCapability); + + invokeEndElement (pctxt, "loopBackTestCapability", -1); + + /* decode n401Capability */ + + invokeStartElement (pctxt, "n401Capability", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->n401Capability, 1U, 4095U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->n401Capability); + + invokeEndElement (pctxt, "n401Capability", -1); + + /* decode maxWindowSizeCapability */ + + invokeStartElement (pctxt, "maxWindowSizeCapability", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->maxWindowSizeCapability, 1U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxWindowSizeCapability); + + invokeEndElement (pctxt, "maxWindowSizeCapability", -1); + + /* decode v75Capability */ + + invokeStartElement (pctxt, "v75Capability", -1); + + stat = asn1PD_H245V75Capability (pctxt, &pvalue->v75Capability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "v75Capability", -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); +} + +/**************************************************************/ +/* */ +/* T84Profile_t84Restricted */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode qcif */ + + invokeStartElement (pctxt, "qcif", -1); + + stat = DECODEBIT (pctxt, &pvalue->qcif); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->qcif); + + invokeEndElement (pctxt, "qcif", -1); + + /* decode cif */ + + invokeStartElement (pctxt, "cif", -1); + + stat = DECODEBIT (pctxt, &pvalue->cif); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->cif); + + invokeEndElement (pctxt, "cif", -1); + + /* decode ccir601Seq */ + + invokeStartElement (pctxt, "ccir601Seq", -1); + + stat = DECODEBIT (pctxt, &pvalue->ccir601Seq); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->ccir601Seq); + + invokeEndElement (pctxt, "ccir601Seq", -1); + + /* decode ccir601Prog */ + + invokeStartElement (pctxt, "ccir601Prog", -1); + + stat = DECODEBIT (pctxt, &pvalue->ccir601Prog); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->ccir601Prog); + + invokeEndElement (pctxt, "ccir601Prog", -1); + + /* decode hdtvSeq */ + + invokeStartElement (pctxt, "hdtvSeq", -1); + + stat = DECODEBIT (pctxt, &pvalue->hdtvSeq); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->hdtvSeq); + + invokeEndElement (pctxt, "hdtvSeq", -1); + + /* decode hdtvProg */ + + invokeStartElement (pctxt, "hdtvProg", -1); + + stat = DECODEBIT (pctxt, &pvalue->hdtvProg); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->hdtvProg); + + invokeEndElement (pctxt, "hdtvProg", -1); + + /* decode g3FacsMH200x100 */ + + invokeStartElement (pctxt, "g3FacsMH200x100", -1); + + stat = DECODEBIT (pctxt, &pvalue->g3FacsMH200x100); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->g3FacsMH200x100); + + invokeEndElement (pctxt, "g3FacsMH200x100", -1); + + /* decode g3FacsMH200x200 */ + + invokeStartElement (pctxt, "g3FacsMH200x200", -1); + + stat = DECODEBIT (pctxt, &pvalue->g3FacsMH200x200); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->g3FacsMH200x200); + + invokeEndElement (pctxt, "g3FacsMH200x200", -1); + + /* decode g4FacsMMR200x100 */ + + invokeStartElement (pctxt, "g4FacsMMR200x100", -1); + + stat = DECODEBIT (pctxt, &pvalue->g4FacsMMR200x100); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->g4FacsMMR200x100); + + invokeEndElement (pctxt, "g4FacsMMR200x100", -1); + + /* decode g4FacsMMR200x200 */ + + invokeStartElement (pctxt, "g4FacsMMR200x200", -1); + + stat = DECODEBIT (pctxt, &pvalue->g4FacsMMR200x200); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->g4FacsMMR200x200); + + invokeEndElement (pctxt, "g4FacsMMR200x200", -1); + + /* decode jbig200x200Seq */ + + invokeStartElement (pctxt, "jbig200x200Seq", -1); + + stat = DECODEBIT (pctxt, &pvalue->jbig200x200Seq); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->jbig200x200Seq); + + invokeEndElement (pctxt, "jbig200x200Seq", -1); + + /* decode jbig200x200Prog */ + + invokeStartElement (pctxt, "jbig200x200Prog", -1); + + stat = DECODEBIT (pctxt, &pvalue->jbig200x200Prog); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->jbig200x200Prog); + + invokeEndElement (pctxt, "jbig200x200Prog", -1); + + /* decode jbig300x300Seq */ + + invokeStartElement (pctxt, "jbig300x300Seq", -1); + + stat = DECODEBIT (pctxt, &pvalue->jbig300x300Seq); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->jbig300x300Seq); + + invokeEndElement (pctxt, "jbig300x300Seq", -1); + + /* decode jbig300x300Prog */ + + invokeStartElement (pctxt, "jbig300x300Prog", -1); + + stat = DECODEBIT (pctxt, &pvalue->jbig300x300Prog); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->jbig300x300Prog); + + invokeEndElement (pctxt, "jbig300x300Prog", -1); + + /* decode digPhotoLow */ + + invokeStartElement (pctxt, "digPhotoLow", -1); + + stat = DECODEBIT (pctxt, &pvalue->digPhotoLow); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->digPhotoLow); + + invokeEndElement (pctxt, "digPhotoLow", -1); + + /* decode digPhotoMedSeq */ + + invokeStartElement (pctxt, "digPhotoMedSeq", -1); + + stat = DECODEBIT (pctxt, &pvalue->digPhotoMedSeq); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->digPhotoMedSeq); + + invokeEndElement (pctxt, "digPhotoMedSeq", -1); + + /* decode digPhotoMedProg */ + + invokeStartElement (pctxt, "digPhotoMedProg", -1); + + stat = DECODEBIT (pctxt, &pvalue->digPhotoMedProg); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->digPhotoMedProg); + + invokeEndElement (pctxt, "digPhotoMedProg", -1); + + /* decode digPhotoHighSeq */ + + invokeStartElement (pctxt, "digPhotoHighSeq", -1); + + stat = DECODEBIT (pctxt, &pvalue->digPhotoHighSeq); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->digPhotoHighSeq); + + invokeEndElement (pctxt, "digPhotoHighSeq", -1); + + /* decode digPhotoHighProg */ + + invokeStartElement (pctxt, "digPhotoHighProg", -1); + + stat = DECODEBIT (pctxt, &pvalue->digPhotoHighProg); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->digPhotoHighProg); + + invokeEndElement (pctxt, "digPhotoHighProg", -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); +} + +/**************************************************************/ +/* */ +/* T84Profile */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245T84Profile (OOCTXT* pctxt, H245T84Profile* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* t84Unrestricted */ + case 0: + invokeStartElement (pctxt, "t84Unrestricted", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "t84Unrestricted", -1); + + break; + + /* t84Restricted */ + case 1: + invokeStartElement (pctxt, "t84Restricted", -1); + + pvalue->u.t84Restricted = ALLOC_ASN1ELEM (pctxt, H245T84Profile_t84Restricted); + + stat = asn1PD_H245T84Profile_t84Restricted (pctxt, pvalue->u.t84Restricted); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t84Restricted", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_t84 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataApplicationCapability_application_t84 (OOCTXT* pctxt, H245DataApplicationCapability_application_t84* pvalue) +{ + int stat = ASN_OK; + + /* decode t84Protocol */ + + invokeStartElement (pctxt, "t84Protocol", -1); + + stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->t84Protocol); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t84Protocol", -1); + + /* decode t84Profile */ + + invokeStartElement (pctxt, "t84Profile", -1); + + stat = asn1PD_H245T84Profile (pctxt, &pvalue->t84Profile); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t84Profile", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_nlpid */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataApplicationCapability_application_nlpid (OOCTXT* pctxt, H245DataApplicationCapability_application_nlpid* pvalue) +{ + int stat = ASN_OK; + + /* decode nlpidProtocol */ + + invokeStartElement (pctxt, "nlpidProtocol", -1); + + stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->nlpidProtocol); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nlpidProtocol", -1); + + /* decode nlpidData */ + + invokeStartElement (pctxt, "nlpidData", -1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->nlpidData); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->nlpidData.numocts, pvalue->nlpidData.data); + + invokeEndElement (pctxt, "nlpidData", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_t38fax */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataApplicationCapability_application_t38fax (OOCTXT* pctxt, H245DataApplicationCapability_application_t38fax* pvalue) +{ + int stat = ASN_OK; + + /* 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); + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityIdentifier_uuid */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CapabilityIdentifier_uuid (OOCTXT* pctxt, H245CapabilityIdentifier_uuid* 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); +} + +/**************************************************************/ +/* */ +/* CapabilityIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CapabilityIdentifier (OOCTXT* pctxt, H245CapabilityIdentifier* pvalue) +{ + static Asn1SizeCnst domainBased_lsize1 = { 0, 1, 64, 0 }; + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* standard */ + case 0: + invokeStartElement (pctxt, "standard", -1); + + pvalue->u.standard = ALLOC_ASN1ELEM (pctxt, ASN1OBJID); + + stat = decodeObjectIdentifier (pctxt, pvalue->u.standard); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->u.standard->numids, pvalue->u.standard->subid); + + invokeEndElement (pctxt, "standard", -1); + + break; + + /* h221NonStandard */ + case 1: + invokeStartElement (pctxt, "h221NonStandard", -1); + + pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.h221NonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h221NonStandard", -1); + + break; + + /* uuid */ + case 2: + invokeStartElement (pctxt, "uuid", -1); + + pvalue->u.uuid = ALLOC_ASN1ELEM (pctxt, H245CapabilityIdentifier_uuid); + + stat = asn1PD_H245CapabilityIdentifier_uuid (pctxt, pvalue->u.uuid); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "uuid", -1); + + break; + + /* domainBased */ + case 3: + invokeStartElement (pctxt, "domainBased", -1); + + addSizeConstraint (pctxt, &domainBased_lsize1); + + stat = decodeConstrainedStringEx (pctxt, &pvalue->u.domainBased, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->u.domainBased); + + invokeEndElement (pctxt, "domainBased", -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); +} + +/**************************************************************/ +/* */ +/* ParameterIdentifier_uuid */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ParameterIdentifier_uuid (OOCTXT* pctxt, H245ParameterIdentifier_uuid* 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); +} + +/**************************************************************/ +/* */ +/* ParameterIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ParameterIdentifier (OOCTXT* pctxt, H245ParameterIdentifier* pvalue) +{ + static Asn1SizeCnst domainBased_lsize1 = { 0, 1, 64, 0 }; + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* standard */ + case 0: + invokeStartElement (pctxt, "standard", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->u.standard, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.standard); + + invokeEndElement (pctxt, "standard", -1); + + break; + + /* h221NonStandard */ + case 1: + invokeStartElement (pctxt, "h221NonStandard", -1); + + pvalue->u.h221NonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.h221NonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h221NonStandard", -1); + + break; + + /* uuid */ + case 2: + invokeStartElement (pctxt, "uuid", -1); + + pvalue->u.uuid = ALLOC_ASN1ELEM (pctxt, H245ParameterIdentifier_uuid); + + stat = asn1PD_H245ParameterIdentifier_uuid (pctxt, pvalue->u.uuid); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "uuid", -1); + + break; + + /* domainBased */ + case 3: + invokeStartElement (pctxt, "domainBased", -1); + + addSizeConstraint (pctxt, &domainBased_lsize1); + + stat = decodeConstrainedStringEx (pctxt, &pvalue->u.domainBased, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->u.domainBased); + + invokeEndElement (pctxt, "domainBased", -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); +} + +/**************************************************************/ +/* */ +/* ParameterValue */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ParameterValue (OOCTXT* pctxt, H245ParameterValue* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* logical */ + case 0: + invokeStartElement (pctxt, "logical", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "logical", -1); + + break; + + /* booleanArray */ + case 1: + invokeStartElement (pctxt, "booleanArray", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->u.booleanArray, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.booleanArray); + + invokeEndElement (pctxt, "booleanArray", -1); + + break; + + /* unsignedMin */ + case 2: + invokeStartElement (pctxt, "unsignedMin", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.unsignedMin, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.unsignedMin); + + invokeEndElement (pctxt, "unsignedMin", -1); + + break; + + /* unsignedMax */ + case 3: + invokeStartElement (pctxt, "unsignedMax", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.unsignedMax, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.unsignedMax); + + invokeEndElement (pctxt, "unsignedMax", -1); + + break; + + /* unsigned32Min */ + case 4: + invokeStartElement (pctxt, "unsigned32Min", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->u.unsigned32Min, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.unsigned32Min); + + invokeEndElement (pctxt, "unsigned32Min", -1); + + break; + + /* unsigned32Max */ + case 5: + invokeStartElement (pctxt, "unsigned32Max", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->u.unsigned32Max, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.unsigned32Max); + + invokeEndElement (pctxt, "unsigned32Max", -1); + + break; + + /* octetString */ + case 6: + invokeStartElement (pctxt, "octetString", -1); + + pvalue->u.octetString = ALLOC_ASN1ELEM (pctxt, ASN1DynOctStr); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue->u.octetString); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->u.octetString->numocts, pvalue->u.octetString->data); + + invokeEndElement (pctxt, "octetString", -1); + + break; + + /* genericParameter */ + case 7: + invokeStartElement (pctxt, "genericParameter", -1); + + pvalue->u.genericParameter = ALLOC_ASN1ELEM (pctxt, H245_SeqOfH245GenericParameter); + + stat = asn1PD_H245_SeqOfH245GenericParameter (pctxt, (H245_SeqOfH245GenericParameter*)pvalue->u.genericParameter); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericParameter", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245ParameterIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245ParameterIdentifier (OOCTXT* pctxt, H245_SeqOfH245ParameterIdentifier* pvalue) +{ + int stat = ASN_OK; + H245ParameterIdentifier* 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, H245ParameterIdentifier); + + stat = asn1PD_H245ParameterIdentifier (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GenericParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245GenericParameter (OOCTXT* pctxt, H245GenericParameter* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.supersedesPresent = optbit; + + /* decode parameterIdentifier */ + + invokeStartElement (pctxt, "parameterIdentifier", -1); + + stat = asn1PD_H245ParameterIdentifier (pctxt, &pvalue->parameterIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "parameterIdentifier", -1); + + /* decode parameterValue */ + + invokeStartElement (pctxt, "parameterValue", -1); + + stat = asn1PD_H245ParameterValue (pctxt, &pvalue->parameterValue); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "parameterValue", -1); + + /* decode supersedes */ + + if (pvalue->m.supersedesPresent) { + invokeStartElement (pctxt, "supersedes", -1); + + stat = asn1PD_H245_SeqOfH245ParameterIdentifier (pctxt, &pvalue->supersedes); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "supersedes", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245GenericParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245GenericParameter (OOCTXT* pctxt, H245_SeqOfH245GenericParameter* pvalue) +{ + int stat = ASN_OK; + H245GenericParameter* 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, H245GenericParameter); + + stat = asn1PD_H245GenericParameter (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GenericCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245GenericCapability (OOCTXT* pctxt, H245GenericCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.maxBitRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.collapsingPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.nonCollapsingPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.nonCollapsingRawPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.transportPresent = optbit; + + /* decode capabilityIdentifier */ + + invokeStartElement (pctxt, "capabilityIdentifier", -1); + + stat = asn1PD_H245CapabilityIdentifier (pctxt, &pvalue->capabilityIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilityIdentifier", -1); + + /* decode maxBitRate */ + + if (pvalue->m.maxBitRatePresent) { + invokeStartElement (pctxt, "maxBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->maxBitRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxBitRate); + + invokeEndElement (pctxt, "maxBitRate", -1); + } + + /* decode collapsing */ + + if (pvalue->m.collapsingPresent) { + invokeStartElement (pctxt, "collapsing", -1); + + stat = asn1PD_H245_SeqOfH245GenericParameter (pctxt, &pvalue->collapsing); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "collapsing", -1); + } + + /* decode nonCollapsing */ + + if (pvalue->m.nonCollapsingPresent) { + invokeStartElement (pctxt, "nonCollapsing", -1); + + stat = asn1PD_H245_SeqOfH245GenericParameter (pctxt, &pvalue->nonCollapsing); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonCollapsing", -1); + } + + /* decode nonCollapsingRaw */ + + if (pvalue->m.nonCollapsingRawPresent) { + invokeStartElement (pctxt, "nonCollapsingRaw", -1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->nonCollapsingRaw); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->nonCollapsingRaw.numocts, pvalue->nonCollapsingRaw.data); + + invokeEndElement (pctxt, "nonCollapsingRaw", -1); + } + + /* decode transport */ + + if (pvalue->m.transportPresent) { + invokeStartElement (pctxt, "transport", -1); + + stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->transport); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transport", -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); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataApplicationCapability_application (OOCTXT* pctxt, H245DataApplicationCapability_application* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 9); + 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* t120 */ + case 1: + invokeStartElement (pctxt, "t120", -1); + + pvalue->u.t120 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t120); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t120", -1); + + break; + + /* dsm_cc */ + case 2: + invokeStartElement (pctxt, "dsm_cc", -1); + + pvalue->u.dsm_cc = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.dsm_cc); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dsm_cc", -1); + + break; + + /* userData */ + case 3: + invokeStartElement (pctxt, "userData", -1); + + pvalue->u.userData = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.userData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "userData", -1); + + break; + + /* t84 */ + case 4: + invokeStartElement (pctxt, "t84", -1); + + pvalue->u.t84 = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability_application_t84); + + stat = asn1PD_H245DataApplicationCapability_application_t84 (pctxt, pvalue->u.t84); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t84", -1); + + break; + + /* t434 */ + case 5: + invokeStartElement (pctxt, "t434", -1); + + pvalue->u.t434 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t434); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t434", -1); + + break; + + /* h224 */ + case 6: + invokeStartElement (pctxt, "h224", -1); + + pvalue->u.h224 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.h224); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h224", -1); + + break; + + /* nlpid */ + case 7: + invokeStartElement (pctxt, "nlpid", -1); + + pvalue->u.nlpid = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability_application_nlpid); + + stat = asn1PD_H245DataApplicationCapability_application_nlpid (pctxt, pvalue->u.nlpid); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nlpid", -1); + + break; + + /* dsvdControl */ + case 8: + invokeStartElement (pctxt, "dsvdControl", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "dsvdControl", -1); + + break; + + /* h222DataPartitioning */ + case 9: + invokeStartElement (pctxt, "h222DataPartitioning", -1); + + pvalue->u.h222DataPartitioning = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.h222DataPartitioning); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h222DataPartitioning", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 11; + + 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) { + /* t30fax */ + case 11: + invokeStartElement (pctxt, "t30fax", -1); + + pvalue->u.t30fax = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t30fax); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t30fax", -1); + + break; + + /* t140 */ + case 12: + invokeStartElement (pctxt, "t140", -1); + + pvalue->u.t140 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t140); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t140", -1); + + break; + + /* t38fax */ + case 13: + invokeStartElement (pctxt, "t38fax", -1); + + pvalue->u.t38fax = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability_application_t38fax); + + stat = asn1PD_H245DataApplicationCapability_application_t38fax (pctxt, pvalue->u.t38fax); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t38fax", -1); + + break; + + /* genericDataCapability */ + case 14: + invokeStartElement (pctxt, "genericDataCapability", -1); + + pvalue->u.genericDataCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability); + + stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericDataCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericDataCapability", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataApplicationCapability (OOCTXT* pctxt, H245DataApplicationCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode application */ + + invokeStartElement (pctxt, "application", -1); + + stat = asn1PD_H245DataApplicationCapability_application (pctxt, &pvalue->application); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "application", -1); + + /* decode maxBitRate */ + + invokeStartElement (pctxt, "maxBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->maxBitRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxBitRate); + + invokeEndElement (pctxt, "maxBitRate", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245DataApplicationCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245DataApplicationCapability (OOCTXT* pctxt, H245_SeqOfH245DataApplicationCapability* pvalue) +{ + int stat = ASN_OK; + H245DataApplicationCapability* 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, H245DataApplicationCapability); + + stat = asn1PD_H245DataApplicationCapability (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaDistributionCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MediaDistributionCapability (OOCTXT* pctxt, H245MediaDistributionCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.centralizedDataPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.distributedDataPresent = optbit; + + /* decode centralizedControl */ + + invokeStartElement (pctxt, "centralizedControl", -1); + + stat = DECODEBIT (pctxt, &pvalue->centralizedControl); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->centralizedControl); + + invokeEndElement (pctxt, "centralizedControl", -1); + + /* decode distributedControl */ + + invokeStartElement (pctxt, "distributedControl", -1); + + stat = DECODEBIT (pctxt, &pvalue->distributedControl); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->distributedControl); + + invokeEndElement (pctxt, "distributedControl", -1); + + /* decode centralizedAudio */ + + invokeStartElement (pctxt, "centralizedAudio", -1); + + stat = DECODEBIT (pctxt, &pvalue->centralizedAudio); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->centralizedAudio); + + invokeEndElement (pctxt, "centralizedAudio", -1); + + /* decode distributedAudio */ + + invokeStartElement (pctxt, "distributedAudio", -1); + + stat = DECODEBIT (pctxt, &pvalue->distributedAudio); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->distributedAudio); + + invokeEndElement (pctxt, "distributedAudio", -1); + + /* decode centralizedVideo */ + + invokeStartElement (pctxt, "centralizedVideo", -1); + + stat = DECODEBIT (pctxt, &pvalue->centralizedVideo); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->centralizedVideo); + + invokeEndElement (pctxt, "centralizedVideo", -1); + + /* decode distributedVideo */ + + invokeStartElement (pctxt, "distributedVideo", -1); + + stat = DECODEBIT (pctxt, &pvalue->distributedVideo); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->distributedVideo); + + invokeEndElement (pctxt, "distributedVideo", -1); + + /* decode centralizedData */ + + if (pvalue->m.centralizedDataPresent) { + invokeStartElement (pctxt, "centralizedData", -1); + + stat = asn1PD_H245_SeqOfH245DataApplicationCapability (pctxt, &pvalue->centralizedData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "centralizedData", -1); + } + + /* decode distributedData */ + + if (pvalue->m.distributedDataPresent) { + invokeStartElement (pctxt, "distributedData", -1); + + stat = asn1PD_H245_SeqOfH245DataApplicationCapability (pctxt, &pvalue->distributedData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "distributedData", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245MediaDistributionCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245MediaDistributionCapability (OOCTXT* pctxt, H245_SeqOfH245MediaDistributionCapability* pvalue) +{ + int stat = ASN_OK; + H245MediaDistributionCapability* 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, H245MediaDistributionCapability); + + stat = asn1PD_H245MediaDistributionCapability (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultipointCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultipointCapability (OOCTXT* pctxt, H245MultipointCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode multicastCapability */ + + invokeStartElement (pctxt, "multicastCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->multicastCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->multicastCapability); + + invokeEndElement (pctxt, "multicastCapability", -1); + + /* decode multiUniCastConference */ + + invokeStartElement (pctxt, "multiUniCastConference", -1); + + stat = DECODEBIT (pctxt, &pvalue->multiUniCastConference); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->multiUniCastConference); + + invokeEndElement (pctxt, "multiUniCastConference", -1); + + /* decode mediaDistributionCapability */ + + invokeStartElement (pctxt, "mediaDistributionCapability", -1); + + stat = asn1PD_H245_SeqOfH245MediaDistributionCapability (pctxt, &pvalue->mediaDistributionCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaDistributionCapability", -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); +} + +/**************************************************************/ +/* */ +/* H2250Capability_mcCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H2250Capability_mcCapability (OOCTXT* pctxt, H245H2250Capability_mcCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode centralizedConferenceMC */ + + invokeStartElement (pctxt, "centralizedConferenceMC", -1); + + stat = DECODEBIT (pctxt, &pvalue->centralizedConferenceMC); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->centralizedConferenceMC); + + invokeEndElement (pctxt, "centralizedConferenceMC", -1); + + /* decode decentralizedConferenceMC */ + + invokeStartElement (pctxt, "decentralizedConferenceMC", -1); + + stat = DECODEBIT (pctxt, &pvalue->decentralizedConferenceMC); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->decentralizedConferenceMC); + + invokeEndElement (pctxt, "decentralizedConferenceMC", -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); +} + +/**************************************************************/ +/* */ +/* RTPPayloadType_payloadDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RTPPayloadType_payloadDescriptor (OOCTXT* pctxt, H245RTPPayloadType_payloadDescriptor* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* nonStandardIdentifier */ + case 0: + invokeStartElement (pctxt, "nonStandardIdentifier", -1); + + pvalue->u.nonStandardIdentifier = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandardIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandardIdentifier", -1); + + break; + + /* rfc_number */ + case 1: + invokeStartElement (pctxt, "rfc_number", -1); + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (extbit == 0) { + stat = decodeConsInteger (pctxt, &pvalue->u.rfc_number, 1, 32768); + if (stat != ASN_OK) return stat; + } + else { + stat = decodeUnconsInteger (pctxt, &pvalue->u.rfc_number); + if (stat != ASN_OK) return stat; + } + invokeIntValue (pctxt, pvalue->u.rfc_number); + + invokeEndElement (pctxt, "rfc_number", -1); + + break; + + /* oid */ + case 2: + 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; + + 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); +} + +/**************************************************************/ +/* */ +/* RTPPayloadType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RTPPayloadType (OOCTXT* pctxt, H245RTPPayloadType* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.payloadTypePresent = optbit; + + /* decode payloadDescriptor */ + + invokeStartElement (pctxt, "payloadDescriptor", -1); + + stat = asn1PD_H245RTPPayloadType_payloadDescriptor (pctxt, &pvalue->payloadDescriptor); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "payloadDescriptor", -1); + + /* decode payloadType */ + + if (pvalue->m.payloadTypePresent) { + invokeStartElement (pctxt, "payloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->payloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->payloadType); + + invokeEndElement (pctxt, "payloadType", -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); +} + +/**************************************************************/ +/* */ +/* MediaPacketizationCapability_rtpPayloadType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MediaPacketizationCapability_rtpPayloadType (OOCTXT* pctxt, H245MediaPacketizationCapability_rtpPayloadType* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245RTPPayloadType* 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, H245RTPPayloadType); + + stat = asn1PD_H245RTPPayloadType (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaPacketizationCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MediaPacketizationCapability (OOCTXT* pctxt, H245MediaPacketizationCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode h261aVideoPacketization */ + + invokeStartElement (pctxt, "h261aVideoPacketization", -1); + + stat = DECODEBIT (pctxt, &pvalue->h261aVideoPacketization); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->h261aVideoPacketization); + + invokeEndElement (pctxt, "h261aVideoPacketization", -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.rtpPayloadTypePresent = 1; + + invokeStartElement (pctxt, "rtpPayloadType", -1); + + stat = asn1PD_H245MediaPacketizationCapability_rtpPayloadType (pctxt, &pvalue->rtpPayloadType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rtpPayloadType", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* QOSMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245QOSMode (OOCTXT* pctxt, H245QOSMode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* guaranteedQOS */ + case 0: + invokeStartElement (pctxt, "guaranteedQOS", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "guaranteedQOS", -1); + + break; + + /* controlledLoad */ + case 1: + invokeStartElement (pctxt, "controlledLoad", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "controlledLoad", -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); +} + +/**************************************************************/ +/* */ +/* RSVPParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RSVPParameters (OOCTXT* pctxt, H245RSVPParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.qosModePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.tokenRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.bucketSizePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.peakRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.minPolicedPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.maxPktSizePresent = optbit; + + /* decode qosMode */ + + if (pvalue->m.qosModePresent) { + invokeStartElement (pctxt, "qosMode", -1); + + stat = asn1PD_H245QOSMode (pctxt, &pvalue->qosMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "qosMode", -1); + } + + /* decode tokenRate */ + + if (pvalue->m.tokenRatePresent) { + invokeStartElement (pctxt, "tokenRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->tokenRate, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->tokenRate); + + invokeEndElement (pctxt, "tokenRate", -1); + } + + /* decode bucketSize */ + + if (pvalue->m.bucketSizePresent) { + invokeStartElement (pctxt, "bucketSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->bucketSize, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bucketSize); + + invokeEndElement (pctxt, "bucketSize", -1); + } + + /* decode peakRate */ + + if (pvalue->m.peakRatePresent) { + invokeStartElement (pctxt, "peakRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->peakRate, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->peakRate); + + invokeEndElement (pctxt, "peakRate", -1); + } + + /* decode minPoliced */ + + if (pvalue->m.minPolicedPresent) { + invokeStartElement (pctxt, "minPoliced", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->minPoliced, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->minPoliced); + + invokeEndElement (pctxt, "minPoliced", -1); + } + + /* decode maxPktSize */ + + if (pvalue->m.maxPktSizePresent) { + invokeStartElement (pctxt, "maxPktSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->maxPktSize, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxPktSize); + + invokeEndElement (pctxt, "maxPktSize", -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); +} + +/**************************************************************/ +/* */ +/* ATMParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ATMParameters (OOCTXT* pctxt, H245ATMParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode maxNTUSize */ + + invokeStartElement (pctxt, "maxNTUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maxNTUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxNTUSize); + + invokeEndElement (pctxt, "maxNTUSize", -1); + + /* decode atmUBR */ + + invokeStartElement (pctxt, "atmUBR", -1); + + stat = DECODEBIT (pctxt, &pvalue->atmUBR); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->atmUBR); + + invokeEndElement (pctxt, "atmUBR", -1); + + /* decode atmrtVBR */ + + invokeStartElement (pctxt, "atmrtVBR", -1); + + stat = DECODEBIT (pctxt, &pvalue->atmrtVBR); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->atmrtVBR); + + invokeEndElement (pctxt, "atmrtVBR", -1); + + /* decode atmnrtVBR */ + + invokeStartElement (pctxt, "atmnrtVBR", -1); + + stat = DECODEBIT (pctxt, &pvalue->atmnrtVBR); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->atmnrtVBR); + + invokeEndElement (pctxt, "atmnrtVBR", -1); + + /* decode atmABR */ + + invokeStartElement (pctxt, "atmABR", -1); + + stat = DECODEBIT (pctxt, &pvalue->atmABR); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->atmABR); + + invokeEndElement (pctxt, "atmABR", -1); + + /* decode atmCBR */ + + invokeStartElement (pctxt, "atmCBR", -1); + + stat = DECODEBIT (pctxt, &pvalue->atmCBR); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->atmCBR); + + invokeEndElement (pctxt, "atmCBR", -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); +} + +/**************************************************************/ +/* */ +/* QOSCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245QOSCapability (OOCTXT* pctxt, H245QOSCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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.rsvpParametersPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.atmParametersPresent = optbit; + + /* decode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + invokeStartElement (pctxt, "nonStandardData", -1); + + stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandardData", -1); + } + + /* decode rsvpParameters */ + + if (pvalue->m.rsvpParametersPresent) { + invokeStartElement (pctxt, "rsvpParameters", -1); + + stat = asn1PD_H245RSVPParameters (pctxt, &pvalue->rsvpParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rsvpParameters", -1); + } + + /* decode atmParameters */ + + if (pvalue->m.atmParametersPresent) { + invokeStartElement (pctxt, "atmParameters", -1); + + stat = asn1PD_H245ATMParameters (pctxt, &pvalue->atmParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "atmParameters", -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); +} + +/**************************************************************/ +/* */ +/* TransportCapability_qOSCapabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TransportCapability_qOSCapabilities (OOCTXT* pctxt, H245TransportCapability_qOSCapabilities* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245QOSCapability* 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, H245QOSCapability); + + stat = asn1PD_H245QOSCapability (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaTransportType_atm_AAL5_compressed */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MediaTransportType_atm_AAL5_compressed (OOCTXT* pctxt, H245MediaTransportType_atm_AAL5_compressed* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode variable_delta */ + + invokeStartElement (pctxt, "variable_delta", -1); + + stat = DECODEBIT (pctxt, &pvalue->variable_delta); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->variable_delta); + + invokeEndElement (pctxt, "variable_delta", -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); +} + +/**************************************************************/ +/* */ +/* MediaTransportType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MediaTransportType (OOCTXT* pctxt, H245MediaTransportType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* ip_UDP */ + case 0: + invokeStartElement (pctxt, "ip_UDP", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "ip_UDP", -1); + + break; + + /* ip_TCP */ + case 1: + invokeStartElement (pctxt, "ip_TCP", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "ip_TCP", -1); + + break; + + /* atm_AAL5_UNIDIR */ + case 2: + invokeStartElement (pctxt, "atm_AAL5_UNIDIR", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "atm_AAL5_UNIDIR", -1); + + break; + + /* atm_AAL5_BIDIR */ + case 3: + invokeStartElement (pctxt, "atm_AAL5_BIDIR", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "atm_AAL5_BIDIR", -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) { + /* atm_AAL5_compressed */ + case 5: + invokeStartElement (pctxt, "atm_AAL5_compressed", -1); + + pvalue->u.atm_AAL5_compressed = ALLOC_ASN1ELEM (pctxt, H245MediaTransportType_atm_AAL5_compressed); + + stat = asn1PD_H245MediaTransportType_atm_AAL5_compressed (pctxt, pvalue->u.atm_AAL5_compressed); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "atm_AAL5_compressed", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaChannelCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MediaChannelCapability (OOCTXT* pctxt, H245MediaChannelCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaTransportPresent = optbit; + + /* decode mediaTransport */ + + if (pvalue->m.mediaTransportPresent) { + invokeStartElement (pctxt, "mediaTransport", -1); + + stat = asn1PD_H245MediaTransportType (pctxt, &pvalue->mediaTransport); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaTransport", -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); +} + +/**************************************************************/ +/* */ +/* TransportCapability_mediaChannelCapabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TransportCapability_mediaChannelCapabilities (OOCTXT* pctxt, H245TransportCapability_mediaChannelCapabilities* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245MediaChannelCapability* 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, H245MediaChannelCapability); + + stat = asn1PD_H245MediaChannelCapability (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TransportCapability (OOCTXT* pctxt, H245TransportCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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.qOSCapabilitiesPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaChannelCapabilitiesPresent = optbit; + + /* decode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + invokeStartElement (pctxt, "nonStandard", -1); + + stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + } + + /* decode qOSCapabilities */ + + if (pvalue->m.qOSCapabilitiesPresent) { + invokeStartElement (pctxt, "qOSCapabilities", -1); + + stat = asn1PD_H245TransportCapability_qOSCapabilities (pctxt, &pvalue->qOSCapabilities); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "qOSCapabilities", -1); + } + + /* decode mediaChannelCapabilities */ + + if (pvalue->m.mediaChannelCapabilitiesPresent) { + invokeStartElement (pctxt, "mediaChannelCapabilities", -1); + + stat = asn1PD_H245TransportCapability_mediaChannelCapabilities (pctxt, &pvalue->mediaChannelCapabilities); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaChannelCapabilities", -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); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyFrameMapping_frameSequence */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RTPH263VideoRedundancyFrameMapping_frameSequence (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping_frameSequence* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = decodeConsUInt8 (pctxt, &pvalue->elem[xx1], 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->elem[xx1]); + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyFrameMapping */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RTPH263VideoRedundancyFrameMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode threadNumber */ + + invokeStartElement (pctxt, "threadNumber", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->threadNumber, 0U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->threadNumber); + + invokeEndElement (pctxt, "threadNumber", -1); + + /* decode frameSequence */ + + invokeStartElement (pctxt, "frameSequence", -1); + + stat = asn1PD_H245RTPH263VideoRedundancyFrameMapping_frameSequence (pctxt, &pvalue->frameSequence); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "frameSequence", -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); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_frameToThreadMapping_cust */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245RTPH263VideoRedundancyFrameMapping* 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, H245RTPH263VideoRedundancyFrameMapping); + + stat = asn1PD_H245RTPH263VideoRedundancyFrameMapping (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_frameToThreadMapping */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* roundrobin */ + case 0: + invokeStartElement (pctxt, "roundrobin", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "roundrobin", -1); + + break; + + /* custom */ + case 1: + invokeStartElement (pctxt, "custom", -1); + + pvalue->u.custom = ALLOC_ASN1ELEM (pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom); + + stat = asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (pctxt, pvalue->u.custom); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "custom", -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); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_containedThreads */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding_containedThreads (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_containedThreads* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = decodeConsUInt8 (pctxt, &pvalue->elem[xx1], 0U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->elem[xx1]); + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RTPH263VideoRedundancyEncoding (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.containedThreadsPresent = optbit; + + /* decode numberOfThreads */ + + invokeStartElement (pctxt, "numberOfThreads", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->numberOfThreads, 1U, 16U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfThreads); + + invokeEndElement (pctxt, "numberOfThreads", -1); + + /* decode framesBetweenSyncPoints */ + + invokeStartElement (pctxt, "framesBetweenSyncPoints", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->framesBetweenSyncPoints, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->framesBetweenSyncPoints); + + invokeEndElement (pctxt, "framesBetweenSyncPoints", -1); + + /* decode frameToThreadMapping */ + + invokeStartElement (pctxt, "frameToThreadMapping", -1); + + stat = asn1PD_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (pctxt, &pvalue->frameToThreadMapping); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "frameToThreadMapping", -1); + + /* decode containedThreads */ + + if (pvalue->m.containedThreadsPresent) { + invokeStartElement (pctxt, "containedThreads", -1); + + stat = asn1PD_H245RTPH263VideoRedundancyEncoding_containedThreads (pctxt, &pvalue->containedThreads); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "containedThreads", -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); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingMethod */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingMethod (OOCTXT* pctxt, H245RedundancyEncodingMethod* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* rtpAudioRedundancyEncoding */ + case 1: + invokeStartElement (pctxt, "rtpAudioRedundancyEncoding", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "rtpAudioRedundancyEncoding", -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) { + /* rtpH263VideoRedundancyEncoding */ + case 3: + invokeStartElement (pctxt, "rtpH263VideoRedundancyEncoding", -1); + + pvalue->u.rtpH263VideoRedundancyEncoding = ALLOC_ASN1ELEM (pctxt, H245RTPH263VideoRedundancyEncoding); + + stat = asn1PD_H245RTPH263VideoRedundancyEncoding (pctxt, pvalue->u.rtpH263VideoRedundancyEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rtpH263VideoRedundancyEncoding", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityTableEntryNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CapabilityTableEntryNumber (OOCTXT* pctxt, H245CapabilityTableEntryNumber* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUInt16 (pctxt, pvalue, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingCapability_secondaryEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingCapability_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingCapability_secondaryEncoding* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingCapability (OOCTXT* pctxt, H245RedundancyEncodingCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.secondaryEncodingPresent = optbit; + + /* decode redundancyEncodingMethod */ + + invokeStartElement (pctxt, "redundancyEncodingMethod", -1); + + stat = asn1PD_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncodingMethod", -1); + + /* decode primaryEncoding */ + + invokeStartElement (pctxt, "primaryEncoding", -1); + + stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->primaryEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "primaryEncoding", -1); + + /* decode secondaryEncoding */ + + if (pvalue->m.secondaryEncodingPresent) { + invokeStartElement (pctxt, "secondaryEncoding", -1); + + stat = asn1PD_H245RedundancyEncodingCapability_secondaryEncoding (pctxt, &pvalue->secondaryEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "secondaryEncoding", -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); +} + +/**************************************************************/ +/* */ +/* H2250Capability_redundancyEncodingCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H2250Capability_redundancyEncodingCapability (OOCTXT* pctxt, H245H2250Capability_redundancyEncodingCapability* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245RedundancyEncodingCapability* 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, H245RedundancyEncodingCapability); + + stat = asn1PD_H245RedundancyEncodingCapability (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H2250Capability (OOCTXT* pctxt, H245H2250Capability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode maximumAudioDelayJitter */ + + invokeStartElement (pctxt, "maximumAudioDelayJitter", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumAudioDelayJitter, 0U, 1023U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumAudioDelayJitter); + + invokeEndElement (pctxt, "maximumAudioDelayJitter", -1); + + /* decode receiveMultipointCapability */ + + invokeStartElement (pctxt, "receiveMultipointCapability", -1); + + stat = asn1PD_H245MultipointCapability (pctxt, &pvalue->receiveMultipointCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveMultipointCapability", -1); + + /* decode transmitMultipointCapability */ + + invokeStartElement (pctxt, "transmitMultipointCapability", -1); + + stat = asn1PD_H245MultipointCapability (pctxt, &pvalue->transmitMultipointCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transmitMultipointCapability", -1); + + /* decode receiveAndTransmitMultipointCapability */ + + invokeStartElement (pctxt, "receiveAndTransmitMultipointCapability", -1); + + stat = asn1PD_H245MultipointCapability (pctxt, &pvalue->receiveAndTransmitMultipointCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveAndTransmitMultipointCapability", -1); + + /* decode mcCapability */ + + invokeStartElement (pctxt, "mcCapability", -1); + + stat = asn1PD_H245H2250Capability_mcCapability (pctxt, &pvalue->mcCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mcCapability", -1); + + /* decode rtcpVideoControlCapability */ + + invokeStartElement (pctxt, "rtcpVideoControlCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->rtcpVideoControlCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->rtcpVideoControlCapability); + + invokeEndElement (pctxt, "rtcpVideoControlCapability", -1); + + /* decode mediaPacketizationCapability */ + + invokeStartElement (pctxt, "mediaPacketizationCapability", -1); + + stat = asn1PD_H245MediaPacketizationCapability (pctxt, &pvalue->mediaPacketizationCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaPacketizationCapability", -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.transportCapabilityPresent = 1; + + invokeStartElement (pctxt, "transportCapability", -1); + + stat = asn1PD_H245TransportCapability (pctxt, &pvalue->transportCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transportCapability", -1); + break; + + case 1: + pvalue->m.redundancyEncodingCapabilityPresent = 1; + + invokeStartElement (pctxt, "redundancyEncodingCapability", -1); + + stat = asn1PD_H245H2250Capability_redundancyEncodingCapability (pctxt, &pvalue->redundancyEncodingCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncodingCapability", -1); + break; + + case 2: + pvalue->m.logicalChannelSwitchingCapabilityPresent = 1; + + invokeStartElement (pctxt, "logicalChannelSwitchingCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->logicalChannelSwitchingCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->logicalChannelSwitchingCapability); + + invokeEndElement (pctxt, "logicalChannelSwitchingCapability", -1); + break; + + case 3: + pvalue->m.t120DynamicPortCapabilityPresent = 1; + + invokeStartElement (pctxt, "t120DynamicPortCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->t120DynamicPortCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->t120DynamicPortCapability); + + invokeEndElement (pctxt, "t120DynamicPortCapability", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexCapability (OOCTXT* pctxt, H245MultiplexCapability* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* h222Capability */ + case 1: + invokeStartElement (pctxt, "h222Capability", -1); + + pvalue->u.h222Capability = ALLOC_ASN1ELEM (pctxt, H245H222Capability); + + stat = asn1PD_H245H222Capability (pctxt, pvalue->u.h222Capability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h222Capability", -1); + + break; + + /* h223Capability */ + case 2: + invokeStartElement (pctxt, "h223Capability", -1); + + pvalue->u.h223Capability = ALLOC_ASN1ELEM (pctxt, H245H223Capability); + + stat = asn1PD_H245H223Capability (pctxt, pvalue->u.h223Capability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223Capability", -1); + + break; + + /* v76Capability */ + case 3: + invokeStartElement (pctxt, "v76Capability", -1); + + pvalue->u.v76Capability = ALLOC_ASN1ELEM (pctxt, H245V76Capability); + + stat = asn1PD_H245V76Capability (pctxt, pvalue->u.v76Capability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "v76Capability", -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) { + /* h2250Capability */ + case 5: + invokeStartElement (pctxt, "h2250Capability", -1); + + pvalue->u.h2250Capability = ALLOC_ASN1ELEM (pctxt, H245H2250Capability); + + stat = asn1PD_H245H2250Capability (pctxt, pvalue->u.h2250Capability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h2250Capability", -1); + + break; + + /* genericMultiplexCapability */ + case 6: + invokeStartElement (pctxt, "genericMultiplexCapability", -1); + + pvalue->u.genericMultiplexCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability); + + stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericMultiplexCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericMultiplexCapability", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H261VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H261VideoCapability (OOCTXT* pctxt, H245H261VideoCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.qcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cifMPIPresent = optbit; + + /* decode qcifMPI */ + + if (pvalue->m.qcifMPIPresent) { + invokeStartElement (pctxt, "qcifMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->qcifMPI, 1U, 4U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->qcifMPI); + + invokeEndElement (pctxt, "qcifMPI", -1); + } + + /* decode cifMPI */ + + if (pvalue->m.cifMPIPresent) { + invokeStartElement (pctxt, "cifMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->cifMPI, 1U, 4U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cifMPI); + + invokeEndElement (pctxt, "cifMPI", -1); + } + + /* decode temporalSpatialTradeOffCapability */ + + invokeStartElement (pctxt, "temporalSpatialTradeOffCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->temporalSpatialTradeOffCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->temporalSpatialTradeOffCapability); + + invokeEndElement (pctxt, "temporalSpatialTradeOffCapability", -1); + + /* decode maxBitRate */ + + invokeStartElement (pctxt, "maxBitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maxBitRate, 1U, 19200U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxBitRate); + + invokeEndElement (pctxt, "maxBitRate", -1); + + /* decode stillImageTransmission */ + + invokeStartElement (pctxt, "stillImageTransmission", -1); + + stat = DECODEBIT (pctxt, &pvalue->stillImageTransmission); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->stillImageTransmission); + + invokeEndElement (pctxt, "stillImageTransmission", -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.videoBadMBsCapPresent = 1; + + invokeStartElement (pctxt, "videoBadMBsCap", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoBadMBsCap); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoBadMBsCap); + + invokeEndElement (pctxt, "videoBadMBsCap", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H262VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H262VideoCapability (OOCTXT* pctxt, H245H262VideoCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.videoBitRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.vbvBufferSizePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.samplesPerLinePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.linesPerFramePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.framesPerSecondPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.luminanceSampleRatePresent = optbit; + + /* decode profileAndLevel_SPatML */ + + invokeStartElement (pctxt, "profileAndLevel_SPatML", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_SPatML); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_SPatML); + + invokeEndElement (pctxt, "profileAndLevel_SPatML", -1); + + /* decode profileAndLevel_MPatLL */ + + invokeStartElement (pctxt, "profileAndLevel_MPatLL", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_MPatLL); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_MPatLL); + + invokeEndElement (pctxt, "profileAndLevel_MPatLL", -1); + + /* decode profileAndLevel_MPatML */ + + invokeStartElement (pctxt, "profileAndLevel_MPatML", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_MPatML); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_MPatML); + + invokeEndElement (pctxt, "profileAndLevel_MPatML", -1); + + /* decode profileAndLevel_MPatH_14 */ + + invokeStartElement (pctxt, "profileAndLevel_MPatH_14", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_MPatH_14); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_MPatH_14); + + invokeEndElement (pctxt, "profileAndLevel_MPatH_14", -1); + + /* decode profileAndLevel_MPatHL */ + + invokeStartElement (pctxt, "profileAndLevel_MPatHL", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_MPatHL); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_MPatHL); + + invokeEndElement (pctxt, "profileAndLevel_MPatHL", -1); + + /* decode profileAndLevel_SNRatLL */ + + invokeStartElement (pctxt, "profileAndLevel_SNRatLL", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_SNRatLL); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_SNRatLL); + + invokeEndElement (pctxt, "profileAndLevel_SNRatLL", -1); + + /* decode profileAndLevel_SNRatML */ + + invokeStartElement (pctxt, "profileAndLevel_SNRatML", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_SNRatML); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_SNRatML); + + invokeEndElement (pctxt, "profileAndLevel_SNRatML", -1); + + /* decode profileAndLevel_SpatialatH_14 */ + + invokeStartElement (pctxt, "profileAndLevel_SpatialatH_14", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_SpatialatH_14); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_SpatialatH_14); + + invokeEndElement (pctxt, "profileAndLevel_SpatialatH_14", -1); + + /* decode profileAndLevel_HPatML */ + + invokeStartElement (pctxt, "profileAndLevel_HPatML", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_HPatML); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_HPatML); + + invokeEndElement (pctxt, "profileAndLevel_HPatML", -1); + + /* decode profileAndLevel_HPatH_14 */ + + invokeStartElement (pctxt, "profileAndLevel_HPatH_14", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_HPatH_14); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_HPatH_14); + + invokeEndElement (pctxt, "profileAndLevel_HPatH_14", -1); + + /* decode profileAndLevel_HPatHL */ + + invokeStartElement (pctxt, "profileAndLevel_HPatHL", -1); + + stat = DECODEBIT (pctxt, &pvalue->profileAndLevel_HPatHL); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->profileAndLevel_HPatHL); + + invokeEndElement (pctxt, "profileAndLevel_HPatHL", -1); + + /* decode videoBitRate */ + + if (pvalue->m.videoBitRatePresent) { + invokeStartElement (pctxt, "videoBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->videoBitRate, 0U, 1073741823U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->videoBitRate); + + invokeEndElement (pctxt, "videoBitRate", -1); + } + + /* decode vbvBufferSize */ + + if (pvalue->m.vbvBufferSizePresent) { + invokeStartElement (pctxt, "vbvBufferSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->vbvBufferSize, 0U, 262143U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->vbvBufferSize); + + invokeEndElement (pctxt, "vbvBufferSize", -1); + } + + /* decode samplesPerLine */ + + if (pvalue->m.samplesPerLinePresent) { + invokeStartElement (pctxt, "samplesPerLine", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->samplesPerLine, 0U, 16383U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->samplesPerLine); + + invokeEndElement (pctxt, "samplesPerLine", -1); + } + + /* decode linesPerFrame */ + + if (pvalue->m.linesPerFramePresent) { + invokeStartElement (pctxt, "linesPerFrame", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->linesPerFrame, 0U, 16383U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->linesPerFrame); + + invokeEndElement (pctxt, "linesPerFrame", -1); + } + + /* decode framesPerSecond */ + + if (pvalue->m.framesPerSecondPresent) { + invokeStartElement (pctxt, "framesPerSecond", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->framesPerSecond, 0U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->framesPerSecond); + + invokeEndElement (pctxt, "framesPerSecond", -1); + } + + /* decode luminanceSampleRate */ + + if (pvalue->m.luminanceSampleRatePresent) { + invokeStartElement (pctxt, "luminanceSampleRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->luminanceSampleRate); + + invokeEndElement (pctxt, "luminanceSampleRate", -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.videoBadMBsCapPresent = 1; + + invokeStartElement (pctxt, "videoBadMBsCap", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoBadMBsCap); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoBadMBsCap); + + invokeEndElement (pctxt, "videoBadMBsCap", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransparencyParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TransparencyParameters (OOCTXT* pctxt, H245TransparencyParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode presentationOrder */ + + invokeStartElement (pctxt, "presentationOrder", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->presentationOrder, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->presentationOrder); + + invokeEndElement (pctxt, "presentationOrder", -1); + + /* decode offset_x */ + + invokeStartElement (pctxt, "offset_x", -1); + + stat = decodeConsInteger (pctxt, &pvalue->offset_x, -262144, 262143); + if (stat != ASN_OK) return stat; + invokeIntValue (pctxt, pvalue->offset_x); + + invokeEndElement (pctxt, "offset_x", -1); + + /* decode offset_y */ + + invokeStartElement (pctxt, "offset_y", -1); + + stat = decodeConsInteger (pctxt, &pvalue->offset_y, -262144, 262143); + if (stat != ASN_OK) return stat; + invokeIntValue (pctxt, pvalue->offset_y); + + invokeEndElement (pctxt, "offset_y", -1); + + /* decode scale_x */ + + invokeStartElement (pctxt, "scale_x", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->scale_x, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->scale_x); + + invokeEndElement (pctxt, "scale_x", -1); + + /* decode scale_y */ + + invokeStartElement (pctxt, "scale_y", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->scale_y, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->scale_y); + + invokeEndElement (pctxt, "scale_y", -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); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection_additionalPictureMemory */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RefPictureSelection_additionalPictureMemory (OOCTXT* pctxt, H245RefPictureSelection_additionalPictureMemory* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.sqcifAdditionalPictureMemoryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.qcifAdditionalPictureMemoryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cifAdditionalPictureMemoryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cif4AdditionalPictureMemoryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cif16AdditionalPictureMemoryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.bigCpfAdditionalPictureMemoryPresent = optbit; + + /* decode sqcifAdditionalPictureMemory */ + + if (pvalue->m.sqcifAdditionalPictureMemoryPresent) { + invokeStartElement (pctxt, "sqcifAdditionalPictureMemory", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->sqcifAdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sqcifAdditionalPictureMemory); + + invokeEndElement (pctxt, "sqcifAdditionalPictureMemory", -1); + } + + /* decode qcifAdditionalPictureMemory */ + + if (pvalue->m.qcifAdditionalPictureMemoryPresent) { + invokeStartElement (pctxt, "qcifAdditionalPictureMemory", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->qcifAdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->qcifAdditionalPictureMemory); + + invokeEndElement (pctxt, "qcifAdditionalPictureMemory", -1); + } + + /* decode cifAdditionalPictureMemory */ + + if (pvalue->m.cifAdditionalPictureMemoryPresent) { + invokeStartElement (pctxt, "cifAdditionalPictureMemory", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->cifAdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cifAdditionalPictureMemory); + + invokeEndElement (pctxt, "cifAdditionalPictureMemory", -1); + } + + /* decode cif4AdditionalPictureMemory */ + + if (pvalue->m.cif4AdditionalPictureMemoryPresent) { + invokeStartElement (pctxt, "cif4AdditionalPictureMemory", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->cif4AdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cif4AdditionalPictureMemory); + + invokeEndElement (pctxt, "cif4AdditionalPictureMemory", -1); + } + + /* decode cif16AdditionalPictureMemory */ + + if (pvalue->m.cif16AdditionalPictureMemoryPresent) { + invokeStartElement (pctxt, "cif16AdditionalPictureMemory", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->cif16AdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cif16AdditionalPictureMemory); + + invokeEndElement (pctxt, "cif16AdditionalPictureMemory", -1); + } + + /* decode bigCpfAdditionalPictureMemory */ + + if (pvalue->m.bigCpfAdditionalPictureMemoryPresent) { + invokeStartElement (pctxt, "bigCpfAdditionalPictureMemory", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bigCpfAdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bigCpfAdditionalPictureMemory); + + invokeEndElement (pctxt, "bigCpfAdditionalPictureMemory", -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); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection_videoBackChannelSend */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RefPictureSelection_videoBackChannelSend (OOCTXT* pctxt, H245RefPictureSelection_videoBackChannelSend* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* none */ + case 0: + invokeStartElement (pctxt, "none", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "none", -1); + + break; + + /* ackMessageOnly */ + case 1: + invokeStartElement (pctxt, "ackMessageOnly", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "ackMessageOnly", -1); + + break; + + /* nackMessageOnly */ + case 2: + invokeStartElement (pctxt, "nackMessageOnly", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "nackMessageOnly", -1); + + break; + + /* ackOrNackMessageOnly */ + case 3: + invokeStartElement (pctxt, "ackOrNackMessageOnly", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "ackOrNackMessageOnly", -1); + + break; + + /* ackAndNackMessage */ + case 4: + invokeStartElement (pctxt, "ackAndNackMessage", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "ackAndNackMessage", -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); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection_enhancedReferencePicSelect_subPictur */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode mpuHorizMBs */ + + invokeStartElement (pctxt, "mpuHorizMBs", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->mpuHorizMBs, 1U, 128U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->mpuHorizMBs); + + invokeEndElement (pctxt, "mpuHorizMBs", -1); + + /* decode mpuVertMBs */ + + invokeStartElement (pctxt, "mpuVertMBs", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->mpuVertMBs, 1U, 72U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->mpuVertMBs); + + invokeEndElement (pctxt, "mpuVertMBs", -1); + + /* decode mpuTotalNumber */ + + invokeStartElement (pctxt, "mpuTotalNumber", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->mpuTotalNumber, 1U, 65536U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->mpuTotalNumber); + + invokeEndElement (pctxt, "mpuTotalNumber", -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); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection_enhancedReferencePicSelect */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RefPictureSelection_enhancedReferencePicSelect (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.subPictureRemovalParametersPresent = optbit; + + /* decode subPictureRemovalParameters */ + + if (pvalue->m.subPictureRemovalParametersPresent) { + invokeStartElement (pctxt, "subPictureRemovalParameters", -1); + + stat = asn1PD_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (pctxt, &pvalue->subPictureRemovalParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "subPictureRemovalParameters", -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); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RefPictureSelection (OOCTXT* pctxt, H245RefPictureSelection* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.additionalPictureMemoryPresent = optbit; + + /* decode additionalPictureMemory */ + + if (pvalue->m.additionalPictureMemoryPresent) { + invokeStartElement (pctxt, "additionalPictureMemory", -1); + + stat = asn1PD_H245RefPictureSelection_additionalPictureMemory (pctxt, &pvalue->additionalPictureMemory); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "additionalPictureMemory", -1); + } + + /* decode videoMux */ + + invokeStartElement (pctxt, "videoMux", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoMux); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoMux); + + invokeEndElement (pctxt, "videoMux", -1); + + /* decode videoBackChannelSend */ + + invokeStartElement (pctxt, "videoBackChannelSend", -1); + + stat = asn1PD_H245RefPictureSelection_videoBackChannelSend (pctxt, &pvalue->videoBackChannelSend); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoBackChannelSend", -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.enhancedReferencePicSelectPresent = 1; + + invokeStartElement (pctxt, "enhancedReferencePicSelect", -1); + + stat = asn1PD_H245RefPictureSelection_enhancedReferencePicSelect (pctxt, &pvalue->enhancedReferencePicSelect); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "enhancedReferencePicSelect", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureClockFrequency */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureClockFrequency (OOCTXT* pctxt, H245CustomPictureClockFrequency* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.sqcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.qcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cif4MPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cif16MPIPresent = optbit; + + /* decode clockConversionCode */ + + invokeStartElement (pctxt, "clockConversionCode", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->clockConversionCode, 1000U, 1001U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->clockConversionCode); + + invokeEndElement (pctxt, "clockConversionCode", -1); + + /* decode clockDivisor */ + + invokeStartElement (pctxt, "clockDivisor", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->clockDivisor, 1U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->clockDivisor); + + invokeEndElement (pctxt, "clockDivisor", -1); + + /* decode sqcifMPI */ + + if (pvalue->m.sqcifMPIPresent) { + invokeStartElement (pctxt, "sqcifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->sqcifMPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sqcifMPI); + + invokeEndElement (pctxt, "sqcifMPI", -1); + } + + /* decode qcifMPI */ + + if (pvalue->m.qcifMPIPresent) { + invokeStartElement (pctxt, "qcifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->qcifMPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->qcifMPI); + + invokeEndElement (pctxt, "qcifMPI", -1); + } + + /* decode cifMPI */ + + if (pvalue->m.cifMPIPresent) { + invokeStartElement (pctxt, "cifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->cifMPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cifMPI); + + invokeEndElement (pctxt, "cifMPI", -1); + } + + /* decode cif4MPI */ + + if (pvalue->m.cif4MPIPresent) { + invokeStartElement (pctxt, "cif4MPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->cif4MPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cif4MPI); + + invokeEndElement (pctxt, "cif4MPI", -1); + } + + /* decode cif16MPI */ + + if (pvalue->m.cif16MPIPresent) { + invokeStartElement (pctxt, "cif16MPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->cif16MPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cif16MPI); + + invokeEndElement (pctxt, "cif16MPI", -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); +} + +/**************************************************************/ +/* */ +/* H263Options_customPictureClockFrequency */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263Options_customPictureClockFrequency (OOCTXT* pctxt, H245H263Options_customPictureClockFrequency* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + H245CustomPictureClockFrequency* 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, H245CustomPictureClockFrequency); + + stat = asn1PD_H245CustomPictureClockFrequency (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI_customPCF_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureFormat_mPI_customPCF_element (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF_element* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode clockConversionCode */ + + invokeStartElement (pctxt, "clockConversionCode", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->clockConversionCode, 1000U, 1001U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->clockConversionCode); + + invokeEndElement (pctxt, "clockConversionCode", -1); + + /* decode clockDivisor */ + + invokeStartElement (pctxt, "clockDivisor", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->clockDivisor, 1U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->clockDivisor); + + invokeEndElement (pctxt, "clockDivisor", -1); + + /* decode customMPI */ + + invokeStartElement (pctxt, "customMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->customMPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->customMPI); + + invokeEndElement (pctxt, "customMPI", -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); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI_customPCF */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureFormat_mPI_customPCF (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + H245CustomPictureFormat_mPI_customPCF_element* 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, H245CustomPictureFormat_mPI_customPCF_element); + + stat = asn1PD_H245CustomPictureFormat_mPI_customPCF_element (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureFormat_mPI (OOCTXT* pctxt, H245CustomPictureFormat_mPI* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.standardMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.customPCFPresent = optbit; + + /* decode standardMPI */ + + if (pvalue->m.standardMPIPresent) { + invokeStartElement (pctxt, "standardMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->standardMPI, 1U, 31U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->standardMPI); + + invokeEndElement (pctxt, "standardMPI", -1); + } + + /* decode customPCF */ + + if (pvalue->m.customPCFPresent) { + invokeStartElement (pctxt, "customPCF", -1); + + stat = asn1PD_H245CustomPictureFormat_mPI_customPCF (pctxt, &pvalue->customPCF); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "customPCF", -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); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_pixelAspectCo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = decodeConsUInt8 (pctxt, &pvalue->elem[xx1], 1U, 14U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->elem[xx1]); + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_extendedPAR_e */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode width */ + + invokeStartElement (pctxt, "width", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->width, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->width); + + invokeEndElement (pctxt, "width", -1); + + /* decode height */ + + invokeStartElement (pctxt, "height", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->height, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->height); + + invokeEndElement (pctxt, "height", -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); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_extendedPAR */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* 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, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element); + + stat = asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureFormat_pixelAspectInformation (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* anyPixelAspectRatio */ + case 0: + invokeStartElement (pctxt, "anyPixelAspectRatio", -1); + + stat = DECODEBIT (pctxt, &pvalue->u.anyPixelAspectRatio); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->u.anyPixelAspectRatio); + + invokeEndElement (pctxt, "anyPixelAspectRatio", -1); + + break; + + /* pixelAspectCode */ + case 1: + invokeStartElement (pctxt, "pixelAspectCode", -1); + + pvalue->u.pixelAspectCode = ALLOC_ASN1ELEM (pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode); + + stat = asn1PD_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (pctxt, pvalue->u.pixelAspectCode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "pixelAspectCode", -1); + + break; + + /* extendedPAR */ + case 2: + invokeStartElement (pctxt, "extendedPAR", -1); + + pvalue->u.extendedPAR = ALLOC_ASN1ELEM (pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR); + + stat = asn1PD_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (pctxt, pvalue->u.extendedPAR); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "extendedPAR", -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); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CustomPictureFormat (OOCTXT* pctxt, H245CustomPictureFormat* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode maxCustomPictureWidth */ + + invokeStartElement (pctxt, "maxCustomPictureWidth", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maxCustomPictureWidth, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxCustomPictureWidth); + + invokeEndElement (pctxt, "maxCustomPictureWidth", -1); + + /* decode maxCustomPictureHeight */ + + invokeStartElement (pctxt, "maxCustomPictureHeight", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maxCustomPictureHeight, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxCustomPictureHeight); + + invokeEndElement (pctxt, "maxCustomPictureHeight", -1); + + /* decode minCustomPictureWidth */ + + invokeStartElement (pctxt, "minCustomPictureWidth", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->minCustomPictureWidth, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->minCustomPictureWidth); + + invokeEndElement (pctxt, "minCustomPictureWidth", -1); + + /* decode minCustomPictureHeight */ + + invokeStartElement (pctxt, "minCustomPictureHeight", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->minCustomPictureHeight, 1U, 2048U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->minCustomPictureHeight); + + invokeEndElement (pctxt, "minCustomPictureHeight", -1); + + /* decode mPI */ + + invokeStartElement (pctxt, "mPI", -1); + + stat = asn1PD_H245CustomPictureFormat_mPI (pctxt, &pvalue->mPI); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mPI", -1); + + /* decode pixelAspectInformation */ + + invokeStartElement (pctxt, "pixelAspectInformation", -1); + + stat = asn1PD_H245CustomPictureFormat_pixelAspectInformation (pctxt, &pvalue->pixelAspectInformation); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "pixelAspectInformation", -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); +} + +/**************************************************************/ +/* */ +/* H263Options_customPictureFormat */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263Options_customPictureFormat (OOCTXT* pctxt, H245H263Options_customPictureFormat* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + H245CustomPictureFormat* 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, H245CustomPictureFormat); + + stat = asn1PD_H245CustomPictureFormat (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263Version3Options */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263Version3Options (OOCTXT* pctxt, H245H263Version3Options* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode dataPartitionedSlices */ + + invokeStartElement (pctxt, "dataPartitionedSlices", -1); + + stat = DECODEBIT (pctxt, &pvalue->dataPartitionedSlices); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dataPartitionedSlices); + + invokeEndElement (pctxt, "dataPartitionedSlices", -1); + + /* decode fixedPointIDCT0 */ + + invokeStartElement (pctxt, "fixedPointIDCT0", -1); + + stat = DECODEBIT (pctxt, &pvalue->fixedPointIDCT0); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fixedPointIDCT0); + + invokeEndElement (pctxt, "fixedPointIDCT0", -1); + + /* decode interlacedFields */ + + invokeStartElement (pctxt, "interlacedFields", -1); + + stat = DECODEBIT (pctxt, &pvalue->interlacedFields); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->interlacedFields); + + invokeEndElement (pctxt, "interlacedFields", -1); + + /* decode currentPictureHeaderRepetition */ + + invokeStartElement (pctxt, "currentPictureHeaderRepetition", -1); + + stat = DECODEBIT (pctxt, &pvalue->currentPictureHeaderRepetition); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->currentPictureHeaderRepetition); + + invokeEndElement (pctxt, "currentPictureHeaderRepetition", -1); + + /* decode previousPictureHeaderRepetition */ + + invokeStartElement (pctxt, "previousPictureHeaderRepetition", -1); + + stat = DECODEBIT (pctxt, &pvalue->previousPictureHeaderRepetition); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->previousPictureHeaderRepetition); + + invokeEndElement (pctxt, "previousPictureHeaderRepetition", -1); + + /* decode nextPictureHeaderRepetition */ + + invokeStartElement (pctxt, "nextPictureHeaderRepetition", -1); + + stat = DECODEBIT (pctxt, &pvalue->nextPictureHeaderRepetition); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->nextPictureHeaderRepetition); + + invokeEndElement (pctxt, "nextPictureHeaderRepetition", -1); + + /* decode pictureNumber */ + + invokeStartElement (pctxt, "pictureNumber", -1); + + stat = DECODEBIT (pctxt, &pvalue->pictureNumber); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->pictureNumber); + + invokeEndElement (pctxt, "pictureNumber", -1); + + /* decode spareReferencePictures */ + + invokeStartElement (pctxt, "spareReferencePictures", -1); + + stat = DECODEBIT (pctxt, &pvalue->spareReferencePictures); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->spareReferencePictures); + + invokeEndElement (pctxt, "spareReferencePictures", -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); +} + +/**************************************************************/ +/* */ +/* H263ModeComboFlags */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263ModeComboFlags (OOCTXT* pctxt, H245H263ModeComboFlags* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode unrestrictedVector */ + + invokeStartElement (pctxt, "unrestrictedVector", -1); + + stat = DECODEBIT (pctxt, &pvalue->unrestrictedVector); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->unrestrictedVector); + + invokeEndElement (pctxt, "unrestrictedVector", -1); + + /* decode arithmeticCoding */ + + invokeStartElement (pctxt, "arithmeticCoding", -1); + + stat = DECODEBIT (pctxt, &pvalue->arithmeticCoding); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->arithmeticCoding); + + invokeEndElement (pctxt, "arithmeticCoding", -1); + + /* decode advancedPrediction */ + + invokeStartElement (pctxt, "advancedPrediction", -1); + + stat = DECODEBIT (pctxt, &pvalue->advancedPrediction); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->advancedPrediction); + + invokeEndElement (pctxt, "advancedPrediction", -1); + + /* decode pbFrames */ + + invokeStartElement (pctxt, "pbFrames", -1); + + stat = DECODEBIT (pctxt, &pvalue->pbFrames); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->pbFrames); + + invokeEndElement (pctxt, "pbFrames", -1); + + /* decode advancedIntraCodingMode */ + + invokeStartElement (pctxt, "advancedIntraCodingMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->advancedIntraCodingMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->advancedIntraCodingMode); + + invokeEndElement (pctxt, "advancedIntraCodingMode", -1); + + /* decode deblockingFilterMode */ + + invokeStartElement (pctxt, "deblockingFilterMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->deblockingFilterMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->deblockingFilterMode); + + invokeEndElement (pctxt, "deblockingFilterMode", -1); + + /* decode unlimitedMotionVectors */ + + invokeStartElement (pctxt, "unlimitedMotionVectors", -1); + + stat = DECODEBIT (pctxt, &pvalue->unlimitedMotionVectors); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->unlimitedMotionVectors); + + invokeEndElement (pctxt, "unlimitedMotionVectors", -1); + + /* decode slicesInOrder_NonRect */ + + invokeStartElement (pctxt, "slicesInOrder_NonRect", -1); + + stat = DECODEBIT (pctxt, &pvalue->slicesInOrder_NonRect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->slicesInOrder_NonRect); + + invokeEndElement (pctxt, "slicesInOrder_NonRect", -1); + + /* decode slicesInOrder_Rect */ + + invokeStartElement (pctxt, "slicesInOrder_Rect", -1); + + stat = DECODEBIT (pctxt, &pvalue->slicesInOrder_Rect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->slicesInOrder_Rect); + + invokeEndElement (pctxt, "slicesInOrder_Rect", -1); + + /* decode slicesNoOrder_NonRect */ + + invokeStartElement (pctxt, "slicesNoOrder_NonRect", -1); + + stat = DECODEBIT (pctxt, &pvalue->slicesNoOrder_NonRect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->slicesNoOrder_NonRect); + + invokeEndElement (pctxt, "slicesNoOrder_NonRect", -1); + + /* decode slicesNoOrder_Rect */ + + invokeStartElement (pctxt, "slicesNoOrder_Rect", -1); + + stat = DECODEBIT (pctxt, &pvalue->slicesNoOrder_Rect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->slicesNoOrder_Rect); + + invokeEndElement (pctxt, "slicesNoOrder_Rect", -1); + + /* decode improvedPBFramesMode */ + + invokeStartElement (pctxt, "improvedPBFramesMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->improvedPBFramesMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->improvedPBFramesMode); + + invokeEndElement (pctxt, "improvedPBFramesMode", -1); + + /* decode referencePicSelect */ + + invokeStartElement (pctxt, "referencePicSelect", -1); + + stat = DECODEBIT (pctxt, &pvalue->referencePicSelect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->referencePicSelect); + + invokeEndElement (pctxt, "referencePicSelect", -1); + + /* decode dynamicPictureResizingByFour */ + + invokeStartElement (pctxt, "dynamicPictureResizingByFour", -1); + + stat = DECODEBIT (pctxt, &pvalue->dynamicPictureResizingByFour); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dynamicPictureResizingByFour); + + invokeEndElement (pctxt, "dynamicPictureResizingByFour", -1); + + /* decode dynamicPictureResizingSixteenthPel */ + + invokeStartElement (pctxt, "dynamicPictureResizingSixteenthPel", -1); + + stat = DECODEBIT (pctxt, &pvalue->dynamicPictureResizingSixteenthPel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dynamicPictureResizingSixteenthPel); + + invokeEndElement (pctxt, "dynamicPictureResizingSixteenthPel", -1); + + /* decode dynamicWarpingHalfPel */ + + invokeStartElement (pctxt, "dynamicWarpingHalfPel", -1); + + stat = DECODEBIT (pctxt, &pvalue->dynamicWarpingHalfPel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dynamicWarpingHalfPel); + + invokeEndElement (pctxt, "dynamicWarpingHalfPel", -1); + + /* decode dynamicWarpingSixteenthPel */ + + invokeStartElement (pctxt, "dynamicWarpingSixteenthPel", -1); + + stat = DECODEBIT (pctxt, &pvalue->dynamicWarpingSixteenthPel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dynamicWarpingSixteenthPel); + + invokeEndElement (pctxt, "dynamicWarpingSixteenthPel", -1); + + /* decode reducedResolutionUpdate */ + + invokeStartElement (pctxt, "reducedResolutionUpdate", -1); + + stat = DECODEBIT (pctxt, &pvalue->reducedResolutionUpdate); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->reducedResolutionUpdate); + + invokeEndElement (pctxt, "reducedResolutionUpdate", -1); + + /* decode independentSegmentDecoding */ + + invokeStartElement (pctxt, "independentSegmentDecoding", -1); + + stat = DECODEBIT (pctxt, &pvalue->independentSegmentDecoding); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->independentSegmentDecoding); + + invokeEndElement (pctxt, "independentSegmentDecoding", -1); + + /* decode alternateInterVLCMode */ + + invokeStartElement (pctxt, "alternateInterVLCMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->alternateInterVLCMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->alternateInterVLCMode); + + invokeEndElement (pctxt, "alternateInterVLCMode", -1); + + /* decode modifiedQuantizationMode */ + + invokeStartElement (pctxt, "modifiedQuantizationMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->modifiedQuantizationMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->modifiedQuantizationMode); + + invokeEndElement (pctxt, "modifiedQuantizationMode", -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.enhancedReferencePicSelectPresent = 1; + + invokeStartElement (pctxt, "enhancedReferencePicSelect", -1); + + stat = DECODEBIT (pctxt, &pvalue->enhancedReferencePicSelect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->enhancedReferencePicSelect); + + invokeEndElement (pctxt, "enhancedReferencePicSelect", -1); + break; + + case 1: + pvalue->m.h263Version3OptionsPresent = 1; + + invokeStartElement (pctxt, "h263Version3Options", -1); + + stat = asn1PD_H245H263Version3Options (pctxt, &pvalue->h263Version3Options); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263Version3Options", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263VideoModeCombos_h263VideoCoupledModes */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263VideoModeCombos_h263VideoCoupledModes (OOCTXT* pctxt, H245H263VideoModeCombos_h263VideoCoupledModes* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + H245H263ModeComboFlags* 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, H245H263ModeComboFlags); + + stat = asn1PD_H245H263ModeComboFlags (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263VideoModeCombos */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263VideoModeCombos (OOCTXT* pctxt, H245H263VideoModeCombos* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode h263VideoUncoupledModes */ + + invokeStartElement (pctxt, "h263VideoUncoupledModes", -1); + + stat = asn1PD_H245H263ModeComboFlags (pctxt, &pvalue->h263VideoUncoupledModes); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263VideoUncoupledModes", -1); + + /* decode h263VideoCoupledModes */ + + invokeStartElement (pctxt, "h263VideoCoupledModes", -1); + + stat = asn1PD_H245H263VideoModeCombos_h263VideoCoupledModes (pctxt, &pvalue->h263VideoCoupledModes); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263VideoCoupledModes", -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); +} + +/**************************************************************/ +/* */ +/* H263Options_modeCombos */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263Options_modeCombos (OOCTXT* pctxt, H245H263Options_modeCombos* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + H245H263VideoModeCombos* 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, H245H263VideoModeCombos); + + stat = asn1PD_H245H263VideoModeCombos (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263Options */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263Options (OOCTXT* pctxt, H245H263Options* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.transparencyParametersPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.refPictureSelectionPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.customPictureClockFrequencyPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.customPictureFormatPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.modeCombosPresent = optbit; + + /* decode advancedIntraCodingMode */ + + invokeStartElement (pctxt, "advancedIntraCodingMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->advancedIntraCodingMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->advancedIntraCodingMode); + + invokeEndElement (pctxt, "advancedIntraCodingMode", -1); + + /* decode deblockingFilterMode */ + + invokeStartElement (pctxt, "deblockingFilterMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->deblockingFilterMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->deblockingFilterMode); + + invokeEndElement (pctxt, "deblockingFilterMode", -1); + + /* decode improvedPBFramesMode */ + + invokeStartElement (pctxt, "improvedPBFramesMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->improvedPBFramesMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->improvedPBFramesMode); + + invokeEndElement (pctxt, "improvedPBFramesMode", -1); + + /* decode unlimitedMotionVectors */ + + invokeStartElement (pctxt, "unlimitedMotionVectors", -1); + + stat = DECODEBIT (pctxt, &pvalue->unlimitedMotionVectors); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->unlimitedMotionVectors); + + invokeEndElement (pctxt, "unlimitedMotionVectors", -1); + + /* decode fullPictureFreeze */ + + invokeStartElement (pctxt, "fullPictureFreeze", -1); + + stat = DECODEBIT (pctxt, &pvalue->fullPictureFreeze); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fullPictureFreeze); + + invokeEndElement (pctxt, "fullPictureFreeze", -1); + + /* decode partialPictureFreezeAndRelease */ + + invokeStartElement (pctxt, "partialPictureFreezeAndRelease", -1); + + stat = DECODEBIT (pctxt, &pvalue->partialPictureFreezeAndRelease); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->partialPictureFreezeAndRelease); + + invokeEndElement (pctxt, "partialPictureFreezeAndRelease", -1); + + /* decode resizingPartPicFreezeAndRelease */ + + invokeStartElement (pctxt, "resizingPartPicFreezeAndRelease", -1); + + stat = DECODEBIT (pctxt, &pvalue->resizingPartPicFreezeAndRelease); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->resizingPartPicFreezeAndRelease); + + invokeEndElement (pctxt, "resizingPartPicFreezeAndRelease", -1); + + /* decode fullPictureSnapshot */ + + invokeStartElement (pctxt, "fullPictureSnapshot", -1); + + stat = DECODEBIT (pctxt, &pvalue->fullPictureSnapshot); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fullPictureSnapshot); + + invokeEndElement (pctxt, "fullPictureSnapshot", -1); + + /* decode partialPictureSnapshot */ + + invokeStartElement (pctxt, "partialPictureSnapshot", -1); + + stat = DECODEBIT (pctxt, &pvalue->partialPictureSnapshot); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->partialPictureSnapshot); + + invokeEndElement (pctxt, "partialPictureSnapshot", -1); + + /* decode videoSegmentTagging */ + + invokeStartElement (pctxt, "videoSegmentTagging", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoSegmentTagging); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoSegmentTagging); + + invokeEndElement (pctxt, "videoSegmentTagging", -1); + + /* decode progressiveRefinement */ + + invokeStartElement (pctxt, "progressiveRefinement", -1); + + stat = DECODEBIT (pctxt, &pvalue->progressiveRefinement); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->progressiveRefinement); + + invokeEndElement (pctxt, "progressiveRefinement", -1); + + /* decode dynamicPictureResizingByFour */ + + invokeStartElement (pctxt, "dynamicPictureResizingByFour", -1); + + stat = DECODEBIT (pctxt, &pvalue->dynamicPictureResizingByFour); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dynamicPictureResizingByFour); + + invokeEndElement (pctxt, "dynamicPictureResizingByFour", -1); + + /* decode dynamicPictureResizingSixteenthPel */ + + invokeStartElement (pctxt, "dynamicPictureResizingSixteenthPel", -1); + + stat = DECODEBIT (pctxt, &pvalue->dynamicPictureResizingSixteenthPel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dynamicPictureResizingSixteenthPel); + + invokeEndElement (pctxt, "dynamicPictureResizingSixteenthPel", -1); + + /* decode dynamicWarpingHalfPel */ + + invokeStartElement (pctxt, "dynamicWarpingHalfPel", -1); + + stat = DECODEBIT (pctxt, &pvalue->dynamicWarpingHalfPel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dynamicWarpingHalfPel); + + invokeEndElement (pctxt, "dynamicWarpingHalfPel", -1); + + /* decode dynamicWarpingSixteenthPel */ + + invokeStartElement (pctxt, "dynamicWarpingSixteenthPel", -1); + + stat = DECODEBIT (pctxt, &pvalue->dynamicWarpingSixteenthPel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->dynamicWarpingSixteenthPel); + + invokeEndElement (pctxt, "dynamicWarpingSixteenthPel", -1); + + /* decode independentSegmentDecoding */ + + invokeStartElement (pctxt, "independentSegmentDecoding", -1); + + stat = DECODEBIT (pctxt, &pvalue->independentSegmentDecoding); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->independentSegmentDecoding); + + invokeEndElement (pctxt, "independentSegmentDecoding", -1); + + /* decode slicesInOrder_NonRect */ + + invokeStartElement (pctxt, "slicesInOrder_NonRect", -1); + + stat = DECODEBIT (pctxt, &pvalue->slicesInOrder_NonRect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->slicesInOrder_NonRect); + + invokeEndElement (pctxt, "slicesInOrder_NonRect", -1); + + /* decode slicesInOrder_Rect */ + + invokeStartElement (pctxt, "slicesInOrder_Rect", -1); + + stat = DECODEBIT (pctxt, &pvalue->slicesInOrder_Rect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->slicesInOrder_Rect); + + invokeEndElement (pctxt, "slicesInOrder_Rect", -1); + + /* decode slicesNoOrder_NonRect */ + + invokeStartElement (pctxt, "slicesNoOrder_NonRect", -1); + + stat = DECODEBIT (pctxt, &pvalue->slicesNoOrder_NonRect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->slicesNoOrder_NonRect); + + invokeEndElement (pctxt, "slicesNoOrder_NonRect", -1); + + /* decode slicesNoOrder_Rect */ + + invokeStartElement (pctxt, "slicesNoOrder_Rect", -1); + + stat = DECODEBIT (pctxt, &pvalue->slicesNoOrder_Rect); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->slicesNoOrder_Rect); + + invokeEndElement (pctxt, "slicesNoOrder_Rect", -1); + + /* decode alternateInterVLCMode */ + + invokeStartElement (pctxt, "alternateInterVLCMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->alternateInterVLCMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->alternateInterVLCMode); + + invokeEndElement (pctxt, "alternateInterVLCMode", -1); + + /* decode modifiedQuantizationMode */ + + invokeStartElement (pctxt, "modifiedQuantizationMode", -1); + + stat = DECODEBIT (pctxt, &pvalue->modifiedQuantizationMode); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->modifiedQuantizationMode); + + invokeEndElement (pctxt, "modifiedQuantizationMode", -1); + + /* decode reducedResolutionUpdate */ + + invokeStartElement (pctxt, "reducedResolutionUpdate", -1); + + stat = DECODEBIT (pctxt, &pvalue->reducedResolutionUpdate); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->reducedResolutionUpdate); + + invokeEndElement (pctxt, "reducedResolutionUpdate", -1); + + /* decode transparencyParameters */ + + if (pvalue->m.transparencyParametersPresent) { + invokeStartElement (pctxt, "transparencyParameters", -1); + + stat = asn1PD_H245TransparencyParameters (pctxt, &pvalue->transparencyParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transparencyParameters", -1); + } + + /* decode separateVideoBackChannel */ + + invokeStartElement (pctxt, "separateVideoBackChannel", -1); + + stat = DECODEBIT (pctxt, &pvalue->separateVideoBackChannel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->separateVideoBackChannel); + + invokeEndElement (pctxt, "separateVideoBackChannel", -1); + + /* decode refPictureSelection */ + + if (pvalue->m.refPictureSelectionPresent) { + invokeStartElement (pctxt, "refPictureSelection", -1); + + stat = asn1PD_H245RefPictureSelection (pctxt, &pvalue->refPictureSelection); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "refPictureSelection", -1); + } + + /* decode customPictureClockFrequency */ + + if (pvalue->m.customPictureClockFrequencyPresent) { + invokeStartElement (pctxt, "customPictureClockFrequency", -1); + + stat = asn1PD_H245H263Options_customPictureClockFrequency (pctxt, &pvalue->customPictureClockFrequency); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "customPictureClockFrequency", -1); + } + + /* decode customPictureFormat */ + + if (pvalue->m.customPictureFormatPresent) { + invokeStartElement (pctxt, "customPictureFormat", -1); + + stat = asn1PD_H245H263Options_customPictureFormat (pctxt, &pvalue->customPictureFormat); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "customPictureFormat", -1); + } + + /* decode modeCombos */ + + if (pvalue->m.modeCombosPresent) { + invokeStartElement (pctxt, "modeCombos", -1); + + stat = asn1PD_H245H263Options_modeCombos (pctxt, &pvalue->modeCombos); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "modeCombos", -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.videoBadMBsCapPresent = 1; + + invokeStartElement (pctxt, "videoBadMBsCap", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoBadMBsCap); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoBadMBsCap); + + invokeEndElement (pctxt, "videoBadMBsCap", -1); + break; + + case 1: + pvalue->m.h263Version3OptionsPresent = 1; + + invokeStartElement (pctxt, "h263Version3Options", -1); + + stat = asn1PD_H245H263Version3Options (pctxt, &pvalue->h263Version3Options); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263Version3Options", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnhancementOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EnhancementOptions (OOCTXT* pctxt, H245EnhancementOptions* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.sqcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.qcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cif4MPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cif16MPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.slowSqcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.slowQcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.slowCifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.slowCif4MPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.slowCif16MPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.h263OptionsPresent = optbit; + + /* decode sqcifMPI */ + + if (pvalue->m.sqcifMPIPresent) { + invokeStartElement (pctxt, "sqcifMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sqcifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sqcifMPI); + + invokeEndElement (pctxt, "sqcifMPI", -1); + } + + /* decode qcifMPI */ + + if (pvalue->m.qcifMPIPresent) { + invokeStartElement (pctxt, "qcifMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->qcifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->qcifMPI); + + invokeEndElement (pctxt, "qcifMPI", -1); + } + + /* decode cifMPI */ + + if (pvalue->m.cifMPIPresent) { + invokeStartElement (pctxt, "cifMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->cifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cifMPI); + + invokeEndElement (pctxt, "cifMPI", -1); + } + + /* decode cif4MPI */ + + if (pvalue->m.cif4MPIPresent) { + invokeStartElement (pctxt, "cif4MPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->cif4MPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cif4MPI); + + invokeEndElement (pctxt, "cif4MPI", -1); + } + + /* decode cif16MPI */ + + if (pvalue->m.cif16MPIPresent) { + invokeStartElement (pctxt, "cif16MPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->cif16MPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cif16MPI); + + invokeEndElement (pctxt, "cif16MPI", -1); + } + + /* decode maxBitRate */ + + invokeStartElement (pctxt, "maxBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->maxBitRate, 1U, 192400U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxBitRate); + + invokeEndElement (pctxt, "maxBitRate", -1); + + /* decode unrestrictedVector */ + + invokeStartElement (pctxt, "unrestrictedVector", -1); + + stat = DECODEBIT (pctxt, &pvalue->unrestrictedVector); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->unrestrictedVector); + + invokeEndElement (pctxt, "unrestrictedVector", -1); + + /* decode arithmeticCoding */ + + invokeStartElement (pctxt, "arithmeticCoding", -1); + + stat = DECODEBIT (pctxt, &pvalue->arithmeticCoding); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->arithmeticCoding); + + invokeEndElement (pctxt, "arithmeticCoding", -1); + + /* decode temporalSpatialTradeOffCapability */ + + invokeStartElement (pctxt, "temporalSpatialTradeOffCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->temporalSpatialTradeOffCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->temporalSpatialTradeOffCapability); + + invokeEndElement (pctxt, "temporalSpatialTradeOffCapability", -1); + + /* decode slowSqcifMPI */ + + if (pvalue->m.slowSqcifMPIPresent) { + invokeStartElement (pctxt, "slowSqcifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowSqcifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowSqcifMPI); + + invokeEndElement (pctxt, "slowSqcifMPI", -1); + } + + /* decode slowQcifMPI */ + + if (pvalue->m.slowQcifMPIPresent) { + invokeStartElement (pctxt, "slowQcifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowQcifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowQcifMPI); + + invokeEndElement (pctxt, "slowQcifMPI", -1); + } + + /* decode slowCifMPI */ + + if (pvalue->m.slowCifMPIPresent) { + invokeStartElement (pctxt, "slowCifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowCifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowCifMPI); + + invokeEndElement (pctxt, "slowCifMPI", -1); + } + + /* decode slowCif4MPI */ + + if (pvalue->m.slowCif4MPIPresent) { + invokeStartElement (pctxt, "slowCif4MPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowCif4MPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowCif4MPI); + + invokeEndElement (pctxt, "slowCif4MPI", -1); + } + + /* decode slowCif16MPI */ + + if (pvalue->m.slowCif16MPIPresent) { + invokeStartElement (pctxt, "slowCif16MPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowCif16MPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowCif16MPI); + + invokeEndElement (pctxt, "slowCif16MPI", -1); + } + + /* decode errorCompensation */ + + invokeStartElement (pctxt, "errorCompensation", -1); + + stat = DECODEBIT (pctxt, &pvalue->errorCompensation); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->errorCompensation); + + invokeEndElement (pctxt, "errorCompensation", -1); + + /* decode h263Options */ + + if (pvalue->m.h263OptionsPresent) { + invokeStartElement (pctxt, "h263Options", -1); + + stat = asn1PD_H245H263Options (pctxt, &pvalue->h263Options); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263Options", -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); +} + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_snrEnhancement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EnhancementLayerInfo_snrEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_snrEnhancement* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 }; + int stat = ASN_OK; + H245EnhancementOptions* 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, H245EnhancementOptions); + + stat = asn1PD_H245EnhancementOptions (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_spatialEnhancement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EnhancementLayerInfo_spatialEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_spatialEnhancement* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 }; + int stat = ASN_OK; + H245EnhancementOptions* 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, H245EnhancementOptions); + + stat = asn1PD_H245EnhancementOptions (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* BEnhancementParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245BEnhancementParameters (OOCTXT* pctxt, H245BEnhancementParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode enhancementOptions */ + + invokeStartElement (pctxt, "enhancementOptions", -1); + + stat = asn1PD_H245EnhancementOptions (pctxt, &pvalue->enhancementOptions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "enhancementOptions", -1); + + /* decode numberOfBPictures */ + + invokeStartElement (pctxt, "numberOfBPictures", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->numberOfBPictures, 1U, 64U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfBPictures); + + invokeEndElement (pctxt, "numberOfBPictures", -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); +} + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_bPictureEnhancement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EnhancementLayerInfo_bPictureEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_bPictureEnhancement* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 }; + int stat = ASN_OK; + H245BEnhancementParameters* 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, H245BEnhancementParameters); + + stat = asn1PD_H245BEnhancementParameters (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EnhancementLayerInfo (OOCTXT* pctxt, H245EnhancementLayerInfo* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.snrEnhancementPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.spatialEnhancementPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.bPictureEnhancementPresent = optbit; + + /* decode baseBitRateConstrained */ + + invokeStartElement (pctxt, "baseBitRateConstrained", -1); + + stat = DECODEBIT (pctxt, &pvalue->baseBitRateConstrained); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->baseBitRateConstrained); + + invokeEndElement (pctxt, "baseBitRateConstrained", -1); + + /* decode snrEnhancement */ + + if (pvalue->m.snrEnhancementPresent) { + invokeStartElement (pctxt, "snrEnhancement", -1); + + stat = asn1PD_H245EnhancementLayerInfo_snrEnhancement (pctxt, &pvalue->snrEnhancement); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "snrEnhancement", -1); + } + + /* decode spatialEnhancement */ + + if (pvalue->m.spatialEnhancementPresent) { + invokeStartElement (pctxt, "spatialEnhancement", -1); + + stat = asn1PD_H245EnhancementLayerInfo_spatialEnhancement (pctxt, &pvalue->spatialEnhancement); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "spatialEnhancement", -1); + } + + /* decode bPictureEnhancement */ + + if (pvalue->m.bPictureEnhancementPresent) { + invokeStartElement (pctxt, "bPictureEnhancement", -1); + + stat = asn1PD_H245EnhancementLayerInfo_bPictureEnhancement (pctxt, &pvalue->bPictureEnhancement); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "bPictureEnhancement", -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); +} + +/**************************************************************/ +/* */ +/* H263VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263VideoCapability (OOCTXT* pctxt, H245H263VideoCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.sqcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.qcifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cifMPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cif4MPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.cif16MPIPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.hrd_BPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.bppMaxKbPresent = optbit; + + /* decode sqcifMPI */ + + if (pvalue->m.sqcifMPIPresent) { + invokeStartElement (pctxt, "sqcifMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sqcifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sqcifMPI); + + invokeEndElement (pctxt, "sqcifMPI", -1); + } + + /* decode qcifMPI */ + + if (pvalue->m.qcifMPIPresent) { + invokeStartElement (pctxt, "qcifMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->qcifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->qcifMPI); + + invokeEndElement (pctxt, "qcifMPI", -1); + } + + /* decode cifMPI */ + + if (pvalue->m.cifMPIPresent) { + invokeStartElement (pctxt, "cifMPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->cifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cifMPI); + + invokeEndElement (pctxt, "cifMPI", -1); + } + + /* decode cif4MPI */ + + if (pvalue->m.cif4MPIPresent) { + invokeStartElement (pctxt, "cif4MPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->cif4MPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cif4MPI); + + invokeEndElement (pctxt, "cif4MPI", -1); + } + + /* decode cif16MPI */ + + if (pvalue->m.cif16MPIPresent) { + invokeStartElement (pctxt, "cif16MPI", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->cif16MPI, 1U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->cif16MPI); + + invokeEndElement (pctxt, "cif16MPI", -1); + } + + /* decode maxBitRate */ + + invokeStartElement (pctxt, "maxBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->maxBitRate, 1U, 192400U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxBitRate); + + invokeEndElement (pctxt, "maxBitRate", -1); + + /* decode unrestrictedVector */ + + invokeStartElement (pctxt, "unrestrictedVector", -1); + + stat = DECODEBIT (pctxt, &pvalue->unrestrictedVector); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->unrestrictedVector); + + invokeEndElement (pctxt, "unrestrictedVector", -1); + + /* decode arithmeticCoding */ + + invokeStartElement (pctxt, "arithmeticCoding", -1); + + stat = DECODEBIT (pctxt, &pvalue->arithmeticCoding); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->arithmeticCoding); + + invokeEndElement (pctxt, "arithmeticCoding", -1); + + /* decode advancedPrediction */ + + invokeStartElement (pctxt, "advancedPrediction", -1); + + stat = DECODEBIT (pctxt, &pvalue->advancedPrediction); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->advancedPrediction); + + invokeEndElement (pctxt, "advancedPrediction", -1); + + /* decode pbFrames */ + + invokeStartElement (pctxt, "pbFrames", -1); + + stat = DECODEBIT (pctxt, &pvalue->pbFrames); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->pbFrames); + + invokeEndElement (pctxt, "pbFrames", -1); + + /* decode temporalSpatialTradeOffCapability */ + + invokeStartElement (pctxt, "temporalSpatialTradeOffCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->temporalSpatialTradeOffCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->temporalSpatialTradeOffCapability); + + invokeEndElement (pctxt, "temporalSpatialTradeOffCapability", -1); + + /* decode hrd_B */ + + if (pvalue->m.hrd_BPresent) { + invokeStartElement (pctxt, "hrd_B", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->hrd_B, 0U, 524287U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->hrd_B); + + invokeEndElement (pctxt, "hrd_B", -1); + } + + /* decode bppMaxKb */ + + if (pvalue->m.bppMaxKbPresent) { + invokeStartElement (pctxt, "bppMaxKb", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bppMaxKb, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bppMaxKb); + + invokeEndElement (pctxt, "bppMaxKb", -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.slowSqcifMPIPresent = 1; + + invokeStartElement (pctxt, "slowSqcifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowSqcifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowSqcifMPI); + + invokeEndElement (pctxt, "slowSqcifMPI", -1); + break; + + case 1: + pvalue->m.slowQcifMPIPresent = 1; + + invokeStartElement (pctxt, "slowQcifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowQcifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowQcifMPI); + + invokeEndElement (pctxt, "slowQcifMPI", -1); + break; + + case 2: + pvalue->m.slowCifMPIPresent = 1; + + invokeStartElement (pctxt, "slowCifMPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowCifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowCifMPI); + + invokeEndElement (pctxt, "slowCifMPI", -1); + break; + + case 3: + pvalue->m.slowCif4MPIPresent = 1; + + invokeStartElement (pctxt, "slowCif4MPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowCif4MPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowCif4MPI); + + invokeEndElement (pctxt, "slowCif4MPI", -1); + break; + + case 4: + pvalue->m.slowCif16MPIPresent = 1; + + invokeStartElement (pctxt, "slowCif16MPI", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->slowCif16MPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->slowCif16MPI); + + invokeEndElement (pctxt, "slowCif16MPI", -1); + break; + + case 5: + pvalue->m.errorCompensationPresent = 1; + + invokeStartElement (pctxt, "errorCompensation", -1); + + stat = DECODEBIT (pctxt, &pvalue->errorCompensation); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->errorCompensation); + + invokeEndElement (pctxt, "errorCompensation", -1); + break; + + case 6: + pvalue->m.enhancementLayerInfoPresent = 1; + + invokeStartElement (pctxt, "enhancementLayerInfo", -1); + + stat = asn1PD_H245EnhancementLayerInfo (pctxt, &pvalue->enhancementLayerInfo); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "enhancementLayerInfo", -1); + break; + + case 7: + pvalue->m.h263OptionsPresent = 1; + + invokeStartElement (pctxt, "h263Options", -1); + + stat = asn1PD_H245H263Options (pctxt, &pvalue->h263Options); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263Options", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS11172VideoCapability (OOCTXT* pctxt, H245IS11172VideoCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.videoBitRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.vbvBufferSizePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.samplesPerLinePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.linesPerFramePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.pictureRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.luminanceSampleRatePresent = optbit; + + /* decode constrainedBitstream */ + + invokeStartElement (pctxt, "constrainedBitstream", -1); + + stat = DECODEBIT (pctxt, &pvalue->constrainedBitstream); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->constrainedBitstream); + + invokeEndElement (pctxt, "constrainedBitstream", -1); + + /* decode videoBitRate */ + + if (pvalue->m.videoBitRatePresent) { + invokeStartElement (pctxt, "videoBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->videoBitRate, 0U, 1073741823U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->videoBitRate); + + invokeEndElement (pctxt, "videoBitRate", -1); + } + + /* decode vbvBufferSize */ + + if (pvalue->m.vbvBufferSizePresent) { + invokeStartElement (pctxt, "vbvBufferSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->vbvBufferSize, 0U, 262143U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->vbvBufferSize); + + invokeEndElement (pctxt, "vbvBufferSize", -1); + } + + /* decode samplesPerLine */ + + if (pvalue->m.samplesPerLinePresent) { + invokeStartElement (pctxt, "samplesPerLine", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->samplesPerLine, 0U, 16383U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->samplesPerLine); + + invokeEndElement (pctxt, "samplesPerLine", -1); + } + + /* decode linesPerFrame */ + + if (pvalue->m.linesPerFramePresent) { + invokeStartElement (pctxt, "linesPerFrame", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->linesPerFrame, 0U, 16383U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->linesPerFrame); + + invokeEndElement (pctxt, "linesPerFrame", -1); + } + + /* decode pictureRate */ + + if (pvalue->m.pictureRatePresent) { + invokeStartElement (pctxt, "pictureRate", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->pictureRate, 0U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->pictureRate); + + invokeEndElement (pctxt, "pictureRate", -1); + } + + /* decode luminanceSampleRate */ + + if (pvalue->m.luminanceSampleRatePresent) { + invokeStartElement (pctxt, "luminanceSampleRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->luminanceSampleRate); + + invokeEndElement (pctxt, "luminanceSampleRate", -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.videoBadMBsCapPresent = 1; + + invokeStartElement (pctxt, "videoBadMBsCap", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoBadMBsCap); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoBadMBsCap); + + invokeEndElement (pctxt, "videoBadMBsCap", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VideoCapability (OOCTXT* pctxt, H245VideoCapability* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* h261VideoCapability */ + case 1: + invokeStartElement (pctxt, "h261VideoCapability", -1); + + pvalue->u.h261VideoCapability = ALLOC_ASN1ELEM (pctxt, H245H261VideoCapability); + + stat = asn1PD_H245H261VideoCapability (pctxt, pvalue->u.h261VideoCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h261VideoCapability", -1); + + break; + + /* h262VideoCapability */ + case 2: + invokeStartElement (pctxt, "h262VideoCapability", -1); + + pvalue->u.h262VideoCapability = ALLOC_ASN1ELEM (pctxt, H245H262VideoCapability); + + stat = asn1PD_H245H262VideoCapability (pctxt, pvalue->u.h262VideoCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h262VideoCapability", -1); + + break; + + /* h263VideoCapability */ + case 3: + invokeStartElement (pctxt, "h263VideoCapability", -1); + + pvalue->u.h263VideoCapability = ALLOC_ASN1ELEM (pctxt, H245H263VideoCapability); + + stat = asn1PD_H245H263VideoCapability (pctxt, pvalue->u.h263VideoCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263VideoCapability", -1); + + break; + + /* is11172VideoCapability */ + case 4: + invokeStartElement (pctxt, "is11172VideoCapability", -1); + + pvalue->u.is11172VideoCapability = ALLOC_ASN1ELEM (pctxt, H245IS11172VideoCapability); + + stat = asn1PD_H245IS11172VideoCapability (pctxt, pvalue->u.is11172VideoCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "is11172VideoCapability", -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; + + copyContext (&lctxt, pctxt); + initContextBuffer (pctxt, openType.data, openType.numocts); + + switch (pvalue->t) { + /* genericVideoCapability */ + case 6: + invokeStartElement (pctxt, "genericVideoCapability", -1); + + pvalue->u.genericVideoCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability); + + stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericVideoCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericVideoCapability", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AudioCapability_g7231 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245AudioCapability_g7231 (OOCTXT* pctxt, H245AudioCapability_g7231* pvalue) +{ + int stat = ASN_OK; + + /* decode maxAl_sduAudioFrames */ + + invokeStartElement (pctxt, "maxAl_sduAudioFrames", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maxAl_sduAudioFrames, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxAl_sduAudioFrames); + + invokeEndElement (pctxt, "maxAl_sduAudioFrames", -1); + + /* decode silenceSuppression */ + + invokeStartElement (pctxt, "silenceSuppression", -1); + + stat = DECODEBIT (pctxt, &pvalue->silenceSuppression); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->silenceSuppression); + + invokeEndElement (pctxt, "silenceSuppression", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS11172AudioCapability (OOCTXT* pctxt, H245IS11172AudioCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode audioLayer1 */ + + invokeStartElement (pctxt, "audioLayer1", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioLayer1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioLayer1); + + invokeEndElement (pctxt, "audioLayer1", -1); + + /* decode audioLayer2 */ + + invokeStartElement (pctxt, "audioLayer2", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioLayer2); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioLayer2); + + invokeEndElement (pctxt, "audioLayer2", -1); + + /* decode audioLayer3 */ + + invokeStartElement (pctxt, "audioLayer3", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioLayer3); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioLayer3); + + invokeEndElement (pctxt, "audioLayer3", -1); + + /* decode audioSampling32k */ + + invokeStartElement (pctxt, "audioSampling32k", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling32k); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling32k); + + invokeEndElement (pctxt, "audioSampling32k", -1); + + /* decode audioSampling44k1 */ + + invokeStartElement (pctxt, "audioSampling44k1", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling44k1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling44k1); + + invokeEndElement (pctxt, "audioSampling44k1", -1); + + /* decode audioSampling48k */ + + invokeStartElement (pctxt, "audioSampling48k", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling48k); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling48k); + + invokeEndElement (pctxt, "audioSampling48k", -1); + + /* decode singleChannel */ + + invokeStartElement (pctxt, "singleChannel", -1); + + stat = DECODEBIT (pctxt, &pvalue->singleChannel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->singleChannel); + + invokeEndElement (pctxt, "singleChannel", -1); + + /* decode twoChannels */ + + invokeStartElement (pctxt, "twoChannels", -1); + + stat = DECODEBIT (pctxt, &pvalue->twoChannels); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->twoChannels); + + invokeEndElement (pctxt, "twoChannels", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 448U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -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); +} + +/**************************************************************/ +/* */ +/* IS13818AudioCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS13818AudioCapability (OOCTXT* pctxt, H245IS13818AudioCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode audioLayer1 */ + + invokeStartElement (pctxt, "audioLayer1", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioLayer1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioLayer1); + + invokeEndElement (pctxt, "audioLayer1", -1); + + /* decode audioLayer2 */ + + invokeStartElement (pctxt, "audioLayer2", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioLayer2); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioLayer2); + + invokeEndElement (pctxt, "audioLayer2", -1); + + /* decode audioLayer3 */ + + invokeStartElement (pctxt, "audioLayer3", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioLayer3); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioLayer3); + + invokeEndElement (pctxt, "audioLayer3", -1); + + /* decode audioSampling16k */ + + invokeStartElement (pctxt, "audioSampling16k", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling16k); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling16k); + + invokeEndElement (pctxt, "audioSampling16k", -1); + + /* decode audioSampling22k05 */ + + invokeStartElement (pctxt, "audioSampling22k05", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling22k05); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling22k05); + + invokeEndElement (pctxt, "audioSampling22k05", -1); + + /* decode audioSampling24k */ + + invokeStartElement (pctxt, "audioSampling24k", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling24k); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling24k); + + invokeEndElement (pctxt, "audioSampling24k", -1); + + /* decode audioSampling32k */ + + invokeStartElement (pctxt, "audioSampling32k", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling32k); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling32k); + + invokeEndElement (pctxt, "audioSampling32k", -1); + + /* decode audioSampling44k1 */ + + invokeStartElement (pctxt, "audioSampling44k1", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling44k1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling44k1); + + invokeEndElement (pctxt, "audioSampling44k1", -1); + + /* decode audioSampling48k */ + + invokeStartElement (pctxt, "audioSampling48k", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioSampling48k); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioSampling48k); + + invokeEndElement (pctxt, "audioSampling48k", -1); + + /* decode singleChannel */ + + invokeStartElement (pctxt, "singleChannel", -1); + + stat = DECODEBIT (pctxt, &pvalue->singleChannel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->singleChannel); + + invokeEndElement (pctxt, "singleChannel", -1); + + /* decode twoChannels */ + + invokeStartElement (pctxt, "twoChannels", -1); + + stat = DECODEBIT (pctxt, &pvalue->twoChannels); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->twoChannels); + + invokeEndElement (pctxt, "twoChannels", -1); + + /* decode threeChannels2_1 */ + + invokeStartElement (pctxt, "threeChannels2_1", -1); + + stat = DECODEBIT (pctxt, &pvalue->threeChannels2_1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->threeChannels2_1); + + invokeEndElement (pctxt, "threeChannels2_1", -1); + + /* decode threeChannels3_0 */ + + invokeStartElement (pctxt, "threeChannels3_0", -1); + + stat = DECODEBIT (pctxt, &pvalue->threeChannels3_0); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->threeChannels3_0); + + invokeEndElement (pctxt, "threeChannels3_0", -1); + + /* decode fourChannels2_0_2_0 */ + + invokeStartElement (pctxt, "fourChannels2_0_2_0", -1); + + stat = DECODEBIT (pctxt, &pvalue->fourChannels2_0_2_0); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fourChannels2_0_2_0); + + invokeEndElement (pctxt, "fourChannels2_0_2_0", -1); + + /* decode fourChannels2_2 */ + + invokeStartElement (pctxt, "fourChannels2_2", -1); + + stat = DECODEBIT (pctxt, &pvalue->fourChannels2_2); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fourChannels2_2); + + invokeEndElement (pctxt, "fourChannels2_2", -1); + + /* decode fourChannels3_1 */ + + invokeStartElement (pctxt, "fourChannels3_1", -1); + + stat = DECODEBIT (pctxt, &pvalue->fourChannels3_1); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fourChannels3_1); + + invokeEndElement (pctxt, "fourChannels3_1", -1); + + /* decode fiveChannels3_0_2_0 */ + + invokeStartElement (pctxt, "fiveChannels3_0_2_0", -1); + + stat = DECODEBIT (pctxt, &pvalue->fiveChannels3_0_2_0); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fiveChannels3_0_2_0); + + invokeEndElement (pctxt, "fiveChannels3_0_2_0", -1); + + /* decode fiveChannels3_2 */ + + invokeStartElement (pctxt, "fiveChannels3_2", -1); + + stat = DECODEBIT (pctxt, &pvalue->fiveChannels3_2); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->fiveChannels3_2); + + invokeEndElement (pctxt, "fiveChannels3_2", -1); + + /* decode lowFrequencyEnhancement */ + + invokeStartElement (pctxt, "lowFrequencyEnhancement", -1); + + stat = DECODEBIT (pctxt, &pvalue->lowFrequencyEnhancement); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->lowFrequencyEnhancement); + + invokeEndElement (pctxt, "lowFrequencyEnhancement", -1); + + /* decode multilingual */ + + invokeStartElement (pctxt, "multilingual", -1); + + stat = DECODEBIT (pctxt, &pvalue->multilingual); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->multilingual); + + invokeEndElement (pctxt, "multilingual", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 1130U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -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); +} + +/**************************************************************/ +/* */ +/* G7231AnnexCCapability_g723AnnexCAudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245G7231AnnexCCapability_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCCapability_g723AnnexCAudioMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode highRateMode0 */ + + invokeStartElement (pctxt, "highRateMode0", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->highRateMode0, 27U, 78U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->highRateMode0); + + invokeEndElement (pctxt, "highRateMode0", -1); + + /* decode highRateMode1 */ + + invokeStartElement (pctxt, "highRateMode1", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->highRateMode1, 27U, 78U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->highRateMode1); + + invokeEndElement (pctxt, "highRateMode1", -1); + + /* decode lowRateMode0 */ + + invokeStartElement (pctxt, "lowRateMode0", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->lowRateMode0, 23U, 66U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->lowRateMode0); + + invokeEndElement (pctxt, "lowRateMode0", -1); + + /* decode lowRateMode1 */ + + invokeStartElement (pctxt, "lowRateMode1", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->lowRateMode1, 23U, 66U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->lowRateMode1); + + invokeEndElement (pctxt, "lowRateMode1", -1); + + /* decode sidMode0 */ + + invokeStartElement (pctxt, "sidMode0", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sidMode0, 6U, 17U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sidMode0); + + invokeEndElement (pctxt, "sidMode0", -1); + + /* decode sidMode1 */ + + invokeStartElement (pctxt, "sidMode1", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sidMode1, 6U, 17U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sidMode1); + + invokeEndElement (pctxt, "sidMode1", -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); +} + +/**************************************************************/ +/* */ +/* G7231AnnexCCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245G7231AnnexCCapability (OOCTXT* pctxt, H245G7231AnnexCCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.g723AnnexCAudioModePresent = optbit; + + /* decode maxAl_sduAudioFrames */ + + invokeStartElement (pctxt, "maxAl_sduAudioFrames", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maxAl_sduAudioFrames, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxAl_sduAudioFrames); + + invokeEndElement (pctxt, "maxAl_sduAudioFrames", -1); + + /* decode silenceSuppression */ + + invokeStartElement (pctxt, "silenceSuppression", -1); + + stat = DECODEBIT (pctxt, &pvalue->silenceSuppression); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->silenceSuppression); + + invokeEndElement (pctxt, "silenceSuppression", -1); + + /* decode g723AnnexCAudioMode */ + + if (pvalue->m.g723AnnexCAudioModePresent) { + invokeStartElement (pctxt, "g723AnnexCAudioMode", -1); + + stat = asn1PD_H245G7231AnnexCCapability_g723AnnexCAudioMode (pctxt, &pvalue->g723AnnexCAudioMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "g723AnnexCAudioMode", -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); +} + +/**************************************************************/ +/* */ +/* GSMAudioCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245GSMAudioCapability (OOCTXT* pctxt, H245GSMAudioCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode audioUnitSize */ + + invokeStartElement (pctxt, "audioUnitSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->audioUnitSize, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->audioUnitSize); + + invokeEndElement (pctxt, "audioUnitSize", -1); + + /* decode comfortNoise */ + + invokeStartElement (pctxt, "comfortNoise", -1); + + stat = DECODEBIT (pctxt, &pvalue->comfortNoise); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->comfortNoise); + + invokeEndElement (pctxt, "comfortNoise", -1); + + /* decode scrambled */ + + invokeStartElement (pctxt, "scrambled", -1); + + stat = DECODEBIT (pctxt, &pvalue->scrambled); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->scrambled); + + invokeEndElement (pctxt, "scrambled", -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); +} + +/**************************************************************/ +/* */ +/* G729Extensions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245G729Extensions (OOCTXT* pctxt, H245G729Extensions* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.audioUnitPresent = optbit; + + /* decode audioUnit */ + + if (pvalue->m.audioUnitPresent) { + invokeStartElement (pctxt, "audioUnit", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->audioUnit, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->audioUnit); + + invokeEndElement (pctxt, "audioUnit", -1); + } + + /* decode annexA */ + + invokeStartElement (pctxt, "annexA", -1); + + stat = DECODEBIT (pctxt, &pvalue->annexA); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->annexA); + + invokeEndElement (pctxt, "annexA", -1); + + /* decode annexB */ + + invokeStartElement (pctxt, "annexB", -1); + + stat = DECODEBIT (pctxt, &pvalue->annexB); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->annexB); + + invokeEndElement (pctxt, "annexB", -1); + + /* decode annexD */ + + invokeStartElement (pctxt, "annexD", -1); + + stat = DECODEBIT (pctxt, &pvalue->annexD); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->annexD); + + invokeEndElement (pctxt, "annexD", -1); + + /* decode annexE */ + + invokeStartElement (pctxt, "annexE", -1); + + stat = DECODEBIT (pctxt, &pvalue->annexE); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->annexE); + + invokeEndElement (pctxt, "annexE", -1); + + /* decode annexF */ + + invokeStartElement (pctxt, "annexF", -1); + + stat = DECODEBIT (pctxt, &pvalue->annexF); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->annexF); + + invokeEndElement (pctxt, "annexF", -1); + + /* decode annexG */ + + invokeStartElement (pctxt, "annexG", -1); + + stat = DECODEBIT (pctxt, &pvalue->annexG); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->annexG); + + invokeEndElement (pctxt, "annexG", -1); + + /* decode annexH */ + + invokeStartElement (pctxt, "annexH", -1); + + stat = DECODEBIT (pctxt, &pvalue->annexH); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->annexH); + + invokeEndElement (pctxt, "annexH", -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); +} + +/**************************************************************/ +/* */ +/* VBDCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VBDCapability (OOCTXT* pctxt, H245VBDCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + pvalue->type = ALLOC_ASN1ELEM (pctxt, H245AudioCapability); + + stat = asn1PD_H245AudioCapability (pctxt, (H245AudioCapability*)pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* NoPTAudioTelephonyEventCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NoPTAudioTelephonyEventCapability (OOCTXT* pctxt, H245NoPTAudioTelephonyEventCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode audioTelephoneEvent */ + + invokeStartElement (pctxt, "audioTelephoneEvent", -1); + + stat = decodeVarWidthCharString (pctxt, &pvalue->audioTelephoneEvent); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->audioTelephoneEvent); + + invokeEndElement (pctxt, "audioTelephoneEvent", -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); +} + +/**************************************************************/ +/* */ +/* NoPTAudioToneCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NoPTAudioToneCapability (OOCTXT* pctxt, H245NoPTAudioToneCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + 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); +} + +/**************************************************************/ +/* */ +/* AudioCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245AudioCapability (OOCTXT* pctxt, H245AudioCapability* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 13); + 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* g711Alaw64k */ + case 1: + invokeStartElement (pctxt, "g711Alaw64k", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g711Alaw64k, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g711Alaw64k); + + invokeEndElement (pctxt, "g711Alaw64k", -1); + + break; + + /* g711Alaw56k */ + case 2: + invokeStartElement (pctxt, "g711Alaw56k", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g711Alaw56k, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g711Alaw56k); + + invokeEndElement (pctxt, "g711Alaw56k", -1); + + break; + + /* g711Ulaw64k */ + case 3: + invokeStartElement (pctxt, "g711Ulaw64k", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g711Ulaw64k, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g711Ulaw64k); + + invokeEndElement (pctxt, "g711Ulaw64k", -1); + + break; + + /* g711Ulaw56k */ + case 4: + invokeStartElement (pctxt, "g711Ulaw56k", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g711Ulaw56k, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g711Ulaw56k); + + invokeEndElement (pctxt, "g711Ulaw56k", -1); + + break; + + /* g722_64k */ + case 5: + invokeStartElement (pctxt, "g722_64k", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g722_64k, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g722_64k); + + invokeEndElement (pctxt, "g722_64k", -1); + + break; + + /* g722_56k */ + case 6: + invokeStartElement (pctxt, "g722_56k", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g722_56k, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g722_56k); + + invokeEndElement (pctxt, "g722_56k", -1); + + break; + + /* g722_48k */ + case 7: + invokeStartElement (pctxt, "g722_48k", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g722_48k, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g722_48k); + + invokeEndElement (pctxt, "g722_48k", -1); + + break; + + /* g7231 */ + case 8: + invokeStartElement (pctxt, "g7231", -1); + + pvalue->u.g7231 = ALLOC_ASN1ELEM (pctxt, H245AudioCapability_g7231); + + stat = asn1PD_H245AudioCapability_g7231 (pctxt, pvalue->u.g7231); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "g7231", -1); + + break; + + /* g728 */ + case 9: + invokeStartElement (pctxt, "g728", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g728, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g728); + + invokeEndElement (pctxt, "g728", -1); + + break; + + /* g729 */ + case 10: + invokeStartElement (pctxt, "g729", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g729, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g729); + + invokeEndElement (pctxt, "g729", -1); + + break; + + /* g729AnnexA */ + case 11: + invokeStartElement (pctxt, "g729AnnexA", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g729AnnexA, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g729AnnexA); + + invokeEndElement (pctxt, "g729AnnexA", -1); + + break; + + /* is11172AudioCapability */ + case 12: + invokeStartElement (pctxt, "is11172AudioCapability", -1); + + pvalue->u.is11172AudioCapability = ALLOC_ASN1ELEM (pctxt, H245IS11172AudioCapability); + + stat = asn1PD_H245IS11172AudioCapability (pctxt, pvalue->u.is11172AudioCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "is11172AudioCapability", -1); + + break; + + /* is13818AudioCapability */ + case 13: + invokeStartElement (pctxt, "is13818AudioCapability", -1); + + pvalue->u.is13818AudioCapability = ALLOC_ASN1ELEM (pctxt, H245IS13818AudioCapability); + + stat = asn1PD_H245IS13818AudioCapability (pctxt, pvalue->u.is13818AudioCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "is13818AudioCapability", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 15; + + 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) { + /* g729wAnnexB */ + case 15: + invokeStartElement (pctxt, "g729wAnnexB", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g729wAnnexB, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g729wAnnexB); + + invokeEndElement (pctxt, "g729wAnnexB", -1); + + break; + + /* g729AnnexAwAnnexB */ + case 16: + invokeStartElement (pctxt, "g729AnnexAwAnnexB", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g729AnnexAwAnnexB, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g729AnnexAwAnnexB); + + invokeEndElement (pctxt, "g729AnnexAwAnnexB", -1); + + break; + + /* g7231AnnexCCapability */ + case 17: + invokeStartElement (pctxt, "g7231AnnexCCapability", -1); + + pvalue->u.g7231AnnexCCapability = ALLOC_ASN1ELEM (pctxt, H245G7231AnnexCCapability); + + stat = asn1PD_H245G7231AnnexCCapability (pctxt, pvalue->u.g7231AnnexCCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "g7231AnnexCCapability", -1); + + break; + + /* gsmFullRate */ + case 18: + invokeStartElement (pctxt, "gsmFullRate", -1); + + pvalue->u.gsmFullRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability); + + stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmFullRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "gsmFullRate", -1); + + break; + + /* gsmHalfRate */ + case 19: + invokeStartElement (pctxt, "gsmHalfRate", -1); + + pvalue->u.gsmHalfRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability); + + stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmHalfRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "gsmHalfRate", -1); + + break; + + /* gsmEnhancedFullRate */ + case 20: + invokeStartElement (pctxt, "gsmEnhancedFullRate", -1); + + pvalue->u.gsmEnhancedFullRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability); + + stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmEnhancedFullRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "gsmEnhancedFullRate", -1); + + break; + + /* genericAudioCapability */ + case 21: + invokeStartElement (pctxt, "genericAudioCapability", -1); + + pvalue->u.genericAudioCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability); + + stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericAudioCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericAudioCapability", -1); + + break; + + /* g729Extensions */ + case 22: + invokeStartElement (pctxt, "g729Extensions", -1); + + pvalue->u.g729Extensions = ALLOC_ASN1ELEM (pctxt, H245G729Extensions); + + stat = asn1PD_H245G729Extensions (pctxt, pvalue->u.g729Extensions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "g729Extensions", -1); + + break; + + /* vbd */ + case 23: + invokeStartElement (pctxt, "vbd", -1); + + pvalue->u.vbd = ALLOC_ASN1ELEM (pctxt, H245VBDCapability); + + stat = asn1PD_H245VBDCapability (pctxt, pvalue->u.vbd); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "vbd", -1); + + break; + + /* audioTelephonyEvent */ + case 24: + invokeStartElement (pctxt, "audioTelephonyEvent", -1); + + pvalue->u.audioTelephonyEvent = ALLOC_ASN1ELEM (pctxt, H245NoPTAudioTelephonyEventCapability); + + stat = asn1PD_H245NoPTAudioTelephonyEventCapability (pctxt, pvalue->u.audioTelephonyEvent); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioTelephonyEvent", -1); + + break; + + /* audioTone */ + case 25: + invokeStartElement (pctxt, "audioTone", -1); + + pvalue->u.audioTone = ALLOC_ASN1ELEM (pctxt, H245NoPTAudioToneCapability); + + stat = asn1PD_H245NoPTAudioToneCapability (pctxt, pvalue->u.audioTone); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioTone", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Capability_h233EncryptionReceiveCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245Capability_h233EncryptionReceiveCapability (OOCTXT* pctxt, H245Capability_h233EncryptionReceiveCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode h233IVResponseTime */ + + invokeStartElement (pctxt, "h233IVResponseTime", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->h233IVResponseTime, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->h233IVResponseTime); + + invokeEndElement (pctxt, "h233IVResponseTime", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245NonStandardParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245NonStandardParameter (OOCTXT* pctxt, H245_SeqOfH245NonStandardParameter* pvalue) +{ + int stat = ASN_OK; + H245NonStandardParameter* 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceCapability (OOCTXT* pctxt, H245ConferenceCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandardData", -1); + } + + /* decode chairControlCapability */ + + invokeStartElement (pctxt, "chairControlCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->chairControlCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->chairControlCapability); + + invokeEndElement (pctxt, "chairControlCapability", -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.videoIndicateMixingCapabilityPresent = 1; + + invokeStartElement (pctxt, "videoIndicateMixingCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->videoIndicateMixingCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->videoIndicateMixingCapability); + + invokeEndElement (pctxt, "videoIndicateMixingCapability", -1); + break; + + case 1: + pvalue->m.multipointVisualizationCapabilityPresent = 1; + + invokeStartElement (pctxt, "multipointVisualizationCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->multipointVisualizationCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->multipointVisualizationCapability); + + invokeEndElement (pctxt, "multipointVisualizationCapability", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaEncryptionAlgorithm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MediaEncryptionAlgorithm (OOCTXT* pctxt, H245MediaEncryptionAlgorithm* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* algorithm */ + case 1: + invokeStartElement (pctxt, "algorithm", -1); + + pvalue->u.algorithm = ALLOC_ASN1ELEM (pctxt, ASN1OBJID); + + stat = decodeObjectIdentifier (pctxt, pvalue->u.algorithm); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->u.algorithm->numids, pvalue->u.algorithm->subid); + + invokeEndElement (pctxt, "algorithm", -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); +} + +/**************************************************************/ +/* */ +/* EncryptionCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EncryptionCapability (OOCTXT* pctxt, H245EncryptionCapability* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245MediaEncryptionAlgorithm* 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, H245MediaEncryptionAlgorithm); + + stat = asn1PD_H245MediaEncryptionAlgorithm (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AuthenticationCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245AuthenticationCapability (OOCTXT* pctxt, H245AuthenticationCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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_H245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -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.antiSpamAlgorithmPresent = 1; + + invokeStartElement (pctxt, "antiSpamAlgorithm", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->antiSpamAlgorithm); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->antiSpamAlgorithm.numids, pvalue->antiSpamAlgorithm.subid); + + invokeEndElement (pctxt, "antiSpamAlgorithm", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IntegrityCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IntegrityCapability (OOCTXT* pctxt, H245IntegrityCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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_H245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -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); +} + +/**************************************************************/ +/* */ +/* EncryptionAuthenticationAndIntegrity */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EncryptionAuthenticationAndIntegrity (OOCTXT* pctxt, H245EncryptionAuthenticationAndIntegrity* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.encryptionCapabilityPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.authenticationCapabilityPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.integrityCapabilityPresent = optbit; + + /* decode encryptionCapability */ + + if (pvalue->m.encryptionCapabilityPresent) { + invokeStartElement (pctxt, "encryptionCapability", -1); + + stat = asn1PD_H245EncryptionCapability (pctxt, &pvalue->encryptionCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionCapability", -1); + } + + /* decode authenticationCapability */ + + if (pvalue->m.authenticationCapabilityPresent) { + invokeStartElement (pctxt, "authenticationCapability", -1); + + stat = asn1PD_H245AuthenticationCapability (pctxt, &pvalue->authenticationCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "authenticationCapability", -1); + } + + /* decode integrityCapability */ + + if (pvalue->m.integrityCapabilityPresent) { + invokeStartElement (pctxt, "integrityCapability", -1); + + stat = asn1PD_H245IntegrityCapability (pctxt, &pvalue->integrityCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "integrityCapability", -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); +} + +/**************************************************************/ +/* */ +/* H235SecurityCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H235SecurityCapability (OOCTXT* pctxt, H245H235SecurityCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode encryptionAuthenticationAndIntegrity */ + + invokeStartElement (pctxt, "encryptionAuthenticationAndIntegrity", -1); + + stat = asn1PD_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionAuthenticationAndIntegrity", -1); + + /* decode mediaCapability */ + + invokeStartElement (pctxt, "mediaCapability", -1); + + stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->mediaCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaCapability", -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); +} + +/**************************************************************/ +/* */ +/* UserInputCapability_nonStandard */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UserInputCapability_nonStandard (OOCTXT* pctxt, H245UserInputCapability_nonStandard* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + H245NonStandardParameter* 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UserInputCapability (OOCTXT* pctxt, H245UserInputCapability* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245UserInputCapability_nonStandard); + + stat = asn1PD_H245UserInputCapability_nonStandard (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* basicString */ + case 1: + invokeStartElement (pctxt, "basicString", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "basicString", -1); + + break; + + /* iA5String */ + case 2: + invokeStartElement (pctxt, "iA5String", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "iA5String", -1); + + break; + + /* generalString */ + case 3: + invokeStartElement (pctxt, "generalString", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "generalString", -1); + + break; + + /* dtmf */ + case 4: + invokeStartElement (pctxt, "dtmf", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "dtmf", -1); + + break; + + /* hookflash */ + case 5: + invokeStartElement (pctxt, "hookflash", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "hookflash", -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) { + /* extendedAlphanumeric */ + case 7: + invokeStartElement (pctxt, "extendedAlphanumeric", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "extendedAlphanumeric", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexFormat */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexFormat (OOCTXT* pctxt, H245MultiplexFormat* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* h222Capability */ + case 1: + invokeStartElement (pctxt, "h222Capability", -1); + + pvalue->u.h222Capability = ALLOC_ASN1ELEM (pctxt, H245H222Capability); + + stat = asn1PD_H245H222Capability (pctxt, pvalue->u.h222Capability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h222Capability", -1); + + break; + + /* h223Capability */ + case 2: + invokeStartElement (pctxt, "h223Capability", -1); + + pvalue->u.h223Capability = ALLOC_ASN1ELEM (pctxt, H245H223Capability); + + stat = asn1PD_H245H223Capability (pctxt, pvalue->u.h223Capability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223Capability", -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); +} + +/**************************************************************/ +/* */ +/* AlternativeCapabilitySet */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245AlternativeCapabilitySet (OOCTXT* pctxt, H245AlternativeCapabilitySet* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexedStreamCapability_capabilityOnMuxStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexedStreamCapability_capabilityOnMuxStream (OOCTXT* pctxt, H245MultiplexedStreamCapability_capabilityOnMuxStream* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245AlternativeCapabilitySet* 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, H245AlternativeCapabilitySet); + + stat = asn1PD_H245AlternativeCapabilitySet (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexedStreamCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexedStreamCapability (OOCTXT* pctxt, H245MultiplexedStreamCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.capabilityOnMuxStreamPresent = optbit; + + /* decode multiplexFormat */ + + invokeStartElement (pctxt, "multiplexFormat", -1); + + stat = asn1PD_H245MultiplexFormat (pctxt, &pvalue->multiplexFormat); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexFormat", -1); + + /* decode controlOnMuxStream */ + + invokeStartElement (pctxt, "controlOnMuxStream", -1); + + stat = DECODEBIT (pctxt, &pvalue->controlOnMuxStream); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->controlOnMuxStream); + + invokeEndElement (pctxt, "controlOnMuxStream", -1); + + /* decode capabilityOnMuxStream */ + + if (pvalue->m.capabilityOnMuxStreamPresent) { + invokeStartElement (pctxt, "capabilityOnMuxStream", -1); + + stat = asn1PD_H245MultiplexedStreamCapability_capabilityOnMuxStream (pctxt, &pvalue->capabilityOnMuxStream); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilityOnMuxStream", -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); +} + +/**************************************************************/ +/* */ +/* AudioTelephonyEventCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245AudioTelephonyEventCapability (OOCTXT* pctxt, H245AudioTelephonyEventCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode dynamicRTPPayloadType */ + + invokeStartElement (pctxt, "dynamicRTPPayloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->dynamicRTPPayloadType, 96U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->dynamicRTPPayloadType); + + invokeEndElement (pctxt, "dynamicRTPPayloadType", -1); + + /* decode audioTelephoneEvent */ + + invokeStartElement (pctxt, "audioTelephoneEvent", -1); + + stat = decodeVarWidthCharString (pctxt, &pvalue->audioTelephoneEvent); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->audioTelephoneEvent); + + invokeEndElement (pctxt, "audioTelephoneEvent", -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); +} + +/**************************************************************/ +/* */ +/* AudioToneCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245AudioToneCapability (OOCTXT* pctxt, H245AudioToneCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode dynamicRTPPayloadType */ + + invokeStartElement (pctxt, "dynamicRTPPayloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->dynamicRTPPayloadType, 96U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->dynamicRTPPayloadType); + + invokeEndElement (pctxt, "dynamicRTPPayloadType", -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); +} + +/**************************************************************/ +/* */ +/* FECCapability_rfc2733_separateStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECCapability_rfc2733_separateStream (OOCTXT* pctxt, H245FECCapability_rfc2733_separateStream* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode separatePort */ + + invokeStartElement (pctxt, "separatePort", -1); + + stat = DECODEBIT (pctxt, &pvalue->separatePort); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->separatePort); + + invokeEndElement (pctxt, "separatePort", -1); + + /* decode samePort */ + + invokeStartElement (pctxt, "samePort", -1); + + stat = DECODEBIT (pctxt, &pvalue->samePort); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->samePort); + + invokeEndElement (pctxt, "samePort", -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); +} + +/**************************************************************/ +/* */ +/* FECCapability_rfc2733 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECCapability_rfc2733 (OOCTXT* pctxt, H245FECCapability_rfc2733* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode redundancyEncoding */ + + invokeStartElement (pctxt, "redundancyEncoding", -1); + + stat = DECODEBIT (pctxt, &pvalue->redundancyEncoding); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->redundancyEncoding); + + invokeEndElement (pctxt, "redundancyEncoding", -1); + + /* decode separateStream */ + + invokeStartElement (pctxt, "separateStream", -1); + + stat = asn1PD_H245FECCapability_rfc2733_separateStream (pctxt, &pvalue->separateStream); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "separateStream", -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); +} + +/**************************************************************/ +/* */ +/* FECCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECCapability (OOCTXT* pctxt, H245FECCapability* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* rfc2733 */ + case 0: + invokeStartElement (pctxt, "rfc2733", -1); + + pvalue->u.rfc2733 = ALLOC_ASN1ELEM (pctxt, H245FECCapability_rfc2733); + + stat = asn1PD_H245FECCapability_rfc2733 (pctxt, pvalue->u.rfc2733); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rfc2733", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamCapability_capabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplePayloadStreamCapability_capabilities (OOCTXT* pctxt, H245MultiplePayloadStreamCapability_capabilities* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245AlternativeCapabilitySet* 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, H245AlternativeCapabilitySet); + + stat = asn1PD_H245AlternativeCapabilitySet (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplePayloadStreamCapability (OOCTXT* pctxt, H245MultiplePayloadStreamCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode capabilities */ + + invokeStartElement (pctxt, "capabilities", -1); + + stat = asn1PD_H245MultiplePayloadStreamCapability_capabilities (pctxt, &pvalue->capabilities); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilities", -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); +} + +/**************************************************************/ +/* */ +/* Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245Capability (OOCTXT* pctxt, H245Capability* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* receiveVideoCapability */ + case 1: + invokeStartElement (pctxt, "receiveVideoCapability", -1); + + pvalue->u.receiveVideoCapability = ALLOC_ASN1ELEM (pctxt, H245VideoCapability); + + stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.receiveVideoCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveVideoCapability", -1); + + break; + + /* transmitVideoCapability */ + case 2: + invokeStartElement (pctxt, "transmitVideoCapability", -1); + + pvalue->u.transmitVideoCapability = ALLOC_ASN1ELEM (pctxt, H245VideoCapability); + + stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.transmitVideoCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transmitVideoCapability", -1); + + break; + + /* receiveAndTransmitVideoCapability */ + case 3: + invokeStartElement (pctxt, "receiveAndTransmitVideoCapability", -1); + + pvalue->u.receiveAndTransmitVideoCapability = ALLOC_ASN1ELEM (pctxt, H245VideoCapability); + + stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.receiveAndTransmitVideoCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveAndTransmitVideoCapability", -1); + + break; + + /* receiveAudioCapability */ + case 4: + invokeStartElement (pctxt, "receiveAudioCapability", -1); + + pvalue->u.receiveAudioCapability = ALLOC_ASN1ELEM (pctxt, H245AudioCapability); + + stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.receiveAudioCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveAudioCapability", -1); + + break; + + /* transmitAudioCapability */ + case 5: + invokeStartElement (pctxt, "transmitAudioCapability", -1); + + pvalue->u.transmitAudioCapability = ALLOC_ASN1ELEM (pctxt, H245AudioCapability); + + stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.transmitAudioCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transmitAudioCapability", -1); + + break; + + /* receiveAndTransmitAudioCapability */ + case 6: + invokeStartElement (pctxt, "receiveAndTransmitAudioCapability", -1); + + pvalue->u.receiveAndTransmitAudioCapability = ALLOC_ASN1ELEM (pctxt, H245AudioCapability); + + stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.receiveAndTransmitAudioCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveAndTransmitAudioCapability", -1); + + break; + + /* receiveDataApplicationCapability */ + case 7: + invokeStartElement (pctxt, "receiveDataApplicationCapability", -1); + + pvalue->u.receiveDataApplicationCapability = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability); + + stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.receiveDataApplicationCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveDataApplicationCapability", -1); + + break; + + /* transmitDataApplicationCapability */ + case 8: + invokeStartElement (pctxt, "transmitDataApplicationCapability", -1); + + pvalue->u.transmitDataApplicationCapability = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability); + + stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.transmitDataApplicationCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transmitDataApplicationCapability", -1); + + break; + + /* receiveAndTransmitDataApplicationCapability */ + case 9: + invokeStartElement (pctxt, "receiveAndTransmitDataApplicationCapability", -1); + + pvalue->u.receiveAndTransmitDataApplicationCapability = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability); + + stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.receiveAndTransmitDataApplicationCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveAndTransmitDataApplicationCapability", -1); + + break; + + /* h233EncryptionTransmitCapability */ + case 10: + invokeStartElement (pctxt, "h233EncryptionTransmitCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->u.h233EncryptionTransmitCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->u.h233EncryptionTransmitCapability); + + invokeEndElement (pctxt, "h233EncryptionTransmitCapability", -1); + + break; + + /* h233EncryptionReceiveCapability */ + case 11: + invokeStartElement (pctxt, "h233EncryptionReceiveCapability", -1); + + pvalue->u.h233EncryptionReceiveCapability = ALLOC_ASN1ELEM (pctxt, H245Capability_h233EncryptionReceiveCapability); + + stat = asn1PD_H245Capability_h233EncryptionReceiveCapability (pctxt, pvalue->u.h233EncryptionReceiveCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h233EncryptionReceiveCapability", -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) { + /* conferenceCapability */ + case 13: + invokeStartElement (pctxt, "conferenceCapability", -1); + + pvalue->u.conferenceCapability = ALLOC_ASN1ELEM (pctxt, H245ConferenceCapability); + + stat = asn1PD_H245ConferenceCapability (pctxt, pvalue->u.conferenceCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "conferenceCapability", -1); + + break; + + /* h235SecurityCapability */ + case 14: + invokeStartElement (pctxt, "h235SecurityCapability", -1); + + pvalue->u.h235SecurityCapability = ALLOC_ASN1ELEM (pctxt, H245H235SecurityCapability); + + stat = asn1PD_H245H235SecurityCapability (pctxt, pvalue->u.h235SecurityCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h235SecurityCapability", -1); + + break; + + /* maxPendingReplacementFor */ + case 15: + invokeStartElement (pctxt, "maxPendingReplacementFor", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->u.maxPendingReplacementFor, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.maxPendingReplacementFor); + + invokeEndElement (pctxt, "maxPendingReplacementFor", -1); + + break; + + /* receiveUserInputCapability */ + case 16: + invokeStartElement (pctxt, "receiveUserInputCapability", -1); + + pvalue->u.receiveUserInputCapability = ALLOC_ASN1ELEM (pctxt, H245UserInputCapability); + + stat = asn1PD_H245UserInputCapability (pctxt, pvalue->u.receiveUserInputCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveUserInputCapability", -1); + + break; + + /* transmitUserInputCapability */ + case 17: + invokeStartElement (pctxt, "transmitUserInputCapability", -1); + + pvalue->u.transmitUserInputCapability = ALLOC_ASN1ELEM (pctxt, H245UserInputCapability); + + stat = asn1PD_H245UserInputCapability (pctxt, pvalue->u.transmitUserInputCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transmitUserInputCapability", -1); + + break; + + /* receiveAndTransmitUserInputCapability */ + case 18: + invokeStartElement (pctxt, "receiveAndTransmitUserInputCapability", -1); + + pvalue->u.receiveAndTransmitUserInputCapability = ALLOC_ASN1ELEM (pctxt, H245UserInputCapability); + + stat = asn1PD_H245UserInputCapability (pctxt, pvalue->u.receiveAndTransmitUserInputCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveAndTransmitUserInputCapability", -1); + + break; + + /* genericControlCapability */ + case 19: + invokeStartElement (pctxt, "genericControlCapability", -1); + + pvalue->u.genericControlCapability = ALLOC_ASN1ELEM (pctxt, H245GenericCapability); + + stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericControlCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericControlCapability", -1); + + break; + + /* receiveMultiplexedStreamCapability */ + case 20: + invokeStartElement (pctxt, "receiveMultiplexedStreamCapability", -1); + + pvalue->u.receiveMultiplexedStreamCapability = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamCapability); + + stat = asn1PD_H245MultiplexedStreamCapability (pctxt, pvalue->u.receiveMultiplexedStreamCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveMultiplexedStreamCapability", -1); + + break; + + /* transmitMultiplexedStreamCapability */ + case 21: + invokeStartElement (pctxt, "transmitMultiplexedStreamCapability", -1); + + pvalue->u.transmitMultiplexedStreamCapability = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamCapability); + + stat = asn1PD_H245MultiplexedStreamCapability (pctxt, pvalue->u.transmitMultiplexedStreamCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transmitMultiplexedStreamCapability", -1); + + break; + + /* receiveAndTransmitMultiplexedStreamCapability */ + case 22: + invokeStartElement (pctxt, "receiveAndTransmitMultiplexedStreamCapability", -1); + + pvalue->u.receiveAndTransmitMultiplexedStreamCapability = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamCapability); + + stat = asn1PD_H245MultiplexedStreamCapability (pctxt, pvalue->u.receiveAndTransmitMultiplexedStreamCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveAndTransmitMultiplexedStreamCapability", -1); + + break; + + /* receiveRTPAudioTelephonyEventCapability */ + case 23: + invokeStartElement (pctxt, "receiveRTPAudioTelephonyEventCapability", -1); + + pvalue->u.receiveRTPAudioTelephonyEventCapability = ALLOC_ASN1ELEM (pctxt, H245AudioTelephonyEventCapability); + + stat = asn1PD_H245AudioTelephonyEventCapability (pctxt, pvalue->u.receiveRTPAudioTelephonyEventCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveRTPAudioTelephonyEventCapability", -1); + + break; + + /* receiveRTPAudioToneCapability */ + case 24: + invokeStartElement (pctxt, "receiveRTPAudioToneCapability", -1); + + pvalue->u.receiveRTPAudioToneCapability = ALLOC_ASN1ELEM (pctxt, H245AudioToneCapability); + + stat = asn1PD_H245AudioToneCapability (pctxt, pvalue->u.receiveRTPAudioToneCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "receiveRTPAudioToneCapability", -1); + + break; + + /* fecCapability */ + case 25: + invokeStartElement (pctxt, "fecCapability", -1); + + pvalue->u.fecCapability = ALLOC_ASN1ELEM (pctxt, H245FECCapability); + + stat = asn1PD_H245FECCapability (pctxt, pvalue->u.fecCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "fecCapability", -1); + + break; + + /* multiplePayloadStreamCapability */ + case 26: + invokeStartElement (pctxt, "multiplePayloadStreamCapability", -1); + + pvalue->u.multiplePayloadStreamCapability = ALLOC_ASN1ELEM (pctxt, H245MultiplePayloadStreamCapability); + + stat = asn1PD_H245MultiplePayloadStreamCapability (pctxt, pvalue->u.multiplePayloadStreamCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplePayloadStreamCapability", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityTableEntry */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CapabilityTableEntry (OOCTXT* pctxt, H245CapabilityTableEntry* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL optbit; + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.capabilityPresent = optbit; + + /* decode capabilityTableEntryNumber */ + + invokeStartElement (pctxt, "capabilityTableEntryNumber", -1); + + stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->capabilityTableEntryNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilityTableEntryNumber", -1); + + /* decode capability */ + + if (pvalue->m.capabilityPresent) { + invokeStartElement (pctxt, "capability", -1); + + stat = asn1PD_H245Capability (pctxt, &pvalue->capability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capability", -1); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet_capabilityTable */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalCapabilitySet_capabilityTable (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityTable* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245CapabilityTableEntry* 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, H245CapabilityTableEntry); + + stat = asn1PD_H245CapabilityTableEntry (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityDescriptorNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CapabilityDescriptorNumber (OOCTXT* pctxt, H245CapabilityDescriptorNumber* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUInt8 (pctxt, pvalue, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityDescriptor_simultaneousCapabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CapabilityDescriptor_simultaneousCapabilities (OOCTXT* pctxt, H245CapabilityDescriptor_simultaneousCapabilities* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245AlternativeCapabilitySet* 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, H245AlternativeCapabilitySet); + + stat = asn1PD_H245AlternativeCapabilitySet (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CapabilityDescriptor (OOCTXT* pctxt, H245CapabilityDescriptor* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL optbit; + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.simultaneousCapabilitiesPresent = optbit; + + /* decode capabilityDescriptorNumber */ + + invokeStartElement (pctxt, "capabilityDescriptorNumber", -1); + + stat = asn1PD_H245CapabilityDescriptorNumber (pctxt, &pvalue->capabilityDescriptorNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilityDescriptorNumber", -1); + + /* decode simultaneousCapabilities */ + + if (pvalue->m.simultaneousCapabilitiesPresent) { + invokeStartElement (pctxt, "simultaneousCapabilities", -1); + + stat = asn1PD_H245CapabilityDescriptor_simultaneousCapabilities (pctxt, &pvalue->simultaneousCapabilities); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "simultaneousCapabilities", -1); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet_capabilityDescriptors */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalCapabilitySet_capabilityDescriptors (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityDescriptors* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245CapabilityDescriptor* 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, H245CapabilityDescriptor); + + stat = asn1PD_H245CapabilityDescriptor (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalCapabilitySet (OOCTXT* pctxt, H245TerminalCapabilitySet* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.multiplexCapabilityPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.capabilityTablePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.capabilityDescriptorsPresent = optbit; + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode protocolIdentifier */ + + invokeStartElement (pctxt, "protocolIdentifier", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->protocolIdentifier.numids, pvalue->protocolIdentifier.subid); + + invokeEndElement (pctxt, "protocolIdentifier", -1); + + /* decode multiplexCapability */ + + if (pvalue->m.multiplexCapabilityPresent) { + invokeStartElement (pctxt, "multiplexCapability", -1); + + stat = asn1PD_H245MultiplexCapability (pctxt, &pvalue->multiplexCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexCapability", -1); + } + + /* decode capabilityTable */ + + if (pvalue->m.capabilityTablePresent) { + invokeStartElement (pctxt, "capabilityTable", -1); + + stat = asn1PD_H245TerminalCapabilitySet_capabilityTable (pctxt, &pvalue->capabilityTable); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilityTable", -1); + } + + /* decode capabilityDescriptors */ + + if (pvalue->m.capabilityDescriptorsPresent) { + invokeStartElement (pctxt, "capabilityDescriptors", -1); + + stat = asn1PD_H245TerminalCapabilitySet_capabilityDescriptors (pctxt, &pvalue->capabilityDescriptors); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilityDescriptors", -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); +} + +/**************************************************************/ +/* */ +/* LogicalChannelNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245LogicalChannelNumber (OOCTXT* pctxt, H245LogicalChannelNumber* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUInt16 (pctxt, pvalue, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EncryptionMode (OOCTXT* pctxt, H245EncryptionMode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* h233Encryption */ + case 1: + invokeStartElement (pctxt, "h233Encryption", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "h233Encryption", -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); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingElement (OOCTXT* pctxt, H245RedundancyEncodingElement* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.payloadTypePresent = optbit; + + /* decode dataType */ + + invokeStartElement (pctxt, "dataType", -1); + + pvalue->dataType = ALLOC_ASN1ELEM (pctxt, H245DataType); + + stat = asn1PD_H245DataType (pctxt, (H245DataType*)pvalue->dataType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dataType", -1); + + /* decode payloadType */ + + if (pvalue->m.payloadTypePresent) { + invokeStartElement (pctxt, "payloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->payloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->payloadType); + + invokeEndElement (pctxt, "payloadType", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245RedundancyEncodingElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245RedundancyEncodingElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingElement* pvalue) +{ + int stat = ASN_OK; + H245RedundancyEncodingElement* 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, H245RedundancyEncodingElement); + + stat = asn1PD_H245RedundancyEncodingElement (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncoding_rtpRedundancyEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncoding_rtpRedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding_rtpRedundancyEncoding* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.primaryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.secondaryPresent = optbit; + + /* decode primary */ + + if (pvalue->m.primaryPresent) { + invokeStartElement (pctxt, "primary", -1); + + stat = asn1PD_H245RedundancyEncodingElement (pctxt, &pvalue->primary); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "primary", -1); + } + + /* decode secondary */ + + if (pvalue->m.secondaryPresent) { + invokeStartElement (pctxt, "secondary", -1); + + stat = asn1PD_H245_SeqOfH245RedundancyEncodingElement (pctxt, &pvalue->secondary); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "secondary", -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); +} + +/**************************************************************/ +/* */ +/* RedundancyEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.secondaryEncodingPresent = optbit; + + /* decode redundancyEncodingMethod */ + + invokeStartElement (pctxt, "redundancyEncodingMethod", -1); + + stat = asn1PD_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncodingMethod", -1); + + /* decode secondaryEncoding */ + + if (pvalue->m.secondaryEncodingPresent) { + invokeStartElement (pctxt, "secondaryEncoding", -1); + + pvalue->secondaryEncoding = ALLOC_ASN1ELEM (pctxt, H245DataType); + + stat = asn1PD_H245DataType (pctxt, (H245DataType*)pvalue->secondaryEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "secondaryEncoding", -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.rtpRedundancyEncodingPresent = 1; + + invokeStartElement (pctxt, "rtpRedundancyEncoding", -1); + + stat = asn1PD_H245RedundancyEncoding_rtpRedundancyEncoding (pctxt, &pvalue->rtpRedundancyEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rtpRedundancyEncoding", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplePayloadStreamElement (OOCTXT* pctxt, H245MultiplePayloadStreamElement* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.payloadTypePresent = optbit; + + /* decode dataType */ + + invokeStartElement (pctxt, "dataType", -1); + + pvalue->dataType = ALLOC_ASN1ELEM (pctxt, H245DataType); + + stat = asn1PD_H245DataType (pctxt, (H245DataType*)pvalue->dataType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dataType", -1); + + /* decode payloadType */ + + if (pvalue->m.payloadTypePresent) { + invokeStartElement (pctxt, "payloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->payloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->payloadType); + + invokeEndElement (pctxt, "payloadType", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245MultiplePayloadStreamElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245MultiplePayloadStreamElement (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElement* pvalue) +{ + int stat = ASN_OK; + H245MultiplePayloadStreamElement* 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, H245MultiplePayloadStreamElement); + + stat = asn1PD_H245MultiplePayloadStreamElement (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplePayloadStream (OOCTXT* pctxt, H245MultiplePayloadStream* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode elements */ + + invokeStartElement (pctxt, "elements", -1); + + stat = asn1PD_H245_SeqOfH245MultiplePayloadStreamElement (pctxt, &pvalue->elements); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "elements", -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); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream_differentPort */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_differentPort* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.protectedPayloadTypePresent = optbit; + + /* decode protectedSessionID */ + + invokeStartElement (pctxt, "protectedSessionID", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->protectedSessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->protectedSessionID); + + invokeEndElement (pctxt, "protectedSessionID", -1); + + /* decode protectedPayloadType */ + + if (pvalue->m.protectedPayloadTypePresent) { + invokeStartElement (pctxt, "protectedPayloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->protectedPayloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->protectedPayloadType); + + invokeEndElement (pctxt, "protectedPayloadType", -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); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream_samePort */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream_samePort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_samePort* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode protectedPayloadType */ + + invokeStartElement (pctxt, "protectedPayloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->protectedPayloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->protectedPayloadType); + + invokeEndElement (pctxt, "protectedPayloadType", -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); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECData_rfc2733_mode_separateStream (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* differentPort */ + case 0: + invokeStartElement (pctxt, "differentPort", -1); + + pvalue->u.differentPort = ALLOC_ASN1ELEM (pctxt, H245FECData_rfc2733_mode_separateStream_differentPort); + + stat = asn1PD_H245FECData_rfc2733_mode_separateStream_differentPort (pctxt, pvalue->u.differentPort); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "differentPort", -1); + + break; + + /* samePort */ + case 1: + invokeStartElement (pctxt, "samePort", -1); + + pvalue->u.samePort = ALLOC_ASN1ELEM (pctxt, H245FECData_rfc2733_mode_separateStream_samePort); + + stat = asn1PD_H245FECData_rfc2733_mode_separateStream_samePort (pctxt, pvalue->u.samePort); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "samePort", -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); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECData_rfc2733_mode (OOCTXT* pctxt, H245FECData_rfc2733_mode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* redundancyEncoding */ + case 0: + invokeStartElement (pctxt, "redundancyEncoding", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "redundancyEncoding", -1); + + break; + + /* separateStream */ + case 1: + invokeStartElement (pctxt, "separateStream", -1); + + pvalue->u.separateStream = ALLOC_ASN1ELEM (pctxt, H245FECData_rfc2733_mode_separateStream); + + stat = asn1PD_H245FECData_rfc2733_mode_separateStream (pctxt, pvalue->u.separateStream); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "separateStream", -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); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECData_rfc2733 (OOCTXT* pctxt, H245FECData_rfc2733* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode mode */ + + invokeStartElement (pctxt, "mode", -1); + + stat = asn1PD_H245FECData_rfc2733_mode (pctxt, &pvalue->mode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mode", -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); +} + +/**************************************************************/ +/* */ +/* FECData */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECData (OOCTXT* pctxt, H245FECData* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* rfc2733 */ + case 0: + invokeStartElement (pctxt, "rfc2733", -1); + + pvalue->u.rfc2733 = ALLOC_ASN1ELEM (pctxt, H245FECData_rfc2733); + + stat = asn1PD_H245FECData_rfc2733 (pctxt, pvalue->u.rfc2733); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rfc2733", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H235Media_mediaType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H235Media_mediaType (OOCTXT* pctxt, H245H235Media_mediaType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* videoData */ + case 1: + invokeStartElement (pctxt, "videoData", -1); + + pvalue->u.videoData = ALLOC_ASN1ELEM (pctxt, H245VideoCapability); + + stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.videoData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoData", -1); + + break; + + /* audioData */ + case 2: + invokeStartElement (pctxt, "audioData", -1); + + pvalue->u.audioData = ALLOC_ASN1ELEM (pctxt, H245AudioCapability); + + stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.audioData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioData", -1); + + break; + + /* data */ + case 3: + invokeStartElement (pctxt, "data", -1); + + pvalue->u.data = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability); + + stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.data); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "data", -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) { + /* redundancyEncoding */ + case 5: + invokeStartElement (pctxt, "redundancyEncoding", -1); + + pvalue->u.redundancyEncoding = ALLOC_ASN1ELEM (pctxt, H245RedundancyEncoding); + + stat = asn1PD_H245RedundancyEncoding (pctxt, pvalue->u.redundancyEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncoding", -1); + + break; + + /* multiplePayloadStream */ + case 6: + invokeStartElement (pctxt, "multiplePayloadStream", -1); + + pvalue->u.multiplePayloadStream = ALLOC_ASN1ELEM (pctxt, H245MultiplePayloadStream); + + stat = asn1PD_H245MultiplePayloadStream (pctxt, pvalue->u.multiplePayloadStream); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplePayloadStream", -1); + + break; + + /* fec */ + case 7: + invokeStartElement (pctxt, "fec", -1); + + pvalue->u.fec = ALLOC_ASN1ELEM (pctxt, H245FECData); + + stat = asn1PD_H245FECData (pctxt, pvalue->u.fec); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "fec", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H235Media */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H235Media (OOCTXT* pctxt, H245H235Media* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode encryptionAuthenticationAndIntegrity */ + + invokeStartElement (pctxt, "encryptionAuthenticationAndIntegrity", -1); + + stat = asn1PD_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionAuthenticationAndIntegrity", -1); + + /* decode mediaType */ + + invokeStartElement (pctxt, "mediaType", -1); + + stat = asn1PD_H245H235Media_mediaType (pctxt, &pvalue->mediaType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaType", -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); +} + +/**************************************************************/ +/* */ +/* MultiplexedStreamParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexedStreamParameter (OOCTXT* pctxt, H245MultiplexedStreamParameter* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode multiplexFormat */ + + invokeStartElement (pctxt, "multiplexFormat", -1); + + stat = asn1PD_H245MultiplexFormat (pctxt, &pvalue->multiplexFormat); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexFormat", -1); + + /* decode controlOnMuxStream */ + + invokeStartElement (pctxt, "controlOnMuxStream", -1); + + stat = DECODEBIT (pctxt, &pvalue->controlOnMuxStream); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->controlOnMuxStream); + + invokeEndElement (pctxt, "controlOnMuxStream", -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); +} + +/**************************************************************/ +/* */ +/* DataType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataType (OOCTXT* pctxt, H245DataType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* nullData */ + case 1: + invokeStartElement (pctxt, "nullData", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "nullData", -1); + + break; + + /* videoData */ + case 2: + invokeStartElement (pctxt, "videoData", -1); + + pvalue->u.videoData = ALLOC_ASN1ELEM (pctxt, H245VideoCapability); + + stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.videoData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoData", -1); + + break; + + /* audioData */ + case 3: + invokeStartElement (pctxt, "audioData", -1); + + pvalue->u.audioData = ALLOC_ASN1ELEM (pctxt, H245AudioCapability); + + stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.audioData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioData", -1); + + break; + + /* data */ + case 4: + invokeStartElement (pctxt, "data", -1); + + pvalue->u.data = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability); + + stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.data); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "data", -1); + + break; + + /* encryptionData */ + case 5: + invokeStartElement (pctxt, "encryptionData", -1); + + pvalue->u.encryptionData = ALLOC_ASN1ELEM (pctxt, H245EncryptionMode); + + stat = asn1PD_H245EncryptionMode (pctxt, pvalue->u.encryptionData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionData", -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) { + /* h235Control */ + case 7: + invokeStartElement (pctxt, "h235Control", -1); + + pvalue->u.h235Control = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.h235Control); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h235Control", -1); + + break; + + /* h235Media */ + case 8: + invokeStartElement (pctxt, "h235Media", -1); + + pvalue->u.h235Media = ALLOC_ASN1ELEM (pctxt, H245H235Media); + + stat = asn1PD_H245H235Media (pctxt, pvalue->u.h235Media); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h235Media", -1); + + break; + + /* multiplexedStream */ + case 9: + invokeStartElement (pctxt, "multiplexedStream", -1); + + pvalue->u.multiplexedStream = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamParameter); + + stat = asn1PD_H245MultiplexedStreamParameter (pctxt, pvalue->u.multiplexedStream); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexedStream", -1); + + break; + + /* redundancyEncoding */ + case 10: + invokeStartElement (pctxt, "redundancyEncoding", -1); + + pvalue->u.redundancyEncoding = ALLOC_ASN1ELEM (pctxt, H245RedundancyEncoding); + + stat = asn1PD_H245RedundancyEncoding (pctxt, pvalue->u.redundancyEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncoding", -1); + + break; + + /* multiplePayloadStream */ + case 11: + invokeStartElement (pctxt, "multiplePayloadStream", -1); + + pvalue->u.multiplePayloadStream = ALLOC_ASN1ELEM (pctxt, H245MultiplePayloadStream); + + stat = asn1PD_H245MultiplePayloadStream (pctxt, pvalue->u.multiplePayloadStream); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplePayloadStream", -1); + + break; + + /* fec */ + case 12: + invokeStartElement (pctxt, "fec", -1); + + pvalue->u.fec = ALLOC_ASN1ELEM (pctxt, H245FECData); + + stat = asn1PD_H245FECData (pctxt, pvalue->u.fec); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "fec", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H222LogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H222LogicalChannelParameters (OOCTXT* pctxt, H245H222LogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.pcr_pidPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.programDescriptorsPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.streamDescriptorsPresent = optbit; + + /* decode resourceID */ + + invokeStartElement (pctxt, "resourceID", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->resourceID); + + invokeEndElement (pctxt, "resourceID", -1); + + /* decode subChannelID */ + + invokeStartElement (pctxt, "subChannelID", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->subChannelID, 0U, 8191U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->subChannelID); + + invokeEndElement (pctxt, "subChannelID", -1); + + /* decode pcr_pid */ + + if (pvalue->m.pcr_pidPresent) { + invokeStartElement (pctxt, "pcr_pid", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->pcr_pid, 0U, 8191U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->pcr_pid); + + invokeEndElement (pctxt, "pcr_pid", -1); + } + + /* decode programDescriptors */ + + if (pvalue->m.programDescriptorsPresent) { + invokeStartElement (pctxt, "programDescriptors", -1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->programDescriptors); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->programDescriptors.numocts, pvalue->programDescriptors.data); + + invokeEndElement (pctxt, "programDescriptors", -1); + } + + /* decode streamDescriptors */ + + if (pvalue->m.streamDescriptorsPresent) { + invokeStartElement (pctxt, "streamDescriptors", -1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->streamDescriptors); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->streamDescriptors.numocts, pvalue->streamDescriptors.data); + + invokeEndElement (pctxt, "streamDescriptors", -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); +} + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters_adaptationLayerType_al3 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223LogicalChannelParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3* pvalue) +{ + int stat = ASN_OK; + + /* decode controlFieldOctets */ + + invokeStartElement (pctxt, "controlFieldOctets", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->controlFieldOctets, 0U, 2U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->controlFieldOctets); + + invokeEndElement (pctxt, "controlFieldOctets", -1); + + /* decode sendBufferSize */ + + invokeStartElement (pctxt, "sendBufferSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->sendBufferSize, 0U, 16777215U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sendBufferSize); + + invokeEndElement (pctxt, "sendBufferSize", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters_transferMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL1MParameters_transferMode (OOCTXT* pctxt, H245H223AL1MParameters_transferMode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* framed */ + case 0: + invokeStartElement (pctxt, "framed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "framed", -1); + + break; + + /* unframed */ + case 1: + invokeStartElement (pctxt, "unframed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unframed", -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); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters_headerFEC */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL1MParameters_headerFEC (OOCTXT* pctxt, H245H223AL1MParameters_headerFEC* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* sebch16_7 */ + case 0: + invokeStartElement (pctxt, "sebch16_7", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "sebch16_7", -1); + + break; + + /* golay24_12 */ + case 1: + invokeStartElement (pctxt, "golay24_12", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "golay24_12", -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); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters_crcLength */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL1MParameters_crcLength (OOCTXT* pctxt, H245H223AL1MParameters_crcLength* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* crc4bit */ + case 0: + invokeStartElement (pctxt, "crc4bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc4bit", -1); + + break; + + /* crc12bit */ + case 1: + invokeStartElement (pctxt, "crc12bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc12bit", -1); + + break; + + /* crc20bit */ + case 2: + invokeStartElement (pctxt, "crc20bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc20bit", -1); + + break; + + /* crc28bit */ + case 3: + invokeStartElement (pctxt, "crc28bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc28bit", -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) { + /* crc8bit */ + case 5: + invokeStartElement (pctxt, "crc8bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc8bit", -1); + + break; + + /* crc16bit */ + case 6: + invokeStartElement (pctxt, "crc16bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc16bit", -1); + + break; + + /* crc32bit */ + case 7: + invokeStartElement (pctxt, "crc32bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc32bit", -1); + + break; + + /* crcNotUsed */ + case 8: + invokeStartElement (pctxt, "crcNotUsed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crcNotUsed", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AnnexCArqParameters_numberOfRetransmissions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AnnexCArqParameters_numberOfRetransmissions (OOCTXT* pctxt, H245H223AnnexCArqParameters_numberOfRetransmissions* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* finite */ + case 0: + invokeStartElement (pctxt, "finite", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->u.finite, 0U, 16U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.finite); + + invokeEndElement (pctxt, "finite", -1); + + break; + + /* infinite */ + case 1: + invokeStartElement (pctxt, "infinite", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "infinite", -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); +} + +/**************************************************************/ +/* */ +/* H223AnnexCArqParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AnnexCArqParameters (OOCTXT* pctxt, H245H223AnnexCArqParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode numberOfRetransmissions */ + + invokeStartElement (pctxt, "numberOfRetransmissions", -1); + + stat = asn1PD_H245H223AnnexCArqParameters_numberOfRetransmissions (pctxt, &pvalue->numberOfRetransmissions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "numberOfRetransmissions", -1); + + /* decode sendBufferSize */ + + invokeStartElement (pctxt, "sendBufferSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->sendBufferSize, 0U, 16777215U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sendBufferSize); + + invokeEndElement (pctxt, "sendBufferSize", -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); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters_arqType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL1MParameters_arqType (OOCTXT* pctxt, H245H223AL1MParameters_arqType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* noArq */ + case 0: + invokeStartElement (pctxt, "noArq", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noArq", -1); + + break; + + /* typeIArq */ + case 1: + invokeStartElement (pctxt, "typeIArq", -1); + + pvalue->u.typeIArq = ALLOC_ASN1ELEM (pctxt, H245H223AnnexCArqParameters); + + stat = asn1PD_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIArq); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "typeIArq", -1); + + break; + + /* typeIIArq */ + case 2: + invokeStartElement (pctxt, "typeIIArq", -1); + + pvalue->u.typeIIArq = ALLOC_ASN1ELEM (pctxt, H245H223AnnexCArqParameters); + + stat = asn1PD_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIIArq); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "typeIIArq", -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); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL1MParameters (OOCTXT* pctxt, H245H223AL1MParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode transferMode */ + + invokeStartElement (pctxt, "transferMode", -1); + + stat = asn1PD_H245H223AL1MParameters_transferMode (pctxt, &pvalue->transferMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transferMode", -1); + + /* decode headerFEC */ + + invokeStartElement (pctxt, "headerFEC", -1); + + stat = asn1PD_H245H223AL1MParameters_headerFEC (pctxt, &pvalue->headerFEC); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "headerFEC", -1); + + /* decode crcLength */ + + invokeStartElement (pctxt, "crcLength", -1); + + stat = asn1PD_H245H223AL1MParameters_crcLength (pctxt, &pvalue->crcLength); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "crcLength", -1); + + /* decode rcpcCodeRate */ + + invokeStartElement (pctxt, "rcpcCodeRate", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->rcpcCodeRate, 8U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->rcpcCodeRate); + + invokeEndElement (pctxt, "rcpcCodeRate", -1); + + /* decode arqType */ + + invokeStartElement (pctxt, "arqType", -1); + + stat = asn1PD_H245H223AL1MParameters_arqType (pctxt, &pvalue->arqType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "arqType", -1); + + /* decode alpduInterleaving */ + + invokeStartElement (pctxt, "alpduInterleaving", -1); + + stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->alpduInterleaving); + + invokeEndElement (pctxt, "alpduInterleaving", -1); + + /* decode alsduSplitting */ + + invokeStartElement (pctxt, "alsduSplitting", -1); + + stat = DECODEBIT (pctxt, &pvalue->alsduSplitting); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->alsduSplitting); + + invokeEndElement (pctxt, "alsduSplitting", -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.rsCodeCorrectionPresent = 1; + + invokeStartElement (pctxt, "rsCodeCorrection", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->rsCodeCorrection, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->rsCodeCorrection); + + invokeEndElement (pctxt, "rsCodeCorrection", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL2MParameters_headerFEC */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL2MParameters_headerFEC (OOCTXT* pctxt, H245H223AL2MParameters_headerFEC* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* sebch16_5 */ + case 0: + invokeStartElement (pctxt, "sebch16_5", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "sebch16_5", -1); + + break; + + /* golay24_12 */ + case 1: + invokeStartElement (pctxt, "golay24_12", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "golay24_12", -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); +} + +/**************************************************************/ +/* */ +/* H223AL2MParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL2MParameters (OOCTXT* pctxt, H245H223AL2MParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode headerFEC */ + + invokeStartElement (pctxt, "headerFEC", -1); + + stat = asn1PD_H245H223AL2MParameters_headerFEC (pctxt, &pvalue->headerFEC); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "headerFEC", -1); + + /* decode alpduInterleaving */ + + invokeStartElement (pctxt, "alpduInterleaving", -1); + + stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->alpduInterleaving); + + invokeEndElement (pctxt, "alpduInterleaving", -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); +} + +/**************************************************************/ +/* */ +/* H223AL3MParameters_headerFormat */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL3MParameters_headerFormat (OOCTXT* pctxt, H245H223AL3MParameters_headerFormat* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* sebch16_7 */ + case 0: + invokeStartElement (pctxt, "sebch16_7", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "sebch16_7", -1); + + break; + + /* golay24_12 */ + case 1: + invokeStartElement (pctxt, "golay24_12", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "golay24_12", -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); +} + +/**************************************************************/ +/* */ +/* H223AL3MParameters_crcLength */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL3MParameters_crcLength (OOCTXT* pctxt, H245H223AL3MParameters_crcLength* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* crc4bit */ + case 0: + invokeStartElement (pctxt, "crc4bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc4bit", -1); + + break; + + /* crc12bit */ + case 1: + invokeStartElement (pctxt, "crc12bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc12bit", -1); + + break; + + /* crc20bit */ + case 2: + invokeStartElement (pctxt, "crc20bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc20bit", -1); + + break; + + /* crc28bit */ + case 3: + invokeStartElement (pctxt, "crc28bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc28bit", -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) { + /* crc8bit */ + case 5: + invokeStartElement (pctxt, "crc8bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc8bit", -1); + + break; + + /* crc16bit */ + case 6: + invokeStartElement (pctxt, "crc16bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc16bit", -1); + + break; + + /* crc32bit */ + case 7: + invokeStartElement (pctxt, "crc32bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc32bit", -1); + + break; + + /* crcNotUsed */ + case 8: + invokeStartElement (pctxt, "crcNotUsed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crcNotUsed", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL3MParameters_arqType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL3MParameters_arqType (OOCTXT* pctxt, H245H223AL3MParameters_arqType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* noArq */ + case 0: + invokeStartElement (pctxt, "noArq", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noArq", -1); + + break; + + /* typeIArq */ + case 1: + invokeStartElement (pctxt, "typeIArq", -1); + + pvalue->u.typeIArq = ALLOC_ASN1ELEM (pctxt, H245H223AnnexCArqParameters); + + stat = asn1PD_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIArq); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "typeIArq", -1); + + break; + + /* typeIIArq */ + case 2: + invokeStartElement (pctxt, "typeIIArq", -1); + + pvalue->u.typeIIArq = ALLOC_ASN1ELEM (pctxt, H245H223AnnexCArqParameters); + + stat = asn1PD_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIIArq); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "typeIIArq", -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); +} + +/**************************************************************/ +/* */ +/* H223AL3MParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223AL3MParameters (OOCTXT* pctxt, H245H223AL3MParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode headerFormat */ + + invokeStartElement (pctxt, "headerFormat", -1); + + stat = asn1PD_H245H223AL3MParameters_headerFormat (pctxt, &pvalue->headerFormat); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "headerFormat", -1); + + /* decode crcLength */ + + invokeStartElement (pctxt, "crcLength", -1); + + stat = asn1PD_H245H223AL3MParameters_crcLength (pctxt, &pvalue->crcLength); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "crcLength", -1); + + /* decode rcpcCodeRate */ + + invokeStartElement (pctxt, "rcpcCodeRate", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->rcpcCodeRate, 8U, 32U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->rcpcCodeRate); + + invokeEndElement (pctxt, "rcpcCodeRate", -1); + + /* decode arqType */ + + invokeStartElement (pctxt, "arqType", -1); + + stat = asn1PD_H245H223AL3MParameters_arqType (pctxt, &pvalue->arqType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "arqType", -1); + + /* decode alpduInterleaving */ + + invokeStartElement (pctxt, "alpduInterleaving", -1); + + stat = DECODEBIT (pctxt, &pvalue->alpduInterleaving); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->alpduInterleaving); + + invokeEndElement (pctxt, "alpduInterleaving", -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.rsCodeCorrectionPresent = 1; + + invokeStartElement (pctxt, "rsCodeCorrection", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->rsCodeCorrection, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->rsCodeCorrection); + + invokeEndElement (pctxt, "rsCodeCorrection", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters_adaptationLayerType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223LogicalChannelParameters_adaptationLayerType (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* al1Framed */ + case 1: + invokeStartElement (pctxt, "al1Framed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "al1Framed", -1); + + break; + + /* al1NotFramed */ + case 2: + invokeStartElement (pctxt, "al1NotFramed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "al1NotFramed", -1); + + break; + + /* al2WithoutSequenceNumbers */ + case 3: + invokeStartElement (pctxt, "al2WithoutSequenceNumbers", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "al2WithoutSequenceNumbers", -1); + + break; + + /* al2WithSequenceNumbers */ + case 4: + invokeStartElement (pctxt, "al2WithSequenceNumbers", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "al2WithSequenceNumbers", -1); + + break; + + /* al3 */ + case 5: + invokeStartElement (pctxt, "al3", -1); + + pvalue->u.al3 = ALLOC_ASN1ELEM (pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3); + + stat = asn1PD_H245H223LogicalChannelParameters_adaptationLayerType_al3 (pctxt, pvalue->u.al3); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "al3", -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) { + /* al1M */ + case 7: + invokeStartElement (pctxt, "al1M", -1); + + pvalue->u.al1M = ALLOC_ASN1ELEM (pctxt, H245H223AL1MParameters); + + stat = asn1PD_H245H223AL1MParameters (pctxt, pvalue->u.al1M); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "al1M", -1); + + break; + + /* al2M */ + case 8: + invokeStartElement (pctxt, "al2M", -1); + + pvalue->u.al2M = ALLOC_ASN1ELEM (pctxt, H245H223AL2MParameters); + + stat = asn1PD_H245H223AL2MParameters (pctxt, pvalue->u.al2M); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "al2M", -1); + + break; + + /* al3M */ + case 9: + invokeStartElement (pctxt, "al3M", -1); + + pvalue->u.al3M = ALLOC_ASN1ELEM (pctxt, H245H223AL3MParameters); + + stat = asn1PD_H245H223AL3MParameters (pctxt, pvalue->u.al3M); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "al3M", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223LogicalChannelParameters (OOCTXT* pctxt, H245H223LogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode adaptationLayerType */ + + invokeStartElement (pctxt, "adaptationLayerType", -1); + + stat = asn1PD_H245H223LogicalChannelParameters_adaptationLayerType (pctxt, &pvalue->adaptationLayerType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "adaptationLayerType", -1); + + /* decode segmentableFlag */ + + invokeStartElement (pctxt, "segmentableFlag", -1); + + stat = DECODEBIT (pctxt, &pvalue->segmentableFlag); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->segmentableFlag); + + invokeEndElement (pctxt, "segmentableFlag", -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); +} + +/**************************************************************/ +/* */ +/* CRCLength */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CRCLength (OOCTXT* pctxt, H245CRCLength* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* crc8bit */ + case 0: + invokeStartElement (pctxt, "crc8bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc8bit", -1); + + break; + + /* crc16bit */ + case 1: + invokeStartElement (pctxt, "crc16bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc16bit", -1); + + break; + + /* crc32bit */ + case 2: + invokeStartElement (pctxt, "crc32bit", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "crc32bit", -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); +} + +/**************************************************************/ +/* */ +/* V76HDLCParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V76HDLCParameters (OOCTXT* pctxt, H245V76HDLCParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode crcLength */ + + invokeStartElement (pctxt, "crcLength", -1); + + stat = asn1PD_H245CRCLength (pctxt, &pvalue->crcLength); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "crcLength", -1); + + /* decode n401 */ + + invokeStartElement (pctxt, "n401", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->n401, 1U, 4095U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->n401); + + invokeEndElement (pctxt, "n401", -1); + + /* decode loopbackTestProcedure */ + + invokeStartElement (pctxt, "loopbackTestProcedure", -1); + + stat = DECODEBIT (pctxt, &pvalue->loopbackTestProcedure); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->loopbackTestProcedure); + + invokeEndElement (pctxt, "loopbackTestProcedure", -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); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_suspendResume */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V76LogicalChannelParameters_suspendResume (OOCTXT* pctxt, H245V76LogicalChannelParameters_suspendResume* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* noSuspendResume */ + case 0: + invokeStartElement (pctxt, "noSuspendResume", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noSuspendResume", -1); + + break; + + /* suspendResumewAddress */ + case 1: + invokeStartElement (pctxt, "suspendResumewAddress", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "suspendResumewAddress", -1); + + break; + + /* suspendResumewoAddress */ + case 2: + invokeStartElement (pctxt, "suspendResumewoAddress", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "suspendResumewoAddress", -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); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode_eRM_recovery */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V76LogicalChannelParameters_mode_eRM_recovery (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM_recovery* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* rej */ + case 0: + invokeStartElement (pctxt, "rej", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "rej", -1); + + break; + + /* sREJ */ + case 1: + invokeStartElement (pctxt, "sREJ", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "sREJ", -1); + + break; + + /* mSREJ */ + case 2: + invokeStartElement (pctxt, "mSREJ", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "mSREJ", -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); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode_eRM */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V76LogicalChannelParameters_mode_eRM (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode windowSize */ + + invokeStartElement (pctxt, "windowSize", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->windowSize, 1U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->windowSize); + + invokeEndElement (pctxt, "windowSize", -1); + + /* decode recovery */ + + invokeStartElement (pctxt, "recovery", -1); + + stat = asn1PD_H245V76LogicalChannelParameters_mode_eRM_recovery (pctxt, &pvalue->recovery); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "recovery", -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); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V76LogicalChannelParameters_mode (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* eRM */ + case 0: + invokeStartElement (pctxt, "eRM", -1); + + pvalue->u.eRM = ALLOC_ASN1ELEM (pctxt, H245V76LogicalChannelParameters_mode_eRM); + + stat = asn1PD_H245V76LogicalChannelParameters_mode_eRM (pctxt, pvalue->u.eRM); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "eRM", -1); + + break; + + /* uNERM */ + case 1: + invokeStartElement (pctxt, "uNERM", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "uNERM", -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); +} + +/**************************************************************/ +/* */ +/* V75Parameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V75Parameters (OOCTXT* pctxt, H245V75Parameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode audioHeaderPresent */ + + invokeStartElement (pctxt, "audioHeaderPresent", -1); + + stat = DECODEBIT (pctxt, &pvalue->audioHeaderPresent); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->audioHeaderPresent); + + invokeEndElement (pctxt, "audioHeaderPresent", -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); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V76LogicalChannelParameters (OOCTXT* pctxt, H245V76LogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode hdlcParameters */ + + invokeStartElement (pctxt, "hdlcParameters", -1); + + stat = asn1PD_H245V76HDLCParameters (pctxt, &pvalue->hdlcParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "hdlcParameters", -1); + + /* decode suspendResume */ + + invokeStartElement (pctxt, "suspendResume", -1); + + stat = asn1PD_H245V76LogicalChannelParameters_suspendResume (pctxt, &pvalue->suspendResume); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "suspendResume", -1); + + /* decode uIH */ + + invokeStartElement (pctxt, "uIH", -1); + + stat = DECODEBIT (pctxt, &pvalue->uIH); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->uIH); + + invokeEndElement (pctxt, "uIH", -1); + + /* decode mode */ + + invokeStartElement (pctxt, "mode", -1); + + stat = asn1PD_H245V76LogicalChannelParameters_mode (pctxt, &pvalue->mode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mode", -1); + + /* decode v75Parameters */ + + invokeStartElement (pctxt, "v75Parameters", -1); + + stat = asn1PD_H245V75Parameters (pctxt, &pvalue->v75Parameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "v75Parameters", -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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPAddress_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPAddress_network* 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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPAddress (OOCTXT* pctxt, H245UnicastAddress_iPAddress* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode network */ + + invokeStartElement (pctxt, "network", -1); + + stat = asn1PD_H245UnicastAddress_iPAddress_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "network", -1); + + /* decode tsapIdentifier */ + + invokeStartElement (pctxt, "tsapIdentifier", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->tsapIdentifier); + + invokeEndElement (pctxt, "tsapIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_node */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPXAddress_node (OOCTXT* pctxt, H245UnicastAddress_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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_netnum */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPXAddress_netnum (OOCTXT* pctxt, H245UnicastAddress_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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_tsapIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPXAddress_tsapIdentifier (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_tsapIdentifier* 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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPXAddress (OOCTXT* pctxt, H245UnicastAddress_iPXAddress* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode node */ + + invokeStartElement (pctxt, "node", -1); + + stat = asn1PD_H245UnicastAddress_iPXAddress_node (pctxt, &pvalue->node); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "node", -1); + + /* decode netnum */ + + invokeStartElement (pctxt, "netnum", -1); + + stat = asn1PD_H245UnicastAddress_iPXAddress_netnum (pctxt, &pvalue->netnum); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "netnum", -1); + + /* decode tsapIdentifier */ + + invokeStartElement (pctxt, "tsapIdentifier", -1); + + stat = asn1PD_H245UnicastAddress_iPXAddress_tsapIdentifier (pctxt, &pvalue->tsapIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "tsapIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iP6Address_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iP6Address_network (OOCTXT* pctxt, H245UnicastAddress_iP6Address_network* 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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iP6Address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iP6Address (OOCTXT* pctxt, H245UnicastAddress_iP6Address* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode network */ + + invokeStartElement (pctxt, "network", -1); + + stat = asn1PD_H245UnicastAddress_iP6Address_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "network", -1); + + /* decode tsapIdentifier */ + + invokeStartElement (pctxt, "tsapIdentifier", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->tsapIdentifier); + + invokeEndElement (pctxt, "tsapIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_netBios */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_netBios (OOCTXT* pctxt, H245UnicastAddress_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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_routing */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_routing (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_routing* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + 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; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_network* 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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_route_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245UnicastAddress_iPSourceRouteAddress_route_elem */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_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, H245UnicastAddress_iPSourceRouteAddress_route_element); + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245UnicastAddress_iPSourceRouteAddress_route_element (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_iPSourceRouteAddress (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode routing */ + + invokeStartElement (pctxt, "routing", -1); + + stat = asn1PD_H245UnicastAddress_iPSourceRouteAddress_routing (pctxt, &pvalue->routing); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "routing", -1); + + /* decode network */ + + invokeStartElement (pctxt, "network", -1); + + stat = asn1PD_H245UnicastAddress_iPSourceRouteAddress_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "network", -1); + + /* decode tsapIdentifier */ + + invokeStartElement (pctxt, "tsapIdentifier", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->tsapIdentifier); + + invokeEndElement (pctxt, "tsapIdentifier", -1); + + /* decode route */ + + invokeStartElement (pctxt, "route", -1); + + stat = asn1PD_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (pctxt, &pvalue->route); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "route", -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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_nsap */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress_nsap (OOCTXT* pctxt, H245UnicastAddress_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); +} + +/**************************************************************/ +/* */ +/* UnicastAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UnicastAddress (OOCTXT* pctxt, H245UnicastAddress* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* 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) { + /* iPAddress */ + case 0: + invokeStartElement (pctxt, "iPAddress", -1); + + pvalue->u.iPAddress = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_iPAddress); + + stat = asn1PD_H245UnicastAddress_iPAddress (pctxt, pvalue->u.iPAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "iPAddress", -1); + + break; + + /* iPXAddress */ + case 1: + invokeStartElement (pctxt, "iPXAddress", -1); + + pvalue->u.iPXAddress = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_iPXAddress); + + stat = asn1PD_H245UnicastAddress_iPXAddress (pctxt, pvalue->u.iPXAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "iPXAddress", -1); + + break; + + /* iP6Address */ + case 2: + invokeStartElement (pctxt, "iP6Address", -1); + + pvalue->u.iP6Address = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_iP6Address); + + stat = asn1PD_H245UnicastAddress_iP6Address (pctxt, pvalue->u.iP6Address); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "iP6Address", -1); + + break; + + /* netBios */ + case 3: + invokeStartElement (pctxt, "netBios", -1); + + pvalue->u.netBios = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_netBios); + + stat = asn1PD_H245UnicastAddress_netBios (pctxt, pvalue->u.netBios); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "netBios", -1); + + break; + + /* iPSourceRouteAddress */ + case 4: + invokeStartElement (pctxt, "iPSourceRouteAddress", -1); + + pvalue->u.iPSourceRouteAddress = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_iPSourceRouteAddress); + + stat = asn1PD_H245UnicastAddress_iPSourceRouteAddress (pctxt, pvalue->u.iPSourceRouteAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "iPSourceRouteAddress", -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; + + copyContext (&lctxt, pctxt); + initContextBuffer (pctxt, openType.data, openType.numocts); + + switch (pvalue->t) { + /* nsap */ + case 6: + invokeStartElement (pctxt, "nsap", -1); + + pvalue->u.nsap = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress_nsap); + + stat = asn1PD_H245UnicastAddress_nsap (pctxt, pvalue->u.nsap); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nsap", -1); + + break; + + /* nonStandardAddress */ + case 7: + invokeStartElement (pctxt, "nonStandardAddress", -1); + + pvalue->u.nonStandardAddress = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandardAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandardAddress", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_iPAddress_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MulticastAddress_iPAddress_network (OOCTXT* pctxt, H245MulticastAddress_iPAddress_network* 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); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_iPAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MulticastAddress_iPAddress (OOCTXT* pctxt, H245MulticastAddress_iPAddress* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode network */ + + invokeStartElement (pctxt, "network", -1); + + stat = asn1PD_H245MulticastAddress_iPAddress_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "network", -1); + + /* decode tsapIdentifier */ + + invokeStartElement (pctxt, "tsapIdentifier", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->tsapIdentifier); + + invokeEndElement (pctxt, "tsapIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_iP6Address_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MulticastAddress_iP6Address_network (OOCTXT* pctxt, H245MulticastAddress_iP6Address_network* 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); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_iP6Address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MulticastAddress_iP6Address (OOCTXT* pctxt, H245MulticastAddress_iP6Address* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode network */ + + invokeStartElement (pctxt, "network", -1); + + stat = asn1PD_H245MulticastAddress_iP6Address_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "network", -1); + + /* decode tsapIdentifier */ + + invokeStartElement (pctxt, "tsapIdentifier", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->tsapIdentifier); + + invokeEndElement (pctxt, "tsapIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_nsap */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MulticastAddress_nsap (OOCTXT* pctxt, H245MulticastAddress_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); +} + +/**************************************************************/ +/* */ +/* MulticastAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MulticastAddress (OOCTXT* pctxt, H245MulticastAddress* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* iPAddress */ + case 0: + invokeStartElement (pctxt, "iPAddress", -1); + + pvalue->u.iPAddress = ALLOC_ASN1ELEM (pctxt, H245MulticastAddress_iPAddress); + + stat = asn1PD_H245MulticastAddress_iPAddress (pctxt, pvalue->u.iPAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "iPAddress", -1); + + break; + + /* iP6Address */ + case 1: + invokeStartElement (pctxt, "iP6Address", -1); + + pvalue->u.iP6Address = ALLOC_ASN1ELEM (pctxt, H245MulticastAddress_iP6Address); + + stat = asn1PD_H245MulticastAddress_iP6Address (pctxt, pvalue->u.iP6Address); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "iP6Address", -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) { + /* nsap */ + case 3: + invokeStartElement (pctxt, "nsap", -1); + + pvalue->u.nsap = ALLOC_ASN1ELEM (pctxt, H245MulticastAddress_nsap); + + stat = asn1PD_H245MulticastAddress_nsap (pctxt, pvalue->u.nsap); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nsap", -1); + + break; + + /* nonStandardAddress */ + case 4: + invokeStartElement (pctxt, "nonStandardAddress", -1); + + pvalue->u.nonStandardAddress = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandardAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandardAddress", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TransportAddress (OOCTXT* pctxt, H245TransportAddress* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* unicastAddress */ + case 0: + invokeStartElement (pctxt, "unicastAddress", -1); + + pvalue->u.unicastAddress = ALLOC_ASN1ELEM (pctxt, H245UnicastAddress); + + stat = asn1PD_H245UnicastAddress (pctxt, pvalue->u.unicastAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "unicastAddress", -1); + + break; + + /* multicastAddress */ + case 1: + invokeStartElement (pctxt, "multicastAddress", -1); + + pvalue->u.multicastAddress = ALLOC_ASN1ELEM (pctxt, H245MulticastAddress); + + stat = asn1PD_H245MulticastAddress (pctxt, pvalue->u.multicastAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multicastAddress", -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); +} + +/**************************************************************/ +/* */ +/* McuNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245McuNumber (OOCTXT* pctxt, H245McuNumber* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUInt8 (pctxt, pvalue, 0U, 192U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalNumber (OOCTXT* pctxt, H245TerminalNumber* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUInt8 (pctxt, pvalue, 0U, 192U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalLabel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalLabel (OOCTXT* pctxt, H245TerminalLabel* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode mcuNumber */ + + invokeStartElement (pctxt, "mcuNumber", -1); + + stat = asn1PD_H245McuNumber (pctxt, &pvalue->mcuNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mcuNumber", -1); + + /* decode terminalNumber */ + + invokeStartElement (pctxt, "terminalNumber", -1); + + stat = asn1PD_H245TerminalNumber (pctxt, &pvalue->terminalNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalNumber", -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); +} + +/**************************************************************/ +/* */ +/* H2250LogicalChannelParameters_mediaPacketization */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H2250LogicalChannelParameters_mediaPacketization (OOCTXT* pctxt, H245H2250LogicalChannelParameters_mediaPacketization* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* h261aVideoPacketization */ + case 0: + invokeStartElement (pctxt, "h261aVideoPacketization", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "h261aVideoPacketization", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + 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) { + /* rtpPayloadType */ + case 2: + invokeStartElement (pctxt, "rtpPayloadType", -1); + + pvalue->u.rtpPayloadType = ALLOC_ASN1ELEM (pctxt, H245RTPPayloadType); + + stat = asn1PD_H245RTPPayloadType (pctxt, pvalue->u.rtpPayloadType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rtpPayloadType", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250LogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H2250LogicalChannelParameters (OOCTXT* pctxt, H245H2250LogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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.associatedSessionIDPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaChannelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaGuaranteedDeliveryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaControlChannelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaControlGuaranteedDeliveryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.silenceSuppressionPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.destinationPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.dynamicRTPPayloadTypePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaPacketizationPresent = optbit; + + /* decode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + invokeStartElement (pctxt, "nonStandard", -1); + + stat = asn1PD_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + } + + /* 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 associatedSessionID */ + + if (pvalue->m.associatedSessionIDPresent) { + invokeStartElement (pctxt, "associatedSessionID", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->associatedSessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->associatedSessionID); + + invokeEndElement (pctxt, "associatedSessionID", -1); + } + + /* decode mediaChannel */ + + if (pvalue->m.mediaChannelPresent) { + invokeStartElement (pctxt, "mediaChannel", -1); + + stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaChannel", -1); + } + + /* decode mediaGuaranteedDelivery */ + + if (pvalue->m.mediaGuaranteedDeliveryPresent) { + invokeStartElement (pctxt, "mediaGuaranteedDelivery", -1); + + stat = DECODEBIT (pctxt, &pvalue->mediaGuaranteedDelivery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->mediaGuaranteedDelivery); + + invokeEndElement (pctxt, "mediaGuaranteedDelivery", -1); + } + + /* decode mediaControlChannel */ + + if (pvalue->m.mediaControlChannelPresent) { + invokeStartElement (pctxt, "mediaControlChannel", -1); + + stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaControlChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaControlChannel", -1); + } + + /* decode mediaControlGuaranteedDelivery */ + + if (pvalue->m.mediaControlGuaranteedDeliveryPresent) { + invokeStartElement (pctxt, "mediaControlGuaranteedDelivery", -1); + + stat = DECODEBIT (pctxt, &pvalue->mediaControlGuaranteedDelivery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->mediaControlGuaranteedDelivery); + + invokeEndElement (pctxt, "mediaControlGuaranteedDelivery", -1); + } + + /* decode silenceSuppression */ + + if (pvalue->m.silenceSuppressionPresent) { + invokeStartElement (pctxt, "silenceSuppression", -1); + + stat = DECODEBIT (pctxt, &pvalue->silenceSuppression); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->silenceSuppression); + + invokeEndElement (pctxt, "silenceSuppression", -1); + } + + /* decode destination */ + + if (pvalue->m.destinationPresent) { + invokeStartElement (pctxt, "destination", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->destination); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "destination", -1); + } + + /* decode dynamicRTPPayloadType */ + + if (pvalue->m.dynamicRTPPayloadTypePresent) { + invokeStartElement (pctxt, "dynamicRTPPayloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->dynamicRTPPayloadType, 96U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->dynamicRTPPayloadType); + + invokeEndElement (pctxt, "dynamicRTPPayloadType", -1); + } + + /* decode mediaPacketization */ + + if (pvalue->m.mediaPacketizationPresent) { + invokeStartElement (pctxt, "mediaPacketization", -1); + + stat = asn1PD_H245H2250LogicalChannelParameters_mediaPacketization (pctxt, &pvalue->mediaPacketization); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaPacketization", -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.transportCapabilityPresent = 1; + + invokeStartElement (pctxt, "transportCapability", -1); + + stat = asn1PD_H245TransportCapability (pctxt, &pvalue->transportCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transportCapability", -1); + break; + + case 1: + pvalue->m.redundancyEncodingPresent = 1; + + invokeStartElement (pctxt, "redundancyEncoding", -1); + + stat = asn1PD_H245RedundancyEncoding (pctxt, &pvalue->redundancyEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncoding", -1); + break; + + case 2: + pvalue->m.sourcePresent = 1; + + invokeStartElement (pctxt, "source", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->source); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "source", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_forwardLogicalChannelParameters_multi */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* h222LogicalChannelParameters */ + case 0: + invokeStartElement (pctxt, "h222LogicalChannelParameters", -1); + + pvalue->u.h222LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H222LogicalChannelParameters); + + stat = asn1PD_H245H222LogicalChannelParameters (pctxt, pvalue->u.h222LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h222LogicalChannelParameters", -1); + + break; + + /* h223LogicalChannelParameters */ + case 1: + invokeStartElement (pctxt, "h223LogicalChannelParameters", -1); + + pvalue->u.h223LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H223LogicalChannelParameters); + + stat = asn1PD_H245H223LogicalChannelParameters (pctxt, pvalue->u.h223LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223LogicalChannelParameters", -1); + + break; + + /* v76LogicalChannelParameters */ + case 2: + invokeStartElement (pctxt, "v76LogicalChannelParameters", -1); + + pvalue->u.v76LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245V76LogicalChannelParameters); + + stat = asn1PD_H245V76LogicalChannelParameters (pctxt, pvalue->u.v76LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "v76LogicalChannelParameters", -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) { + /* h2250LogicalChannelParameters */ + case 4: + invokeStartElement (pctxt, "h2250LogicalChannelParameters", -1); + + pvalue->u.h2250LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H2250LogicalChannelParameters); + + stat = asn1PD_H245H2250LogicalChannelParameters (pctxt, pvalue->u.h2250LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h2250LogicalChannelParameters", -1); + + break; + + /* none */ + case 5: + invokeStartElement (pctxt, "none", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "none", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_forwardLogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.portNumberPresent = optbit; + + /* decode portNumber */ + + if (pvalue->m.portNumberPresent) { + invokeStartElement (pctxt, "portNumber", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->portNumber, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->portNumber); + + invokeEndElement (pctxt, "portNumber", -1); + } + + /* decode dataType */ + + invokeStartElement (pctxt, "dataType", -1); + + stat = asn1PD_H245DataType (pctxt, &pvalue->dataType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dataType", -1); + + /* decode multiplexParameters */ + + invokeStartElement (pctxt, "multiplexParameters", -1); + + stat = asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexParameters", -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.forwardLogicalChannelDependencyPresent = 1; + + invokeStartElement (pctxt, "forwardLogicalChannelDependency", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelDependency); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelDependency", -1); + break; + + case 1: + pvalue->m.replacementForPresent = 1; + + invokeStartElement (pctxt, "replacementFor", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->replacementFor); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "replacementFor", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_reverseLogicalChannelParameters_multi */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* h223LogicalChannelParameters */ + case 0: + invokeStartElement (pctxt, "h223LogicalChannelParameters", -1); + + pvalue->u.h223LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H223LogicalChannelParameters); + + stat = asn1PD_H245H223LogicalChannelParameters (pctxt, pvalue->u.h223LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223LogicalChannelParameters", -1); + + break; + + /* v76LogicalChannelParameters */ + case 1: + invokeStartElement (pctxt, "v76LogicalChannelParameters", -1); + + pvalue->u.v76LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245V76LogicalChannelParameters); + + stat = asn1PD_H245V76LogicalChannelParameters (pctxt, pvalue->u.v76LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "v76LogicalChannelParameters", -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) { + /* h2250LogicalChannelParameters */ + case 3: + invokeStartElement (pctxt, "h2250LogicalChannelParameters", -1); + + pvalue->u.h2250LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H2250LogicalChannelParameters); + + stat = asn1PD_H245H2250LogicalChannelParameters (pctxt, pvalue->u.h2250LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h2250LogicalChannelParameters", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_reverseLogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.multiplexParametersPresent = optbit; + + /* decode dataType */ + + invokeStartElement (pctxt, "dataType", -1); + + stat = asn1PD_H245DataType (pctxt, &pvalue->dataType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dataType", -1); + + /* decode multiplexParameters */ + + if (pvalue->m.multiplexParametersPresent) { + invokeStartElement (pctxt, "multiplexParameters", -1); + + stat = asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexParameters", -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.reverseLogicalChannelDependencyPresent = 1; + + invokeStartElement (pctxt, "reverseLogicalChannelDependency", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->reverseLogicalChannelDependency); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reverseLogicalChannelDependency", -1); + break; + + case 1: + pvalue->m.replacementForPresent = 1; + + invokeStartElement (pctxt, "replacementFor", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->replacementFor); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "replacementFor", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_distribution */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NetworkAccessParameters_distribution (OOCTXT* pctxt, H245NetworkAccessParameters_distribution* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* unicast */ + case 0: + invokeStartElement (pctxt, "unicast", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unicast", -1); + + break; + + /* multicast */ + case 1: + invokeStartElement (pctxt, "multicast", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "multicast", -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); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_networkAddress */ +/* */ +/**************************************************************/ + +extern EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet; + +EXTERN int asn1PD_H245NetworkAccessParameters_networkAddress (OOCTXT* pctxt, H245NetworkAccessParameters_networkAddress* pvalue) +{ + static Asn1SizeCnst e164Address_lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* q2931Address */ + case 0: + invokeStartElement (pctxt, "q2931Address", -1); + + pvalue->u.q2931Address = ALLOC_ASN1ELEM (pctxt, H245Q2931Address); + + stat = asn1PD_H245Q2931Address (pctxt, pvalue->u.q2931Address); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "q2931Address", -1); + + break; + + /* e164Address */ + case 1: + invokeStartElement (pctxt, "e164Address", -1); + + addSizeConstraint (pctxt, &e164Address_lsize1); + + stat = decodeConstrainedStringEx (pctxt, &pvalue->u.e164Address, gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->u.e164Address); + + invokeEndElement (pctxt, "e164Address", -1); + + break; + + /* localAreaAddress */ + case 2: + invokeStartElement (pctxt, "localAreaAddress", -1); + + pvalue->u.localAreaAddress = ALLOC_ASN1ELEM (pctxt, H245TransportAddress); + + stat = asn1PD_H245TransportAddress (pctxt, pvalue->u.localAreaAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "localAreaAddress", -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); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_externalReference */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NetworkAccessParameters_externalReference (OOCTXT* pctxt, H245NetworkAccessParameters_externalReference* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 255, 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); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_t120SetupProcedure */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NetworkAccessParameters_t120SetupProcedure (OOCTXT* pctxt, H245NetworkAccessParameters_t120SetupProcedure* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* originateCall */ + case 0: + invokeStartElement (pctxt, "originateCall", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "originateCall", -1); + + break; + + /* waitForCall */ + case 1: + invokeStartElement (pctxt, "waitForCall", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "waitForCall", -1); + + break; + + /* issueQuery */ + case 2: + invokeStartElement (pctxt, "issueQuery", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "issueQuery", -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); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NetworkAccessParameters (OOCTXT* pctxt, H245NetworkAccessParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.distributionPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.externalReferencePresent = optbit; + + /* decode distribution */ + + if (pvalue->m.distributionPresent) { + invokeStartElement (pctxt, "distribution", -1); + + stat = asn1PD_H245NetworkAccessParameters_distribution (pctxt, &pvalue->distribution); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "distribution", -1); + } + + /* decode networkAddress */ + + invokeStartElement (pctxt, "networkAddress", -1); + + stat = asn1PD_H245NetworkAccessParameters_networkAddress (pctxt, &pvalue->networkAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "networkAddress", -1); + + /* decode associateConference */ + + invokeStartElement (pctxt, "associateConference", -1); + + stat = DECODEBIT (pctxt, &pvalue->associateConference); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->associateConference); + + invokeEndElement (pctxt, "associateConference", -1); + + /* decode externalReference */ + + if (pvalue->m.externalReferencePresent) { + invokeStartElement (pctxt, "externalReference", -1); + + stat = asn1PD_H245NetworkAccessParameters_externalReference (pctxt, &pvalue->externalReference); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "externalReference", -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.t120SetupProcedurePresent = 1; + + invokeStartElement (pctxt, "t120SetupProcedure", -1); + + stat = asn1PD_H245NetworkAccessParameters_t120SetupProcedure (pctxt, &pvalue->t120SetupProcedure); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t120SetupProcedure", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EscrowData_escrowValue */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EscrowData_escrowValue (OOCTXT* pctxt, H245EscrowData_escrowValue* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 65535, 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); +} + +/**************************************************************/ +/* */ +/* EscrowData */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EscrowData (OOCTXT* pctxt, H245EscrowData* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode escrowID */ + + invokeStartElement (pctxt, "escrowID", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->escrowID); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->escrowID.numids, pvalue->escrowID.subid); + + invokeEndElement (pctxt, "escrowID", -1); + + /* decode escrowValue */ + + invokeStartElement (pctxt, "escrowValue", -1); + + stat = asn1PD_H245EscrowData_escrowValue (pctxt, &pvalue->escrowValue); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "escrowValue", -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); +} + +/**************************************************************/ +/* */ +/* EncryptionSync_escrowentry */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EncryptionSync_escrowentry (OOCTXT* pctxt, H245EncryptionSync_escrowentry* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245EscrowData* 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, H245EscrowData); + + stat = asn1PD_H245EscrowData (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionSync */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EncryptionSync (OOCTXT* pctxt, H245EncryptionSync* pvalue) +{ + static Asn1SizeCnst h235Key_lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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.escrowentryPresent = optbit; + + /* decode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + invokeStartElement (pctxt, "nonStandard", -1); + + stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + } + + /* decode synchFlag */ + + invokeStartElement (pctxt, "synchFlag", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->synchFlag, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->synchFlag); + + invokeEndElement (pctxt, "synchFlag", -1); + + /* decode h235Key */ + + invokeStartElement (pctxt, "h235Key", -1); + + addSizeConstraint (pctxt, &h235Key_lsize1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->h235Key); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->h235Key.numocts, pvalue->h235Key.data); + + invokeEndElement (pctxt, "h235Key", -1); + + /* decode escrowentry */ + + if (pvalue->m.escrowentryPresent) { + invokeStartElement (pctxt, "escrowentry", -1); + + stat = asn1PD_H245EncryptionSync_escrowentry (pctxt, &pvalue->escrowentry); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "escrowentry", -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); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannel (OOCTXT* pctxt, H245OpenLogicalChannel* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.reverseLogicalChannelParametersPresent = optbit; + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1); + + /* decode forwardLogicalChannelParameters */ + + invokeStartElement (pctxt, "forwardLogicalChannelParameters", -1); + + stat = asn1PD_H245OpenLogicalChannel_forwardLogicalChannelParameters (pctxt, &pvalue->forwardLogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelParameters", -1); + + /* decode reverseLogicalChannelParameters */ + + if (pvalue->m.reverseLogicalChannelParametersPresent) { + invokeStartElement (pctxt, "reverseLogicalChannelParameters", -1); + + stat = asn1PD_H245OpenLogicalChannel_reverseLogicalChannelParameters (pctxt, &pvalue->reverseLogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reverseLogicalChannelParameters", -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.separateStackPresent = 1; + + invokeStartElement (pctxt, "separateStack", -1); + + stat = asn1PD_H245NetworkAccessParameters (pctxt, &pvalue->separateStack); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "separateStack", -1); + break; + + case 1: + pvalue->m.encryptionSyncPresent = 1; + + invokeStartElement (pctxt, "encryptionSync", -1); + + stat = asn1PD_H245EncryptionSync (pctxt, &pvalue->encryptionSync); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionSync", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CloseLogicalChannel_source */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CloseLogicalChannel_source (OOCTXT* pctxt, H245CloseLogicalChannel_source* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* user */ + case 0: + invokeStartElement (pctxt, "user", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "user", -1); + + break; + + /* lcse */ + case 1: + invokeStartElement (pctxt, "lcse", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "lcse", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CloseLogicalChannel_reason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CloseLogicalChannel_reason (OOCTXT* pctxt, H245CloseLogicalChannel_reason* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* unknown */ + case 0: + invokeStartElement (pctxt, "unknown", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unknown", -1); + + break; + + /* reopen */ + case 1: + invokeStartElement (pctxt, "reopen", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "reopen", -1); + + break; + + /* reservationFailure */ + case 2: + invokeStartElement (pctxt, "reservationFailure", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "reservationFailure", -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); +} + +/**************************************************************/ +/* */ +/* CloseLogicalChannel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CloseLogicalChannel (OOCTXT* pctxt, H245CloseLogicalChannel* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1); + + /* decode source */ + + invokeStartElement (pctxt, "source", -1); + + stat = asn1PD_H245CloseLogicalChannel_source (pctxt, &pvalue->source); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "source", -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.reasonPresent = 1; + + invokeStartElement (pctxt, "reason", -1); + + stat = asn1PD_H245CloseLogicalChannel_reason (pctxt, &pvalue->reason); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reason", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestChannelClose_reason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestChannelClose_reason (OOCTXT* pctxt, H245RequestChannelClose_reason* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* unknown */ + case 0: + invokeStartElement (pctxt, "unknown", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unknown", -1); + + break; + + /* normal */ + case 1: + invokeStartElement (pctxt, "normal", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "normal", -1); + + break; + + /* reopen */ + case 2: + invokeStartElement (pctxt, "reopen", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "reopen", -1); + + break; + + /* reservationFailure */ + case 3: + invokeStartElement (pctxt, "reservationFailure", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "reservationFailure", -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); +} + +/**************************************************************/ +/* */ +/* RequestChannelClose */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestChannelClose (OOCTXT* pctxt, H245RequestChannelClose* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -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.qosCapabilityPresent = 1; + + invokeStartElement (pctxt, "qosCapability", -1); + + stat = asn1PD_H245QOSCapability (pctxt, &pvalue->qosCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "qosCapability", -1); + break; + + case 1: + pvalue->m.reasonPresent = 1; + + invokeStartElement (pctxt, "reason", -1); + + stat = asn1PD_H245RequestChannelClose_reason (pctxt, &pvalue->reason); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reason", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexTableEntryNumber* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUInt8 (pctxt, pvalue, 1U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexElement_type_subElementList */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexElement_type_subElementList (OOCTXT* pctxt, H245MultiplexElement_type_subElementList* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 2, 255, 0 }; + int stat = ASN_OK; + H245MultiplexElement* 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, H245MultiplexElement); + + stat = asn1PD_H245MultiplexElement (pctxt, (H245MultiplexElement*)pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexElement_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexElement_type (OOCTXT* pctxt, H245MultiplexElement_type* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* logicalChannelNumber */ + case 0: + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.logicalChannelNumber, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.logicalChannelNumber); + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + break; + + /* subElementList */ + case 1: + invokeStartElement (pctxt, "subElementList", -1); + + pvalue->u.subElementList = ALLOC_ASN1ELEM (pctxt, H245MultiplexElement_type_subElementList); + + stat = asn1PD_H245MultiplexElement_type_subElementList (pctxt, pvalue->u.subElementList); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "subElementList", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexElement_repeatCount */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexElement_repeatCount (OOCTXT* pctxt, H245MultiplexElement_repeatCount* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* finite */ + case 0: + invokeStartElement (pctxt, "finite", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.finite, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.finite); + + invokeEndElement (pctxt, "finite", -1); + + break; + + /* untilClosingFlag */ + case 1: + invokeStartElement (pctxt, "untilClosingFlag", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "untilClosingFlag", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexElement (OOCTXT* pctxt, H245MultiplexElement* pvalue) +{ + int stat = ASN_OK; + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245MultiplexElement_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -1); + + /* decode repeatCount */ + + invokeStartElement (pctxt, "repeatCount", -1); + + stat = asn1PD_H245MultiplexElement_repeatCount (pctxt, &pvalue->repeatCount); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "repeatCount", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntryDescriptor_elementList */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntryDescriptor_elementList (OOCTXT* pctxt, H245MultiplexEntryDescriptor_elementList* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245MultiplexElement* 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, H245MultiplexElement); + + stat = asn1PD_H245MultiplexElement (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntryDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntryDescriptor (OOCTXT* pctxt, H245MultiplexEntryDescriptor* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL optbit; + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.elementListPresent = optbit; + + /* decode multiplexTableEntryNumber */ + + invokeStartElement (pctxt, "multiplexTableEntryNumber", -1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexTableEntryNumber", -1); + + /* decode elementList */ + + if (pvalue->m.elementListPresent) { + invokeStartElement (pctxt, "elementList", -1); + + stat = asn1PD_H245MultiplexEntryDescriptor_elementList (pctxt, &pvalue->elementList); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "elementList", -1); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySend_multiplexEntryDescriptors */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntrySend_multiplexEntryDescriptors (OOCTXT* pctxt, H245MultiplexEntrySend_multiplexEntryDescriptors* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + H245MultiplexEntryDescriptor* 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, H245MultiplexEntryDescriptor); + + stat = asn1PD_H245MultiplexEntryDescriptor (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySend */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntrySend (OOCTXT* pctxt, H245MultiplexEntrySend* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode multiplexEntryDescriptors */ + + invokeStartElement (pctxt, "multiplexEntryDescriptors", -1); + + stat = asn1PD_H245MultiplexEntrySend_multiplexEntryDescriptors (pctxt, &pvalue->multiplexEntryDescriptors); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexEntryDescriptors", -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); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntry_entryNumbers */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntry_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntry_entryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntry */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntry (OOCTXT* pctxt, H245RequestMultiplexEntry* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode entryNumbers */ + + invokeStartElement (pctxt, "entryNumbers", -1); + + stat = asn1PD_H245RequestMultiplexEntry_entryNumbers (pctxt, &pvalue->entryNumbers); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "entryNumbers", -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); +} + +/**************************************************************/ +/* */ +/* H261VideoMode_resolution */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H261VideoMode_resolution (OOCTXT* pctxt, H245H261VideoMode_resolution* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* qcif */ + case 0: + invokeStartElement (pctxt, "qcif", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "qcif", -1); + + break; + + /* cif */ + case 1: + invokeStartElement (pctxt, "cif", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cif", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H261VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H261VideoMode (OOCTXT* pctxt, H245H261VideoMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode resolution */ + + invokeStartElement (pctxt, "resolution", -1); + + stat = asn1PD_H245H261VideoMode_resolution (pctxt, &pvalue->resolution); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "resolution", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 19200U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -1); + + /* decode stillImageTransmission */ + + invokeStartElement (pctxt, "stillImageTransmission", -1); + + stat = DECODEBIT (pctxt, &pvalue->stillImageTransmission); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->stillImageTransmission); + + invokeEndElement (pctxt, "stillImageTransmission", -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); +} + +/**************************************************************/ +/* */ +/* H262VideoMode_profileAndLevel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H262VideoMode_profileAndLevel (OOCTXT* pctxt, H245H262VideoMode_profileAndLevel* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 10); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* profileAndLevel_SPatML */ + case 0: + invokeStartElement (pctxt, "profileAndLevel_SPatML", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_SPatML", -1); + + break; + + /* profileAndLevel_MPatLL */ + case 1: + invokeStartElement (pctxt, "profileAndLevel_MPatLL", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_MPatLL", -1); + + break; + + /* profileAndLevel_MPatML */ + case 2: + invokeStartElement (pctxt, "profileAndLevel_MPatML", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_MPatML", -1); + + break; + + /* profileAndLevel_MPatH_14 */ + case 3: + invokeStartElement (pctxt, "profileAndLevel_MPatH_14", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_MPatH_14", -1); + + break; + + /* profileAndLevel_MPatHL */ + case 4: + invokeStartElement (pctxt, "profileAndLevel_MPatHL", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_MPatHL", -1); + + break; + + /* profileAndLevel_SNRatLL */ + case 5: + invokeStartElement (pctxt, "profileAndLevel_SNRatLL", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_SNRatLL", -1); + + break; + + /* profileAndLevel_SNRatML */ + case 6: + invokeStartElement (pctxt, "profileAndLevel_SNRatML", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_SNRatML", -1); + + break; + + /* profileAndLevel_SpatialatH_14 */ + case 7: + invokeStartElement (pctxt, "profileAndLevel_SpatialatH_14", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_SpatialatH_14", -1); + + break; + + /* profileAndLevel_HPatML */ + case 8: + invokeStartElement (pctxt, "profileAndLevel_HPatML", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_HPatML", -1); + + break; + + /* profileAndLevel_HPatH_14 */ + case 9: + invokeStartElement (pctxt, "profileAndLevel_HPatH_14", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_HPatH_14", -1); + + break; + + /* profileAndLevel_HPatHL */ + case 10: + invokeStartElement (pctxt, "profileAndLevel_HPatHL", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "profileAndLevel_HPatHL", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 12; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H262VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H262VideoMode (OOCTXT* pctxt, H245H262VideoMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.videoBitRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.vbvBufferSizePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.samplesPerLinePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.linesPerFramePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.framesPerSecondPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.luminanceSampleRatePresent = optbit; + + /* decode profileAndLevel */ + + invokeStartElement (pctxt, "profileAndLevel", -1); + + stat = asn1PD_H245H262VideoMode_profileAndLevel (pctxt, &pvalue->profileAndLevel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "profileAndLevel", -1); + + /* decode videoBitRate */ + + if (pvalue->m.videoBitRatePresent) { + invokeStartElement (pctxt, "videoBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->videoBitRate, 0U, 1073741823U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->videoBitRate); + + invokeEndElement (pctxt, "videoBitRate", -1); + } + + /* decode vbvBufferSize */ + + if (pvalue->m.vbvBufferSizePresent) { + invokeStartElement (pctxt, "vbvBufferSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->vbvBufferSize, 0U, 262143U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->vbvBufferSize); + + invokeEndElement (pctxt, "vbvBufferSize", -1); + } + + /* decode samplesPerLine */ + + if (pvalue->m.samplesPerLinePresent) { + invokeStartElement (pctxt, "samplesPerLine", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->samplesPerLine, 0U, 16383U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->samplesPerLine); + + invokeEndElement (pctxt, "samplesPerLine", -1); + } + + /* decode linesPerFrame */ + + if (pvalue->m.linesPerFramePresent) { + invokeStartElement (pctxt, "linesPerFrame", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->linesPerFrame, 0U, 16383U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->linesPerFrame); + + invokeEndElement (pctxt, "linesPerFrame", -1); + } + + /* decode framesPerSecond */ + + if (pvalue->m.framesPerSecondPresent) { + invokeStartElement (pctxt, "framesPerSecond", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->framesPerSecond, 0U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->framesPerSecond); + + invokeEndElement (pctxt, "framesPerSecond", -1); + } + + /* decode luminanceSampleRate */ + + if (pvalue->m.luminanceSampleRatePresent) { + invokeStartElement (pctxt, "luminanceSampleRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->luminanceSampleRate); + + invokeEndElement (pctxt, "luminanceSampleRate", -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); +} + +/**************************************************************/ +/* */ +/* H263VideoMode_resolution */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263VideoMode_resolution (OOCTXT* pctxt, H245H263VideoMode_resolution* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* 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) { + /* sqcif */ + case 0: + invokeStartElement (pctxt, "sqcif", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "sqcif", -1); + + break; + + /* qcif */ + case 1: + invokeStartElement (pctxt, "qcif", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "qcif", -1); + + break; + + /* cif */ + case 2: + invokeStartElement (pctxt, "cif", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cif", -1); + + break; + + /* cif4 */ + case 3: + invokeStartElement (pctxt, "cif4", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cif4", -1); + + break; + + /* cif16 */ + case 4: + invokeStartElement (pctxt, "cif16", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cif16", -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; + + copyContext (&lctxt, pctxt); + initContextBuffer (pctxt, openType.data, openType.numocts); + + switch (pvalue->t) { + /* custom */ + case 6: + invokeStartElement (pctxt, "custom", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "custom", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H263VideoMode (OOCTXT* pctxt, H245H263VideoMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode resolution */ + + invokeStartElement (pctxt, "resolution", -1); + + stat = asn1PD_H245H263VideoMode_resolution (pctxt, &pvalue->resolution); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "resolution", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 19200U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -1); + + /* decode unrestrictedVector */ + + invokeStartElement (pctxt, "unrestrictedVector", -1); + + stat = DECODEBIT (pctxt, &pvalue->unrestrictedVector); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->unrestrictedVector); + + invokeEndElement (pctxt, "unrestrictedVector", -1); + + /* decode arithmeticCoding */ + + invokeStartElement (pctxt, "arithmeticCoding", -1); + + stat = DECODEBIT (pctxt, &pvalue->arithmeticCoding); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->arithmeticCoding); + + invokeEndElement (pctxt, "arithmeticCoding", -1); + + /* decode advancedPrediction */ + + invokeStartElement (pctxt, "advancedPrediction", -1); + + stat = DECODEBIT (pctxt, &pvalue->advancedPrediction); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->advancedPrediction); + + invokeEndElement (pctxt, "advancedPrediction", -1); + + /* decode pbFrames */ + + invokeStartElement (pctxt, "pbFrames", -1); + + stat = DECODEBIT (pctxt, &pvalue->pbFrames); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->pbFrames); + + invokeEndElement (pctxt, "pbFrames", -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.errorCompensationPresent = 1; + + invokeStartElement (pctxt, "errorCompensation", -1); + + stat = DECODEBIT (pctxt, &pvalue->errorCompensation); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->errorCompensation); + + invokeEndElement (pctxt, "errorCompensation", -1); + break; + + case 1: + pvalue->m.enhancementLayerInfoPresent = 1; + + invokeStartElement (pctxt, "enhancementLayerInfo", -1); + + stat = asn1PD_H245EnhancementLayerInfo (pctxt, &pvalue->enhancementLayerInfo); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "enhancementLayerInfo", -1); + break; + + case 2: + pvalue->m.h263OptionsPresent = 1; + + invokeStartElement (pctxt, "h263Options", -1); + + stat = asn1PD_H245H263Options (pctxt, &pvalue->h263Options); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263Options", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS11172VideoMode (OOCTXT* pctxt, H245IS11172VideoMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.videoBitRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.vbvBufferSizePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.samplesPerLinePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.linesPerFramePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.pictureRatePresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.luminanceSampleRatePresent = optbit; + + /* decode constrainedBitstream */ + + invokeStartElement (pctxt, "constrainedBitstream", -1); + + stat = DECODEBIT (pctxt, &pvalue->constrainedBitstream); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->constrainedBitstream); + + invokeEndElement (pctxt, "constrainedBitstream", -1); + + /* decode videoBitRate */ + + if (pvalue->m.videoBitRatePresent) { + invokeStartElement (pctxt, "videoBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->videoBitRate, 0U, 1073741823U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->videoBitRate); + + invokeEndElement (pctxt, "videoBitRate", -1); + } + + /* decode vbvBufferSize */ + + if (pvalue->m.vbvBufferSizePresent) { + invokeStartElement (pctxt, "vbvBufferSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->vbvBufferSize, 0U, 262143U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->vbvBufferSize); + + invokeEndElement (pctxt, "vbvBufferSize", -1); + } + + /* decode samplesPerLine */ + + if (pvalue->m.samplesPerLinePresent) { + invokeStartElement (pctxt, "samplesPerLine", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->samplesPerLine, 0U, 16383U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->samplesPerLine); + + invokeEndElement (pctxt, "samplesPerLine", -1); + } + + /* decode linesPerFrame */ + + if (pvalue->m.linesPerFramePresent) { + invokeStartElement (pctxt, "linesPerFrame", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->linesPerFrame, 0U, 16383U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->linesPerFrame); + + invokeEndElement (pctxt, "linesPerFrame", -1); + } + + /* decode pictureRate */ + + if (pvalue->m.pictureRatePresent) { + invokeStartElement (pctxt, "pictureRate", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->pictureRate, 0U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->pictureRate); + + invokeEndElement (pctxt, "pictureRate", -1); + } + + /* decode luminanceSampleRate */ + + if (pvalue->m.luminanceSampleRatePresent) { + invokeStartElement (pctxt, "luminanceSampleRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->luminanceSampleRate); + + invokeEndElement (pctxt, "luminanceSampleRate", -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); +} + +/**************************************************************/ +/* */ +/* VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VideoMode (OOCTXT* pctxt, H245VideoMode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* h261VideoMode */ + case 1: + invokeStartElement (pctxt, "h261VideoMode", -1); + + pvalue->u.h261VideoMode = ALLOC_ASN1ELEM (pctxt, H245H261VideoMode); + + stat = asn1PD_H245H261VideoMode (pctxt, pvalue->u.h261VideoMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h261VideoMode", -1); + + break; + + /* h262VideoMode */ + case 2: + invokeStartElement (pctxt, "h262VideoMode", -1); + + pvalue->u.h262VideoMode = ALLOC_ASN1ELEM (pctxt, H245H262VideoMode); + + stat = asn1PD_H245H262VideoMode (pctxt, pvalue->u.h262VideoMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h262VideoMode", -1); + + break; + + /* h263VideoMode */ + case 3: + invokeStartElement (pctxt, "h263VideoMode", -1); + + pvalue->u.h263VideoMode = ALLOC_ASN1ELEM (pctxt, H245H263VideoMode); + + stat = asn1PD_H245H263VideoMode (pctxt, pvalue->u.h263VideoMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h263VideoMode", -1); + + break; + + /* is11172VideoMode */ + case 4: + invokeStartElement (pctxt, "is11172VideoMode", -1); + + pvalue->u.is11172VideoMode = ALLOC_ASN1ELEM (pctxt, H245IS11172VideoMode); + + stat = asn1PD_H245IS11172VideoMode (pctxt, pvalue->u.is11172VideoMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "is11172VideoMode", -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; + + copyContext (&lctxt, pctxt); + initContextBuffer (pctxt, openType.data, openType.numocts); + + switch (pvalue->t) { + /* genericVideoMode */ + case 6: + invokeStartElement (pctxt, "genericVideoMode", -1); + + pvalue->u.genericVideoMode = ALLOC_ASN1ELEM (pctxt, H245GenericCapability); + + stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericVideoMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericVideoMode", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AudioMode_g7231 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245AudioMode_g7231 (OOCTXT* pctxt, H245AudioMode_g7231* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 3); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* noSilenceSuppressionLowRate */ + case 0: + invokeStartElement (pctxt, "noSilenceSuppressionLowRate", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noSilenceSuppressionLowRate", -1); + + break; + + /* noSilenceSuppressionHighRate */ + case 1: + invokeStartElement (pctxt, "noSilenceSuppressionHighRate", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noSilenceSuppressionHighRate", -1); + + break; + + /* silenceSuppressionLowRate */ + case 2: + invokeStartElement (pctxt, "silenceSuppressionLowRate", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "silenceSuppressionLowRate", -1); + + break; + + /* silenceSuppressionHighRate */ + case 3: + invokeStartElement (pctxt, "silenceSuppressionHighRate", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "silenceSuppressionHighRate", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioMode_audioLayer */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS11172AudioMode_audioLayer (OOCTXT* pctxt, H245IS11172AudioMode_audioLayer* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 2); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* audioLayer1 */ + case 0: + invokeStartElement (pctxt, "audioLayer1", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioLayer1", -1); + + break; + + /* audioLayer2 */ + case 1: + invokeStartElement (pctxt, "audioLayer2", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioLayer2", -1); + + break; + + /* audioLayer3 */ + case 2: + invokeStartElement (pctxt, "audioLayer3", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioLayer3", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioMode_audioSampling */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS11172AudioMode_audioSampling (OOCTXT* pctxt, H245IS11172AudioMode_audioSampling* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 2); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* audioSampling32k */ + case 0: + invokeStartElement (pctxt, "audioSampling32k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling32k", -1); + + break; + + /* audioSampling44k1 */ + case 1: + invokeStartElement (pctxt, "audioSampling44k1", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling44k1", -1); + + break; + + /* audioSampling48k */ + case 2: + invokeStartElement (pctxt, "audioSampling48k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling48k", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioMode_multichannelType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS11172AudioMode_multichannelType (OOCTXT* pctxt, H245IS11172AudioMode_multichannelType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 2); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* singleChannel */ + case 0: + invokeStartElement (pctxt, "singleChannel", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "singleChannel", -1); + + break; + + /* twoChannelStereo */ + case 1: + invokeStartElement (pctxt, "twoChannelStereo", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "twoChannelStereo", -1); + + break; + + /* twoChannelDual */ + case 2: + invokeStartElement (pctxt, "twoChannelDual", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "twoChannelDual", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS11172AudioMode (OOCTXT* pctxt, H245IS11172AudioMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode audioLayer */ + + invokeStartElement (pctxt, "audioLayer", -1); + + stat = asn1PD_H245IS11172AudioMode_audioLayer (pctxt, &pvalue->audioLayer); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioLayer", -1); + + /* decode audioSampling */ + + invokeStartElement (pctxt, "audioSampling", -1); + + stat = asn1PD_H245IS11172AudioMode_audioSampling (pctxt, &pvalue->audioSampling); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioSampling", -1); + + /* decode multichannelType */ + + invokeStartElement (pctxt, "multichannelType", -1); + + stat = asn1PD_H245IS11172AudioMode_multichannelType (pctxt, &pvalue->multichannelType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multichannelType", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 448U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -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); +} + +/**************************************************************/ +/* */ +/* IS13818AudioMode_audioLayer */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS13818AudioMode_audioLayer (OOCTXT* pctxt, H245IS13818AudioMode_audioLayer* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 2); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* audioLayer1 */ + case 0: + invokeStartElement (pctxt, "audioLayer1", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioLayer1", -1); + + break; + + /* audioLayer2 */ + case 1: + invokeStartElement (pctxt, "audioLayer2", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioLayer2", -1); + + break; + + /* audioLayer3 */ + case 2: + invokeStartElement (pctxt, "audioLayer3", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioLayer3", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS13818AudioMode_audioSampling */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS13818AudioMode_audioSampling (OOCTXT* pctxt, H245IS13818AudioMode_audioSampling* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 5); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* audioSampling16k */ + case 0: + invokeStartElement (pctxt, "audioSampling16k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling16k", -1); + + break; + + /* audioSampling22k05 */ + case 1: + invokeStartElement (pctxt, "audioSampling22k05", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling22k05", -1); + + break; + + /* audioSampling24k */ + case 2: + invokeStartElement (pctxt, "audioSampling24k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling24k", -1); + + break; + + /* audioSampling32k */ + case 3: + invokeStartElement (pctxt, "audioSampling32k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling32k", -1); + + break; + + /* audioSampling44k1 */ + case 4: + invokeStartElement (pctxt, "audioSampling44k1", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling44k1", -1); + + break; + + /* audioSampling48k */ + case 5: + invokeStartElement (pctxt, "audioSampling48k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "audioSampling48k", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS13818AudioMode_multichannelType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS13818AudioMode_multichannelType (OOCTXT* pctxt, H245IS13818AudioMode_multichannelType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 9); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* singleChannel */ + case 0: + invokeStartElement (pctxt, "singleChannel", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "singleChannel", -1); + + break; + + /* twoChannelStereo */ + case 1: + invokeStartElement (pctxt, "twoChannelStereo", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "twoChannelStereo", -1); + + break; + + /* twoChannelDual */ + case 2: + invokeStartElement (pctxt, "twoChannelDual", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "twoChannelDual", -1); + + break; + + /* threeChannels2_1 */ + case 3: + invokeStartElement (pctxt, "threeChannels2_1", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "threeChannels2_1", -1); + + break; + + /* threeChannels3_0 */ + case 4: + invokeStartElement (pctxt, "threeChannels3_0", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "threeChannels3_0", -1); + + break; + + /* fourChannels2_0_2_0 */ + case 5: + invokeStartElement (pctxt, "fourChannels2_0_2_0", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "fourChannels2_0_2_0", -1); + + break; + + /* fourChannels2_2 */ + case 6: + invokeStartElement (pctxt, "fourChannels2_2", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "fourChannels2_2", -1); + + break; + + /* fourChannels3_1 */ + case 7: + invokeStartElement (pctxt, "fourChannels3_1", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "fourChannels3_1", -1); + + break; + + /* fiveChannels3_0_2_0 */ + case 8: + invokeStartElement (pctxt, "fiveChannels3_0_2_0", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "fiveChannels3_0_2_0", -1); + + break; + + /* fiveChannels3_2 */ + case 9: + invokeStartElement (pctxt, "fiveChannels3_2", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "fiveChannels3_2", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS13818AudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IS13818AudioMode (OOCTXT* pctxt, H245IS13818AudioMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode audioLayer */ + + invokeStartElement (pctxt, "audioLayer", -1); + + stat = asn1PD_H245IS13818AudioMode_audioLayer (pctxt, &pvalue->audioLayer); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioLayer", -1); + + /* decode audioSampling */ + + invokeStartElement (pctxt, "audioSampling", -1); + + stat = asn1PD_H245IS13818AudioMode_audioSampling (pctxt, &pvalue->audioSampling); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioSampling", -1); + + /* decode multichannelType */ + + invokeStartElement (pctxt, "multichannelType", -1); + + stat = asn1PD_H245IS13818AudioMode_multichannelType (pctxt, &pvalue->multichannelType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multichannelType", -1); + + /* decode lowFrequencyEnhancement */ + + invokeStartElement (pctxt, "lowFrequencyEnhancement", -1); + + stat = DECODEBIT (pctxt, &pvalue->lowFrequencyEnhancement); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->lowFrequencyEnhancement); + + invokeEndElement (pctxt, "lowFrequencyEnhancement", -1); + + /* decode multilingual */ + + invokeStartElement (pctxt, "multilingual", -1); + + stat = DECODEBIT (pctxt, &pvalue->multilingual); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->multilingual); + + invokeEndElement (pctxt, "multilingual", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 1130U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -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); +} + +/**************************************************************/ +/* */ +/* G7231AnnexCMode_g723AnnexCAudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245G7231AnnexCMode_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCMode_g723AnnexCAudioMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode highRateMode0 */ + + invokeStartElement (pctxt, "highRateMode0", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->highRateMode0, 27U, 78U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->highRateMode0); + + invokeEndElement (pctxt, "highRateMode0", -1); + + /* decode highRateMode1 */ + + invokeStartElement (pctxt, "highRateMode1", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->highRateMode1, 27U, 78U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->highRateMode1); + + invokeEndElement (pctxt, "highRateMode1", -1); + + /* decode lowRateMode0 */ + + invokeStartElement (pctxt, "lowRateMode0", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->lowRateMode0, 23U, 66U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->lowRateMode0); + + invokeEndElement (pctxt, "lowRateMode0", -1); + + /* decode lowRateMode1 */ + + invokeStartElement (pctxt, "lowRateMode1", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->lowRateMode1, 23U, 66U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->lowRateMode1); + + invokeEndElement (pctxt, "lowRateMode1", -1); + + /* decode sidMode0 */ + + invokeStartElement (pctxt, "sidMode0", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sidMode0, 6U, 17U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sidMode0); + + invokeEndElement (pctxt, "sidMode0", -1); + + /* decode sidMode1 */ + + invokeStartElement (pctxt, "sidMode1", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sidMode1, 6U, 17U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sidMode1); + + invokeEndElement (pctxt, "sidMode1", -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); +} + +/**************************************************************/ +/* */ +/* G7231AnnexCMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245G7231AnnexCMode (OOCTXT* pctxt, H245G7231AnnexCMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode maxAl_sduAudioFrames */ + + invokeStartElement (pctxt, "maxAl_sduAudioFrames", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maxAl_sduAudioFrames, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxAl_sduAudioFrames); + + invokeEndElement (pctxt, "maxAl_sduAudioFrames", -1); + + /* decode silenceSuppression */ + + invokeStartElement (pctxt, "silenceSuppression", -1); + + stat = DECODEBIT (pctxt, &pvalue->silenceSuppression); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->silenceSuppression); + + invokeEndElement (pctxt, "silenceSuppression", -1); + + /* decode g723AnnexCAudioMode */ + + invokeStartElement (pctxt, "g723AnnexCAudioMode", -1); + + stat = asn1PD_H245G7231AnnexCMode_g723AnnexCAudioMode (pctxt, &pvalue->g723AnnexCAudioMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "g723AnnexCAudioMode", -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); +} + +/**************************************************************/ +/* */ +/* VBDMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VBDMode (OOCTXT* pctxt, H245VBDMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + pvalue->type = ALLOC_ASN1ELEM (pctxt, H245AudioMode); + + stat = asn1PD_H245AudioMode (pctxt, (H245AudioMode*)pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* AudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245AudioMode (OOCTXT* pctxt, H245AudioMode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 13); + 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* g711Alaw64k */ + case 1: + invokeStartElement (pctxt, "g711Alaw64k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g711Alaw64k", -1); + + break; + + /* g711Alaw56k */ + case 2: + invokeStartElement (pctxt, "g711Alaw56k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g711Alaw56k", -1); + + break; + + /* g711Ulaw64k */ + case 3: + invokeStartElement (pctxt, "g711Ulaw64k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g711Ulaw64k", -1); + + break; + + /* g711Ulaw56k */ + case 4: + invokeStartElement (pctxt, "g711Ulaw56k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g711Ulaw56k", -1); + + break; + + /* g722_64k */ + case 5: + invokeStartElement (pctxt, "g722_64k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g722_64k", -1); + + break; + + /* g722_56k */ + case 6: + invokeStartElement (pctxt, "g722_56k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g722_56k", -1); + + break; + + /* g722_48k */ + case 7: + invokeStartElement (pctxt, "g722_48k", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g722_48k", -1); + + break; + + /* g728 */ + case 8: + invokeStartElement (pctxt, "g728", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g728", -1); + + break; + + /* g729 */ + case 9: + invokeStartElement (pctxt, "g729", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g729", -1); + + break; + + /* g729AnnexA */ + case 10: + invokeStartElement (pctxt, "g729AnnexA", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "g729AnnexA", -1); + + break; + + /* g7231 */ + case 11: + invokeStartElement (pctxt, "g7231", -1); + + pvalue->u.g7231 = ALLOC_ASN1ELEM (pctxt, H245AudioMode_g7231); + + stat = asn1PD_H245AudioMode_g7231 (pctxt, pvalue->u.g7231); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "g7231", -1); + + break; + + /* is11172AudioMode */ + case 12: + invokeStartElement (pctxt, "is11172AudioMode", -1); + + pvalue->u.is11172AudioMode = ALLOC_ASN1ELEM (pctxt, H245IS11172AudioMode); + + stat = asn1PD_H245IS11172AudioMode (pctxt, pvalue->u.is11172AudioMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "is11172AudioMode", -1); + + break; + + /* is13818AudioMode */ + case 13: + invokeStartElement (pctxt, "is13818AudioMode", -1); + + pvalue->u.is13818AudioMode = ALLOC_ASN1ELEM (pctxt, H245IS13818AudioMode); + + stat = asn1PD_H245IS13818AudioMode (pctxt, pvalue->u.is13818AudioMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "is13818AudioMode", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 15; + + 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) { + /* g729wAnnexB */ + case 15: + invokeStartElement (pctxt, "g729wAnnexB", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g729wAnnexB, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g729wAnnexB); + + invokeEndElement (pctxt, "g729wAnnexB", -1); + + break; + + /* g729AnnexAwAnnexB */ + case 16: + invokeStartElement (pctxt, "g729AnnexAwAnnexB", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.g729AnnexAwAnnexB, 1U, 256U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.g729AnnexAwAnnexB); + + invokeEndElement (pctxt, "g729AnnexAwAnnexB", -1); + + break; + + /* g7231AnnexCMode */ + case 17: + invokeStartElement (pctxt, "g7231AnnexCMode", -1); + + pvalue->u.g7231AnnexCMode = ALLOC_ASN1ELEM (pctxt, H245G7231AnnexCMode); + + stat = asn1PD_H245G7231AnnexCMode (pctxt, pvalue->u.g7231AnnexCMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "g7231AnnexCMode", -1); + + break; + + /* gsmFullRate */ + case 18: + invokeStartElement (pctxt, "gsmFullRate", -1); + + pvalue->u.gsmFullRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability); + + stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmFullRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "gsmFullRate", -1); + + break; + + /* gsmHalfRate */ + case 19: + invokeStartElement (pctxt, "gsmHalfRate", -1); + + pvalue->u.gsmHalfRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability); + + stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmHalfRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "gsmHalfRate", -1); + + break; + + /* gsmEnhancedFullRate */ + case 20: + invokeStartElement (pctxt, "gsmEnhancedFullRate", -1); + + pvalue->u.gsmEnhancedFullRate = ALLOC_ASN1ELEM (pctxt, H245GSMAudioCapability); + + stat = asn1PD_H245GSMAudioCapability (pctxt, pvalue->u.gsmEnhancedFullRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "gsmEnhancedFullRate", -1); + + break; + + /* genericAudioMode */ + case 21: + invokeStartElement (pctxt, "genericAudioMode", -1); + + pvalue->u.genericAudioMode = ALLOC_ASN1ELEM (pctxt, H245GenericCapability); + + stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericAudioMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericAudioMode", -1); + + break; + + /* g729Extensions */ + case 22: + invokeStartElement (pctxt, "g729Extensions", -1); + + pvalue->u.g729Extensions = ALLOC_ASN1ELEM (pctxt, H245G729Extensions); + + stat = asn1PD_H245G729Extensions (pctxt, pvalue->u.g729Extensions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "g729Extensions", -1); + + break; + + /* vbd */ + case 23: + invokeStartElement (pctxt, "vbd", -1); + + pvalue->u.vbd = ALLOC_ASN1ELEM (pctxt, H245VBDMode); + + stat = asn1PD_H245VBDMode (pctxt, pvalue->u.vbd); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "vbd", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataMode_application_nlpid */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataMode_application_nlpid (OOCTXT* pctxt, H245DataMode_application_nlpid* pvalue) +{ + int stat = ASN_OK; + + /* decode nlpidProtocol */ + + invokeStartElement (pctxt, "nlpidProtocol", -1); + + stat = asn1PD_H245DataProtocolCapability (pctxt, &pvalue->nlpidProtocol); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nlpidProtocol", -1); + + /* decode nlpidData */ + + invokeStartElement (pctxt, "nlpidData", -1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->nlpidData); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->nlpidData.numocts, pvalue->nlpidData.data); + + invokeEndElement (pctxt, "nlpidData", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataMode_application_t38fax */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataMode_application_t38fax (OOCTXT* pctxt, H245DataMode_application_t38fax* pvalue) +{ + int stat = ASN_OK; + + /* 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); + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataMode_application */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataMode_application (OOCTXT* pctxt, H245DataMode_application* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 9); + 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* t120 */ + case 1: + invokeStartElement (pctxt, "t120", -1); + + pvalue->u.t120 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t120); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t120", -1); + + break; + + /* dsm_cc */ + case 2: + invokeStartElement (pctxt, "dsm_cc", -1); + + pvalue->u.dsm_cc = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.dsm_cc); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dsm_cc", -1); + + break; + + /* userData */ + case 3: + invokeStartElement (pctxt, "userData", -1); + + pvalue->u.userData = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.userData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "userData", -1); + + break; + + /* t84 */ + case 4: + invokeStartElement (pctxt, "t84", -1); + + pvalue->u.t84 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t84); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t84", -1); + + break; + + /* t434 */ + case 5: + invokeStartElement (pctxt, "t434", -1); + + pvalue->u.t434 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t434); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t434", -1); + + break; + + /* h224 */ + case 6: + invokeStartElement (pctxt, "h224", -1); + + pvalue->u.h224 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.h224); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h224", -1); + + break; + + /* nlpid */ + case 7: + invokeStartElement (pctxt, "nlpid", -1); + + pvalue->u.nlpid = ALLOC_ASN1ELEM (pctxt, H245DataMode_application_nlpid); + + stat = asn1PD_H245DataMode_application_nlpid (pctxt, pvalue->u.nlpid); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nlpid", -1); + + break; + + /* dsvdControl */ + case 8: + invokeStartElement (pctxt, "dsvdControl", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "dsvdControl", -1); + + break; + + /* h222DataPartitioning */ + case 9: + invokeStartElement (pctxt, "h222DataPartitioning", -1); + + pvalue->u.h222DataPartitioning = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.h222DataPartitioning); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h222DataPartitioning", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 11; + + 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) { + /* t30fax */ + case 11: + invokeStartElement (pctxt, "t30fax", -1); + + pvalue->u.t30fax = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t30fax); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t30fax", -1); + + break; + + /* t140 */ + case 12: + invokeStartElement (pctxt, "t140", -1); + + pvalue->u.t140 = ALLOC_ASN1ELEM (pctxt, H245DataProtocolCapability); + + stat = asn1PD_H245DataProtocolCapability (pctxt, pvalue->u.t140); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t140", -1); + + break; + + /* t38fax */ + case 13: + invokeStartElement (pctxt, "t38fax", -1); + + pvalue->u.t38fax = ALLOC_ASN1ELEM (pctxt, H245DataMode_application_t38fax); + + stat = asn1PD_H245DataMode_application_t38fax (pctxt, pvalue->u.t38fax); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "t38fax", -1); + + break; + + /* genericDataMode */ + case 14: + invokeStartElement (pctxt, "genericDataMode", -1); + + pvalue->u.genericDataMode = ALLOC_ASN1ELEM (pctxt, H245GenericCapability); + + stat = asn1PD_H245GenericCapability (pctxt, pvalue->u.genericDataMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericDataMode", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DataMode (OOCTXT* pctxt, H245DataMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode application */ + + invokeStartElement (pctxt, "application", -1); + + stat = asn1PD_H245DataMode_application (pctxt, &pvalue->application); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "application", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->bitRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -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); +} + +/**************************************************************/ +/* */ +/* H235Mode_mediaMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H235Mode_mediaMode (OOCTXT* pctxt, H245H235Mode_mediaMode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* videoMode */ + case 1: + invokeStartElement (pctxt, "videoMode", -1); + + pvalue->u.videoMode = ALLOC_ASN1ELEM (pctxt, H245VideoMode); + + stat = asn1PD_H245VideoMode (pctxt, pvalue->u.videoMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoMode", -1); + + break; + + /* audioMode */ + case 2: + invokeStartElement (pctxt, "audioMode", -1); + + pvalue->u.audioMode = ALLOC_ASN1ELEM (pctxt, H245AudioMode); + + stat = asn1PD_H245AudioMode (pctxt, pvalue->u.audioMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioMode", -1); + + break; + + /* dataMode */ + case 3: + invokeStartElement (pctxt, "dataMode", -1); + + pvalue->u.dataMode = ALLOC_ASN1ELEM (pctxt, H245DataMode); + + stat = asn1PD_H245DataMode (pctxt, pvalue->u.dataMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dataMode", -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); +} + +/**************************************************************/ +/* */ +/* H235Mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H235Mode (OOCTXT* pctxt, H245H235Mode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode encryptionAuthenticationAndIntegrity */ + + invokeStartElement (pctxt, "encryptionAuthenticationAndIntegrity", -1); + + stat = asn1PD_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionAuthenticationAndIntegrity", -1); + + /* decode mediaMode */ + + invokeStartElement (pctxt, "mediaMode", -1); + + stat = asn1PD_H245H235Mode_mediaMode (pctxt, &pvalue->mediaMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaMode", -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); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTModeElement_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingDTModeElement_type (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement_type* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* videoMode */ + case 1: + invokeStartElement (pctxt, "videoMode", -1); + + pvalue->u.videoMode = ALLOC_ASN1ELEM (pctxt, H245VideoMode); + + stat = asn1PD_H245VideoMode (pctxt, pvalue->u.videoMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoMode", -1); + + break; + + /* audioMode */ + case 2: + invokeStartElement (pctxt, "audioMode", -1); + + pvalue->u.audioMode = ALLOC_ASN1ELEM (pctxt, H245AudioMode); + + stat = asn1PD_H245AudioMode (pctxt, pvalue->u.audioMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioMode", -1); + + break; + + /* dataMode */ + case 3: + invokeStartElement (pctxt, "dataMode", -1); + + pvalue->u.dataMode = ALLOC_ASN1ELEM (pctxt, H245DataMode); + + stat = asn1PD_H245DataMode (pctxt, pvalue->u.dataMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dataMode", -1); + + break; + + /* encryptionMode */ + case 4: + invokeStartElement (pctxt, "encryptionMode", -1); + + pvalue->u.encryptionMode = ALLOC_ASN1ELEM (pctxt, H245EncryptionMode); + + stat = asn1PD_H245EncryptionMode (pctxt, pvalue->u.encryptionMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionMode", -1); + + break; + + /* h235Mode */ + case 5: + invokeStartElement (pctxt, "h235Mode", -1); + + pvalue->u.h235Mode = ALLOC_ASN1ELEM (pctxt, H245H235Mode); + + stat = asn1PD_H245H235Mode (pctxt, pvalue->u.h235Mode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h235Mode", -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); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTModeElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245RedundancyEncodingDTModeElement_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245RedundancyEncodingDTModeElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingDTModeElement* pvalue) +{ + int stat = ASN_OK; + H245RedundancyEncodingDTModeElement* 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, H245RedundancyEncodingDTModeElement); + + stat = asn1PD_H245RedundancyEncodingDTModeElement (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingDTMode (OOCTXT* pctxt, H245RedundancyEncodingDTMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode redundancyEncodingMethod */ + + invokeStartElement (pctxt, "redundancyEncodingMethod", -1); + + stat = asn1PD_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncodingMethod", -1); + + /* decode primary */ + + invokeStartElement (pctxt, "primary", -1); + + stat = asn1PD_H245RedundancyEncodingDTModeElement (pctxt, &pvalue->primary); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "primary", -1); + + /* decode secondary */ + + invokeStartElement (pctxt, "secondary", -1); + + stat = asn1PD_H245_SeqOfH245RedundancyEncodingDTModeElement (pctxt, &pvalue->secondary); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "secondary", -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); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamElementMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245MultiplePayloadStreamElementMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + pvalue->type = ALLOC_ASN1ELEM (pctxt, H245ModeElementType); + + stat = asn1PD_H245ModeElementType (pctxt, (H245ModeElementType*)pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245MultiplePayloadStreamElementMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElementMode* pvalue) +{ + int stat = ASN_OK; + H245MultiplePayloadStreamElementMode* 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, H245MultiplePayloadStreamElementMode); + + stat = asn1PD_H245MultiplePayloadStreamElementMode (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplePayloadStreamMode (OOCTXT* pctxt, H245MultiplePayloadStreamMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode elements */ + + invokeStartElement (pctxt, "elements", -1); + + stat = asn1PD_H245_SeqOfH245MultiplePayloadStreamElementMode (pctxt, &pvalue->elements); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "elements", -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); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream_differentPort */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.protectedPayloadTypePresent = optbit; + + /* decode protectedSessionID */ + + invokeStartElement (pctxt, "protectedSessionID", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->protectedSessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->protectedSessionID); + + invokeEndElement (pctxt, "protectedSessionID", -1); + + /* decode protectedPayloadType */ + + if (pvalue->m.protectedPayloadTypePresent) { + invokeStartElement (pctxt, "protectedPayloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->protectedPayloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->protectedPayloadType); + + invokeEndElement (pctxt, "protectedPayloadType", -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); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream_samePort */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_samePort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode protectedType */ + + invokeStartElement (pctxt, "protectedType", -1); + + pvalue->protectedType = ALLOC_ASN1ELEM (pctxt, H245ModeElementType); + + stat = asn1PD_H245ModeElementType (pctxt, (H245ModeElementType*)pvalue->protectedType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "protectedType", -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); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode_separateStream (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* differentPort */ + case 0: + invokeStartElement (pctxt, "differentPort", -1); + + pvalue->u.differentPort = ALLOC_ASN1ELEM (pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort); + + stat = asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (pctxt, pvalue->u.differentPort); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "differentPort", -1); + + break; + + /* samePort */ + case 1: + invokeStartElement (pctxt, "samePort", -1); + + pvalue->u.samePort = ALLOC_ASN1ELEM (pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort); + + stat = asn1PD_H245FECMode_rfc2733Mode_mode_separateStream_samePort (pctxt, pvalue->u.samePort); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "samePort", -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); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECMode_rfc2733Mode_mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* redundancyEncoding */ + case 0: + invokeStartElement (pctxt, "redundancyEncoding", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "redundancyEncoding", -1); + + break; + + /* separateStream */ + case 1: + invokeStartElement (pctxt, "separateStream", -1); + + pvalue->u.separateStream = ALLOC_ASN1ELEM (pctxt, H245FECMode_rfc2733Mode_mode_separateStream); + + stat = asn1PD_H245FECMode_rfc2733Mode_mode_separateStream (pctxt, pvalue->u.separateStream); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "separateStream", -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); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECMode_rfc2733Mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode mode */ + + invokeStartElement (pctxt, "mode", -1); + + stat = asn1PD_H245FECMode_rfc2733Mode_mode (pctxt, &pvalue->mode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mode", -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); +} + +/**************************************************************/ +/* */ +/* FECMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FECMode (OOCTXT* pctxt, H245FECMode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* rfc2733Mode */ + case 0: + invokeStartElement (pctxt, "rfc2733Mode", -1); + + pvalue->u.rfc2733Mode = ALLOC_ASN1ELEM (pctxt, H245FECMode_rfc2733Mode); + + stat = asn1PD_H245FECMode_rfc2733Mode (pctxt, pvalue->u.rfc2733Mode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rfc2733Mode", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ModeElementType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ModeElementType (OOCTXT* pctxt, H245ModeElementType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* videoMode */ + case 1: + invokeStartElement (pctxt, "videoMode", -1); + + pvalue->u.videoMode = ALLOC_ASN1ELEM (pctxt, H245VideoMode); + + stat = asn1PD_H245VideoMode (pctxt, pvalue->u.videoMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoMode", -1); + + break; + + /* audioMode */ + case 2: + invokeStartElement (pctxt, "audioMode", -1); + + pvalue->u.audioMode = ALLOC_ASN1ELEM (pctxt, H245AudioMode); + + stat = asn1PD_H245AudioMode (pctxt, pvalue->u.audioMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioMode", -1); + + break; + + /* dataMode */ + case 3: + invokeStartElement (pctxt, "dataMode", -1); + + pvalue->u.dataMode = ALLOC_ASN1ELEM (pctxt, H245DataMode); + + stat = asn1PD_H245DataMode (pctxt, pvalue->u.dataMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dataMode", -1); + + break; + + /* encryptionMode */ + case 4: + invokeStartElement (pctxt, "encryptionMode", -1); + + pvalue->u.encryptionMode = ALLOC_ASN1ELEM (pctxt, H245EncryptionMode); + + stat = asn1PD_H245EncryptionMode (pctxt, pvalue->u.encryptionMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionMode", -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; + + copyContext (&lctxt, pctxt); + initContextBuffer (pctxt, openType.data, openType.numocts); + + switch (pvalue->t) { + /* h235Mode */ + case 6: + invokeStartElement (pctxt, "h235Mode", -1); + + pvalue->u.h235Mode = ALLOC_ASN1ELEM (pctxt, H245H235Mode); + + stat = asn1PD_H245H235Mode (pctxt, pvalue->u.h235Mode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h235Mode", -1); + + break; + + /* multiplexedStreamMode */ + case 7: + invokeStartElement (pctxt, "multiplexedStreamMode", -1); + + pvalue->u.multiplexedStreamMode = ALLOC_ASN1ELEM (pctxt, H245MultiplexedStreamParameter); + + stat = asn1PD_H245MultiplexedStreamParameter (pctxt, pvalue->u.multiplexedStreamMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexedStreamMode", -1); + + break; + + /* redundancyEncodingDTMode */ + case 8: + invokeStartElement (pctxt, "redundancyEncodingDTMode", -1); + + pvalue->u.redundancyEncodingDTMode = ALLOC_ASN1ELEM (pctxt, H245RedundancyEncodingDTMode); + + stat = asn1PD_H245RedundancyEncodingDTMode (pctxt, pvalue->u.redundancyEncodingDTMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncodingDTMode", -1); + + break; + + /* multiplePayloadStreamMode */ + case 9: + invokeStartElement (pctxt, "multiplePayloadStreamMode", -1); + + pvalue->u.multiplePayloadStreamMode = ALLOC_ASN1ELEM (pctxt, H245MultiplePayloadStreamMode); + + stat = asn1PD_H245MultiplePayloadStreamMode (pctxt, pvalue->u.multiplePayloadStreamMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplePayloadStreamMode", -1); + + break; + + /* fecMode */ + case 10: + invokeStartElement (pctxt, "fecMode", -1); + + pvalue->u.fecMode = ALLOC_ASN1ELEM (pctxt, H245FECMode); + + stat = asn1PD_H245FECMode (pctxt, pvalue->u.fecMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "fecMode", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223ModeParameters_adaptationLayerType_al3 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223ModeParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType_al3* pvalue) +{ + int stat = ASN_OK; + + /* decode controlFieldOctets */ + + invokeStartElement (pctxt, "controlFieldOctets", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->controlFieldOctets, 0U, 2U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->controlFieldOctets); + + invokeEndElement (pctxt, "controlFieldOctets", -1); + + /* decode sendBufferSize */ + + invokeStartElement (pctxt, "sendBufferSize", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->sendBufferSize, 0U, 16777215U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sendBufferSize); + + invokeEndElement (pctxt, "sendBufferSize", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223ModeParameters_adaptationLayerType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223ModeParameters_adaptationLayerType (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* al1Framed */ + case 1: + invokeStartElement (pctxt, "al1Framed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "al1Framed", -1); + + break; + + /* al1NotFramed */ + case 2: + invokeStartElement (pctxt, "al1NotFramed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "al1NotFramed", -1); + + break; + + /* al2WithoutSequenceNumbers */ + case 3: + invokeStartElement (pctxt, "al2WithoutSequenceNumbers", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "al2WithoutSequenceNumbers", -1); + + break; + + /* al2WithSequenceNumbers */ + case 4: + invokeStartElement (pctxt, "al2WithSequenceNumbers", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "al2WithSequenceNumbers", -1); + + break; + + /* al3 */ + case 5: + invokeStartElement (pctxt, "al3", -1); + + pvalue->u.al3 = ALLOC_ASN1ELEM (pctxt, H245H223ModeParameters_adaptationLayerType_al3); + + stat = asn1PD_H245H223ModeParameters_adaptationLayerType_al3 (pctxt, pvalue->u.al3); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "al3", -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) { + /* al1M */ + case 7: + invokeStartElement (pctxt, "al1M", -1); + + pvalue->u.al1M = ALLOC_ASN1ELEM (pctxt, H245H223AL1MParameters); + + stat = asn1PD_H245H223AL1MParameters (pctxt, pvalue->u.al1M); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "al1M", -1); + + break; + + /* al2M */ + case 8: + invokeStartElement (pctxt, "al2M", -1); + + pvalue->u.al2M = ALLOC_ASN1ELEM (pctxt, H245H223AL2MParameters); + + stat = asn1PD_H245H223AL2MParameters (pctxt, pvalue->u.al2M); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "al2M", -1); + + break; + + /* al3M */ + case 9: + invokeStartElement (pctxt, "al3M", -1); + + pvalue->u.al3M = ALLOC_ASN1ELEM (pctxt, H245H223AL3MParameters); + + stat = asn1PD_H245H223AL3MParameters (pctxt, pvalue->u.al3M); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "al3M", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223ModeParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223ModeParameters (OOCTXT* pctxt, H245H223ModeParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode adaptationLayerType */ + + invokeStartElement (pctxt, "adaptationLayerType", -1); + + stat = asn1PD_H245H223ModeParameters_adaptationLayerType (pctxt, &pvalue->adaptationLayerType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "adaptationLayerType", -1); + + /* decode segmentableFlag */ + + invokeStartElement (pctxt, "segmentableFlag", -1); + + stat = DECODEBIT (pctxt, &pvalue->segmentableFlag); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->segmentableFlag); + + invokeEndElement (pctxt, "segmentableFlag", -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); +} + +/**************************************************************/ +/* */ +/* V76ModeParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245V76ModeParameters (OOCTXT* pctxt, H245V76ModeParameters* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* suspendResumewAddress */ + case 0: + invokeStartElement (pctxt, "suspendResumewAddress", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "suspendResumewAddress", -1); + + break; + + /* suspendResumewoAddress */ + case 1: + invokeStartElement (pctxt, "suspendResumewoAddress", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "suspendResumewoAddress", -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); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingMode_secondaryEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingMode_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingMode_secondaryEncoding* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* audioData */ + case 1: + invokeStartElement (pctxt, "audioData", -1); + + pvalue->u.audioData = ALLOC_ASN1ELEM (pctxt, H245AudioMode); + + stat = asn1PD_H245AudioMode (pctxt, pvalue->u.audioData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioData", -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); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RedundancyEncodingMode (OOCTXT* pctxt, H245RedundancyEncodingMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.secondaryEncodingPresent = optbit; + + /* decode redundancyEncodingMethod */ + + invokeStartElement (pctxt, "redundancyEncodingMethod", -1); + + stat = asn1PD_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncodingMethod", -1); + + /* decode secondaryEncoding */ + + if (pvalue->m.secondaryEncodingPresent) { + invokeStartElement (pctxt, "secondaryEncoding", -1); + + stat = asn1PD_H245RedundancyEncodingMode_secondaryEncoding (pctxt, &pvalue->secondaryEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "secondaryEncoding", -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); +} + +/**************************************************************/ +/* */ +/* H2250ModeParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H2250ModeParameters (OOCTXT* pctxt, H245H2250ModeParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.redundancyEncodingModePresent = optbit; + + /* decode redundancyEncodingMode */ + + if (pvalue->m.redundancyEncodingModePresent) { + invokeStartElement (pctxt, "redundancyEncodingMode", -1); + + stat = asn1PD_H245RedundancyEncodingMode (pctxt, &pvalue->redundancyEncodingMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncodingMode", -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); +} + +/**************************************************************/ +/* */ +/* MultiplexedStreamModeParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexedStreamModeParameters (OOCTXT* pctxt, H245MultiplexedStreamModeParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode logicalChannelNumber */ + + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -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); +} + +/**************************************************************/ +/* */ +/* ModeElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ModeElement (OOCTXT* pctxt, H245ModeElement* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.h223ModeParametersPresent = optbit; + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245ModeElementType (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -1); + + /* decode h223ModeParameters */ + + if (pvalue->m.h223ModeParametersPresent) { + invokeStartElement (pctxt, "h223ModeParameters", -1); + + stat = asn1PD_H245H223ModeParameters (pctxt, &pvalue->h223ModeParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223ModeParameters", -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.v76ModeParametersPresent = 1; + + invokeStartElement (pctxt, "v76ModeParameters", -1); + + stat = asn1PD_H245V76ModeParameters (pctxt, &pvalue->v76ModeParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "v76ModeParameters", -1); + break; + + case 1: + pvalue->m.h2250ModeParametersPresent = 1; + + invokeStartElement (pctxt, "h2250ModeParameters", -1); + + stat = asn1PD_H245H2250ModeParameters (pctxt, &pvalue->h2250ModeParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h2250ModeParameters", -1); + break; + + case 2: + pvalue->m.genericModeParametersPresent = 1; + + invokeStartElement (pctxt, "genericModeParameters", -1); + + stat = asn1PD_H245GenericCapability (pctxt, &pvalue->genericModeParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "genericModeParameters", -1); + break; + + case 3: + pvalue->m.multiplexedStreamModeParametersPresent = 1; + + invokeStartElement (pctxt, "multiplexedStreamModeParameters", -1); + + stat = asn1PD_H245MultiplexedStreamModeParameters (pctxt, &pvalue->multiplexedStreamModeParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexedStreamModeParameters", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ModeDescription */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ModeDescription (OOCTXT* pctxt, H245ModeDescription* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245ModeElement* 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, H245ModeElement); + + stat = asn1PD_H245ModeElement (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMode_requestedModes */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMode_requestedModes (OOCTXT* pctxt, H245RequestMode_requestedModes* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245ModeDescription* 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, H245ModeDescription); + + stat = asn1PD_H245ModeDescription (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMode (OOCTXT* pctxt, H245RequestMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode requestedModes */ + + invokeStartElement (pctxt, "requestedModes", -1); + + stat = asn1PD_H245RequestMode_requestedModes (pctxt, &pvalue->requestedModes); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestedModes", -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); +} + +/**************************************************************/ +/* */ +/* RoundTripDelayRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RoundTripDelayRequest (OOCTXT* pctxt, H245RoundTripDelayRequest* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -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); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopRequest_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaintenanceLoopRequest_type (OOCTXT* pctxt, H245MaintenanceLoopRequest_type* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* systemLoop */ + case 0: + invokeStartElement (pctxt, "systemLoop", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "systemLoop", -1); + + break; + + /* mediaLoop */ + case 1: + invokeStartElement (pctxt, "mediaLoop", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.mediaLoop); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaLoop", -1); + + break; + + /* logicalChannelLoop */ + case 2: + invokeStartElement (pctxt, "logicalChannelLoop", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelLoop); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelLoop", -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); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaintenanceLoopRequest (OOCTXT* pctxt, H245MaintenanceLoopRequest* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245MaintenanceLoopRequest_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* CommunicationModeRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CommunicationModeRequest (OOCTXT* pctxt, H245CommunicationModeRequest* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + 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); +} + +/**************************************************************/ +/* */ +/* Criteria */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245Criteria (OOCTXT* pctxt, H245Criteria* pvalue) +{ + static Asn1SizeCnst value_lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode field */ + + invokeStartElement (pctxt, "field", -1); + + stat = decodeObjectIdentifier (pctxt, &pvalue->field); + if (stat != ASN_OK) return stat; + invokeOidValue (pctxt, pvalue->field.numids, pvalue->field.subid); + + invokeEndElement (pctxt, "field", -1); + + /* decode value */ + + invokeStartElement (pctxt, "value", -1); + + addSizeConstraint (pctxt, &value_lsize1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->value); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->value.numocts, pvalue->value.data); + + invokeEndElement (pctxt, "value", -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); +} + +/**************************************************************/ +/* */ +/* CertSelectionCriteria */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CertSelectionCriteria (OOCTXT* pctxt, H245CertSelectionCriteria* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + H245Criteria* 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, H245Criteria); + + stat = asn1PD_H245Criteria (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceRequest_requestTerminalCertificate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceRequest_requestTerminalCertificate (OOCTXT* pctxt, H245ConferenceRequest_requestTerminalCertificate* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.terminalLabelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.certSelectionCriteriaPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.sRandomPresent = optbit; + + /* decode terminalLabel */ + + if (pvalue->m.terminalLabelPresent) { + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + } + + /* decode certSelectionCriteria */ + + if (pvalue->m.certSelectionCriteriaPresent) { + invokeStartElement (pctxt, "certSelectionCriteria", -1); + + stat = asn1PD_H245CertSelectionCriteria (pctxt, &pvalue->certSelectionCriteria); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "certSelectionCriteria", -1); + } + + /* decode sRandom */ + + if (pvalue->m.sRandomPresent) { + invokeStartElement (pctxt, "sRandom", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->sRandom, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sRandom); + + invokeEndElement (pctxt, "sRandom", -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); +} + +/**************************************************************/ +/* */ +/* RemoteMCRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RemoteMCRequest (OOCTXT* pctxt, H245RemoteMCRequest* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* masterActivate */ + case 0: + invokeStartElement (pctxt, "masterActivate", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "masterActivate", -1); + + break; + + /* slaveActivate */ + case 1: + invokeStartElement (pctxt, "slaveActivate", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "slaveActivate", -1); + + break; + + /* deActivate */ + case 2: + invokeStartElement (pctxt, "deActivate", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "deActivate", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceRequest (OOCTXT* pctxt, H245ConferenceRequest* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* terminalListRequest */ + case 0: + invokeStartElement (pctxt, "terminalListRequest", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "terminalListRequest", -1); + + break; + + /* makeMeChair */ + case 1: + invokeStartElement (pctxt, "makeMeChair", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "makeMeChair", -1); + + break; + + /* cancelMakeMeChair */ + case 2: + invokeStartElement (pctxt, "cancelMakeMeChair", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelMakeMeChair", -1); + + break; + + /* dropTerminal */ + case 3: + invokeStartElement (pctxt, "dropTerminal", -1); + + pvalue->u.dropTerminal = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.dropTerminal); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dropTerminal", -1); + + break; + + /* requestTerminalID */ + case 4: + invokeStartElement (pctxt, "requestTerminalID", -1); + + pvalue->u.requestTerminalID = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.requestTerminalID); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestTerminalID", -1); + + break; + + /* enterH243Password */ + case 5: + invokeStartElement (pctxt, "enterH243Password", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "enterH243Password", -1); + + break; + + /* enterH243TerminalID */ + case 6: + invokeStartElement (pctxt, "enterH243TerminalID", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "enterH243TerminalID", -1); + + break; + + /* enterH243ConferenceID */ + case 7: + invokeStartElement (pctxt, "enterH243ConferenceID", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "enterH243ConferenceID", -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) { + /* enterExtensionAddress */ + case 9: + invokeStartElement (pctxt, "enterExtensionAddress", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "enterExtensionAddress", -1); + + break; + + /* requestChairTokenOwner */ + case 10: + invokeStartElement (pctxt, "requestChairTokenOwner", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "requestChairTokenOwner", -1); + + break; + + /* requestTerminalCertificate */ + case 11: + invokeStartElement (pctxt, "requestTerminalCertificate", -1); + + pvalue->u.requestTerminalCertificate = ALLOC_ASN1ELEM (pctxt, H245ConferenceRequest_requestTerminalCertificate); + + stat = asn1PD_H245ConferenceRequest_requestTerminalCertificate (pctxt, pvalue->u.requestTerminalCertificate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestTerminalCertificate", -1); + + break; + + /* broadcastMyLogicalChannel */ + case 12: + invokeStartElement (pctxt, "broadcastMyLogicalChannel", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.broadcastMyLogicalChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "broadcastMyLogicalChannel", -1); + + break; + + /* makeTerminalBroadcaster */ + case 13: + invokeStartElement (pctxt, "makeTerminalBroadcaster", -1); + + pvalue->u.makeTerminalBroadcaster = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.makeTerminalBroadcaster); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "makeTerminalBroadcaster", -1); + + break; + + /* sendThisSource */ + case 14: + invokeStartElement (pctxt, "sendThisSource", -1); + + pvalue->u.sendThisSource = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.sendThisSource); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sendThisSource", -1); + + break; + + /* requestAllTerminalIDs */ + case 15: + invokeStartElement (pctxt, "requestAllTerminalIDs", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "requestAllTerminalIDs", -1); + + break; + + /* remoteMCRequest */ + case 16: + invokeStartElement (pctxt, "remoteMCRequest", -1); + + pvalue->u.remoteMCRequest = ALLOC_ASN1ELEM (pctxt, H245RemoteMCRequest); + + stat = asn1PD_H245RemoteMCRequest (pctxt, pvalue->u.remoteMCRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "remoteMCRequest", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_callInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkRequest_callInformation (OOCTXT* pctxt, H245MultilinkRequest_callInformation* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode maxNumberOfAdditionalConnections */ + + invokeStartElement (pctxt, "maxNumberOfAdditionalConnections", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maxNumberOfAdditionalConnections, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maxNumberOfAdditionalConnections); + + invokeEndElement (pctxt, "maxNumberOfAdditionalConnections", -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); +} + +/**************************************************************/ +/* */ +/* DialingInformationNetworkType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DialingInformationNetworkType (OOCTXT* pctxt, H245DialingInformationNetworkType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* n_isdn */ + case 1: + invokeStartElement (pctxt, "n_isdn", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "n_isdn", -1); + + break; + + /* gstn */ + case 2: + invokeStartElement (pctxt, "gstn", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "gstn", -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) { + /* mobile */ + case 4: + invokeStartElement (pctxt, "mobile", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "mobile", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DialingInformationNumber_networkType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DialingInformationNumber_networkType (OOCTXT* pctxt, H245DialingInformationNumber_networkType* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 255, 0 }; + int stat = ASN_OK; + H245DialingInformationNetworkType* 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, H245DialingInformationNetworkType); + + stat = asn1PD_H245DialingInformationNetworkType (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DialingInformationNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DialingInformationNumber (OOCTXT* pctxt, H245DialingInformationNumber* pvalue) +{ + static Asn1SizeCnst networkAddress_lsize1 = { 0, 0, 40, 0 }; + static Asn1SizeCnst subAddress_lsize1 = { 0, 1, 40, 0 }; + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.subAddressPresent = optbit; + + /* decode networkAddress */ + + invokeStartElement (pctxt, "networkAddress", -1); + + addSizeConstraint (pctxt, &networkAddress_lsize1); + + stat = decodeConstrainedStringEx (pctxt, &pvalue->networkAddress, NUM_CANSET, 4, 4, 4); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->networkAddress); + + invokeEndElement (pctxt, "networkAddress", -1); + + /* decode subAddress */ + + if (pvalue->m.subAddressPresent) { + invokeStartElement (pctxt, "subAddress", -1); + + addSizeConstraint (pctxt, &subAddress_lsize1); + + stat = decodeConstrainedStringEx (pctxt, &pvalue->subAddress, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->subAddress); + + invokeEndElement (pctxt, "subAddress", -1); + } + + /* decode networkType */ + + invokeStartElement (pctxt, "networkType", -1); + + stat = asn1PD_H245DialingInformationNumber_networkType (pctxt, &pvalue->networkType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "networkType", -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); +} + +/**************************************************************/ +/* */ +/* DialingInformation_differential */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DialingInformation_differential (OOCTXT* pctxt, H245DialingInformation_differential* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + H245DialingInformationNumber* 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, H245DialingInformationNumber); + + stat = asn1PD_H245DialingInformationNumber (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DialingInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245DialingInformation (OOCTXT* pctxt, H245DialingInformation* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* differential */ + case 1: + invokeStartElement (pctxt, "differential", -1); + + pvalue->u.differential = ALLOC_ASN1ELEM (pctxt, H245DialingInformation_differential); + + stat = asn1PD_H245DialingInformation_differential (pctxt, pvalue->u.differential); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "differential", -1); + + break; + + /* infoNotAvailable */ + case 2: + invokeStartElement (pctxt, "infoNotAvailable", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.infoNotAvailable, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.infoNotAvailable); + + invokeEndElement (pctxt, "infoNotAvailable", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_addConnection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkRequest_addConnection (OOCTXT* pctxt, H245MultilinkRequest_addConnection* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode dialingInformation */ + + invokeStartElement (pctxt, "dialingInformation", -1); + + stat = asn1PD_H245DialingInformation (pctxt, &pvalue->dialingInformation); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dialingInformation", -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); +} + +/**************************************************************/ +/* */ +/* ConnectionIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConnectionIdentifier (OOCTXT* pctxt, H245ConnectionIdentifier* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode channelTag */ + + invokeStartElement (pctxt, "channelTag", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->channelTag, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->channelTag); + + invokeEndElement (pctxt, "channelTag", -1); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->sequenceNumber, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sequenceNumber); + + invokeEndElement (pctxt, "sequenceNumber", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_removeConnection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkRequest_removeConnection (OOCTXT* pctxt, H245MultilinkRequest_removeConnection* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode connectionIdentifier */ + + invokeStartElement (pctxt, "connectionIdentifier", -1); + + stat = asn1PD_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "connectionIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_maximumHeaderInterval_requestType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkRequest_maximumHeaderInterval_requestType (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval_requestType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* currentIntervalInformation */ + case 0: + invokeStartElement (pctxt, "currentIntervalInformation", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "currentIntervalInformation", -1); + + break; + + /* requestedInterval */ + case 1: + invokeStartElement (pctxt, "requestedInterval", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.requestedInterval, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.requestedInterval); + + invokeEndElement (pctxt, "requestedInterval", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_maximumHeaderInterval */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkRequest_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode requestType */ + + invokeStartElement (pctxt, "requestType", -1); + + stat = asn1PD_H245MultilinkRequest_maximumHeaderInterval_requestType (pctxt, &pvalue->requestType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestType", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkRequest (OOCTXT* pctxt, H245MultilinkRequest* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* callInformation */ + case 1: + invokeStartElement (pctxt, "callInformation", -1); + + pvalue->u.callInformation = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest_callInformation); + + stat = asn1PD_H245MultilinkRequest_callInformation (pctxt, pvalue->u.callInformation); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "callInformation", -1); + + break; + + /* addConnection */ + case 2: + invokeStartElement (pctxt, "addConnection", -1); + + pvalue->u.addConnection = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest_addConnection); + + stat = asn1PD_H245MultilinkRequest_addConnection (pctxt, pvalue->u.addConnection); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "addConnection", -1); + + break; + + /* removeConnection */ + case 3: + invokeStartElement (pctxt, "removeConnection", -1); + + pvalue->u.removeConnection = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest_removeConnection); + + stat = asn1PD_H245MultilinkRequest_removeConnection (pctxt, pvalue->u.removeConnection); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "removeConnection", -1); + + break; + + /* maximumHeaderInterval */ + case 4: + invokeStartElement (pctxt, "maximumHeaderInterval", -1); + + pvalue->u.maximumHeaderInterval = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest_maximumHeaderInterval); + + stat = asn1PD_H245MultilinkRequest_maximumHeaderInterval (pctxt, pvalue->u.maximumHeaderInterval); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "maximumHeaderInterval", -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); +} + +/**************************************************************/ +/* */ +/* MaximumBitRate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaximumBitRate (OOCTXT* pctxt, H245MaximumBitRate* pvalue) +{ + int stat = ASN_OK; + + stat = decodeConsUnsigned (pctxt, pvalue, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, *pvalue); + + return (stat); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245LogicalChannelRateRequest (OOCTXT* pctxt, H245LogicalChannelRateRequest* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode logicalChannelNumber */ + + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + /* decode maximumBitRate */ + + invokeStartElement (pctxt, "maximumBitRate", -1); + + stat = asn1PD_H245MaximumBitRate (pctxt, &pvalue->maximumBitRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "maximumBitRate", -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); +} + +/**************************************************************/ +/* */ +/* RequestMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMessage (OOCTXT* pctxt, H245RequestMessage* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 10); + 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, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* masterSlaveDetermination */ + case 1: + invokeStartElement (pctxt, "masterSlaveDetermination", -1); + + pvalue->u.masterSlaveDetermination = ALLOC_ASN1ELEM (pctxt, H245MasterSlaveDetermination); + + stat = asn1PD_H245MasterSlaveDetermination (pctxt, pvalue->u.masterSlaveDetermination); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "masterSlaveDetermination", -1); + + break; + + /* terminalCapabilitySet */ + case 2: + invokeStartElement (pctxt, "terminalCapabilitySet", -1); + + pvalue->u.terminalCapabilitySet = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySet); + + stat = asn1PD_H245TerminalCapabilitySet (pctxt, pvalue->u.terminalCapabilitySet); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalCapabilitySet", -1); + + break; + + /* openLogicalChannel */ + case 3: + invokeStartElement (pctxt, "openLogicalChannel", -1); + + pvalue->u.openLogicalChannel = ALLOC_ASN1ELEM (pctxt, H245OpenLogicalChannel); + + stat = asn1PD_H245OpenLogicalChannel (pctxt, pvalue->u.openLogicalChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "openLogicalChannel", -1); + + break; + + /* closeLogicalChannel */ + case 4: + invokeStartElement (pctxt, "closeLogicalChannel", -1); + + pvalue->u.closeLogicalChannel = ALLOC_ASN1ELEM (pctxt, H245CloseLogicalChannel); + + stat = asn1PD_H245CloseLogicalChannel (pctxt, pvalue->u.closeLogicalChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "closeLogicalChannel", -1); + + break; + + /* requestChannelClose */ + case 5: + invokeStartElement (pctxt, "requestChannelClose", -1); + + pvalue->u.requestChannelClose = ALLOC_ASN1ELEM (pctxt, H245RequestChannelClose); + + stat = asn1PD_H245RequestChannelClose (pctxt, pvalue->u.requestChannelClose); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestChannelClose", -1); + + break; + + /* multiplexEntrySend */ + case 6: + invokeStartElement (pctxt, "multiplexEntrySend", -1); + + pvalue->u.multiplexEntrySend = ALLOC_ASN1ELEM (pctxt, H245MultiplexEntrySend); + + stat = asn1PD_H245MultiplexEntrySend (pctxt, pvalue->u.multiplexEntrySend); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexEntrySend", -1); + + break; + + /* requestMultiplexEntry */ + case 7: + invokeStartElement (pctxt, "requestMultiplexEntry", -1); + + pvalue->u.requestMultiplexEntry = ALLOC_ASN1ELEM (pctxt, H245RequestMultiplexEntry); + + stat = asn1PD_H245RequestMultiplexEntry (pctxt, pvalue->u.requestMultiplexEntry); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestMultiplexEntry", -1); + + break; + + /* requestMode */ + case 8: + invokeStartElement (pctxt, "requestMode", -1); + + pvalue->u.requestMode = ALLOC_ASN1ELEM (pctxt, H245RequestMode); + + stat = asn1PD_H245RequestMode (pctxt, pvalue->u.requestMode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestMode", -1); + + break; + + /* roundTripDelayRequest */ + case 9: + invokeStartElement (pctxt, "roundTripDelayRequest", -1); + + pvalue->u.roundTripDelayRequest = ALLOC_ASN1ELEM (pctxt, H245RoundTripDelayRequest); + + stat = asn1PD_H245RoundTripDelayRequest (pctxt, pvalue->u.roundTripDelayRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "roundTripDelayRequest", -1); + + break; + + /* maintenanceLoopRequest */ + case 10: + invokeStartElement (pctxt, "maintenanceLoopRequest", -1); + + pvalue->u.maintenanceLoopRequest = ALLOC_ASN1ELEM (pctxt, H245MaintenanceLoopRequest); + + stat = asn1PD_H245MaintenanceLoopRequest (pctxt, pvalue->u.maintenanceLoopRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "maintenanceLoopRequest", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 12; + + 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) { + /* communicationModeRequest */ + case 12: + invokeStartElement (pctxt, "communicationModeRequest", -1); + + pvalue->u.communicationModeRequest = ALLOC_ASN1ELEM (pctxt, H245CommunicationModeRequest); + + stat = asn1PD_H245CommunicationModeRequest (pctxt, pvalue->u.communicationModeRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "communicationModeRequest", -1); + + break; + + /* conferenceRequest */ + case 13: + invokeStartElement (pctxt, "conferenceRequest", -1); + + pvalue->u.conferenceRequest = ALLOC_ASN1ELEM (pctxt, H245ConferenceRequest); + + stat = asn1PD_H245ConferenceRequest (pctxt, pvalue->u.conferenceRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "conferenceRequest", -1); + + break; + + /* multilinkRequest */ + case 14: + invokeStartElement (pctxt, "multilinkRequest", -1); + + pvalue->u.multilinkRequest = ALLOC_ASN1ELEM (pctxt, H245MultilinkRequest); + + stat = asn1PD_H245MultilinkRequest (pctxt, pvalue->u.multilinkRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multilinkRequest", -1); + + break; + + /* logicalChannelRateRequest */ + case 15: + invokeStartElement (pctxt, "logicalChannelRateRequest", -1); + + pvalue->u.logicalChannelRateRequest = ALLOC_ASN1ELEM (pctxt, H245LogicalChannelRateRequest); + + stat = asn1PD_H245LogicalChannelRateRequest (pctxt, pvalue->u.logicalChannelRateRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelRateRequest", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationAck_decision */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MasterSlaveDeterminationAck_decision (OOCTXT* pctxt, H245MasterSlaveDeterminationAck_decision* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* master */ + case 0: + invokeStartElement (pctxt, "master", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "master", -1); + + break; + + /* slave */ + case 1: + invokeStartElement (pctxt, "slave", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "slave", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MasterSlaveDeterminationAck (OOCTXT* pctxt, H245MasterSlaveDeterminationAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode decision */ + + invokeStartElement (pctxt, "decision", -1); + + stat = asn1PD_H245MasterSlaveDeterminationAck_decision (pctxt, &pvalue->decision); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "decision", -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); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MasterSlaveDeterminationReject_cause (OOCTXT* pctxt, H245MasterSlaveDeterminationReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* identicalNumbers */ + case 0: + invokeStartElement (pctxt, "identicalNumbers", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "identicalNumbers", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MasterSlaveDeterminationReject (OOCTXT* pctxt, H245MasterSlaveDeterminationReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245MasterSlaveDeterminationReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -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); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalCapabilitySetAck (OOCTXT* pctxt, H245TerminalCapabilitySetAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -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); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject_cause_tableEntryCapacityExce */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* highestEntryNumberProcessed */ + case 0: + invokeStartElement (pctxt, "highestEntryNumberProcessed", -1); + + stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->u.highestEntryNumberProcessed); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "highestEntryNumberProcessed", -1); + + break; + + /* noneProcessed */ + case 1: + invokeStartElement (pctxt, "noneProcessed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noneProcessed", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalCapabilitySetReject_cause (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* unspecified */ + case 0: + invokeStartElement (pctxt, "unspecified", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unspecified", -1); + + break; + + /* undefinedTableEntryUsed */ + case 1: + invokeStartElement (pctxt, "undefinedTableEntryUsed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "undefinedTableEntryUsed", -1); + + break; + + /* descriptorCapacityExceeded */ + case 2: + invokeStartElement (pctxt, "descriptorCapacityExceeded", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "descriptorCapacityExceeded", -1); + + break; + + /* tableEntryCapacityExceeded */ + case 3: + invokeStartElement (pctxt, "tableEntryCapacityExceeded", -1); + + pvalue->u.tableEntryCapacityExceeded = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded); + + stat = asn1PD_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (pctxt, pvalue->u.tableEntryCapacityExceeded); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "tableEntryCapacityExceeded", -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); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalCapabilitySetReject (OOCTXT* pctxt, H245TerminalCapabilitySetReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245TerminalCapabilitySetReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -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); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_reverseLogicalChannelParameters_mu */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* h222LogicalChannelParameters */ + case 0: + invokeStartElement (pctxt, "h222LogicalChannelParameters", -1); + + pvalue->u.h222LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H222LogicalChannelParameters); + + stat = asn1PD_H245H222LogicalChannelParameters (pctxt, pvalue->u.h222LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h222LogicalChannelParameters", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + 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) { + /* h2250LogicalChannelParameters */ + case 2: + invokeStartElement (pctxt, "h2250LogicalChannelParameters", -1); + + pvalue->u.h2250LogicalChannelParameters = ALLOC_ASN1ELEM (pctxt, H245H2250LogicalChannelParameters); + + stat = asn1PD_H245H2250LogicalChannelParameters (pctxt, pvalue->u.h2250LogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h2250LogicalChannelParameters", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_reverseLogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.portNumberPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.multiplexParametersPresent = optbit; + + /* decode reverseLogicalChannelNumber */ + + invokeStartElement (pctxt, "reverseLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->reverseLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reverseLogicalChannelNumber", -1); + + /* decode portNumber */ + + if (pvalue->m.portNumberPresent) { + invokeStartElement (pctxt, "portNumber", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->portNumber, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->portNumber); + + invokeEndElement (pctxt, "portNumber", -1); + } + + /* decode multiplexParameters */ + + if (pvalue->m.multiplexParametersPresent) { + invokeStartElement (pctxt, "multiplexParameters", -1); + + stat = asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexParameters", -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.replacementForPresent = 1; + + invokeStartElement (pctxt, "replacementFor", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->replacementFor); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "replacementFor", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250LogicalChannelAckParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H2250LogicalChannelAckParameters (OOCTXT* pctxt, H245H2250LogicalChannelAckParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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.sessionIDPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaChannelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaControlChannelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.dynamicRTPPayloadTypePresent = optbit; + + /* decode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + invokeStartElement (pctxt, "nonStandard", -1); + + stat = asn1PD_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + } + + /* decode sessionID */ + + if (pvalue->m.sessionIDPresent) { + 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 mediaChannel */ + + if (pvalue->m.mediaChannelPresent) { + invokeStartElement (pctxt, "mediaChannel", -1); + + stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaChannel", -1); + } + + /* decode mediaControlChannel */ + + if (pvalue->m.mediaControlChannelPresent) { + invokeStartElement (pctxt, "mediaControlChannel", -1); + + stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaControlChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaControlChannel", -1); + } + + /* decode dynamicRTPPayloadType */ + + if (pvalue->m.dynamicRTPPayloadTypePresent) { + invokeStartElement (pctxt, "dynamicRTPPayloadType", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->dynamicRTPPayloadType, 96U, 127U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->dynamicRTPPayloadType); + + invokeEndElement (pctxt, "dynamicRTPPayloadType", -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.flowControlToZeroPresent = 1; + + invokeStartElement (pctxt, "flowControlToZero", -1); + + stat = DECODEBIT (pctxt, &pvalue->flowControlToZero); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->flowControlToZero); + + invokeEndElement (pctxt, "flowControlToZero", -1); + break; + + case 1: + pvalue->m.portNumberPresent = 1; + + invokeStartElement (pctxt, "portNumber", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->portNumber, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->portNumber); + + invokeEndElement (pctxt, "portNumber", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_forwardMultiplexAckParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_forwardMultiplexAckParameters* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* h2250LogicalChannelAckParameters */ + case 0: + invokeStartElement (pctxt, "h2250LogicalChannelAckParameters", -1); + + pvalue->u.h2250LogicalChannelAckParameters = ALLOC_ASN1ELEM (pctxt, H245H2250LogicalChannelAckParameters); + + stat = asn1PD_H245H2250LogicalChannelAckParameters (pctxt, pvalue->u.h2250LogicalChannelAckParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h2250LogicalChannelAckParameters", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannelAck (OOCTXT* pctxt, H245OpenLogicalChannelAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.reverseLogicalChannelParametersPresent = optbit; + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1); + + /* decode reverseLogicalChannelParameters */ + + if (pvalue->m.reverseLogicalChannelParametersPresent) { + invokeStartElement (pctxt, "reverseLogicalChannelParameters", -1); + + stat = asn1PD_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (pctxt, &pvalue->reverseLogicalChannelParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reverseLogicalChannelParameters", -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.separateStackPresent = 1; + + invokeStartElement (pctxt, "separateStack", -1); + + stat = asn1PD_H245NetworkAccessParameters (pctxt, &pvalue->separateStack); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "separateStack", -1); + break; + + case 1: + pvalue->m.forwardMultiplexAckParametersPresent = 1; + + invokeStartElement (pctxt, "forwardMultiplexAckParameters", -1); + + stat = asn1PD_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (pctxt, &pvalue->forwardMultiplexAckParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardMultiplexAckParameters", -1); + break; + + case 2: + pvalue->m.encryptionSyncPresent = 1; + + invokeStartElement (pctxt, "encryptionSync", -1); + + stat = asn1PD_H245EncryptionSync (pctxt, &pvalue->encryptionSync); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionSync", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannelReject_cause (OOCTXT* pctxt, H245OpenLogicalChannelReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* unspecified */ + case 0: + invokeStartElement (pctxt, "unspecified", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unspecified", -1); + + break; + + /* unsuitableReverseParameters */ + case 1: + invokeStartElement (pctxt, "unsuitableReverseParameters", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unsuitableReverseParameters", -1); + + break; + + /* dataTypeNotSupported */ + case 2: + invokeStartElement (pctxt, "dataTypeNotSupported", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "dataTypeNotSupported", -1); + + break; + + /* dataTypeNotAvailable */ + case 3: + invokeStartElement (pctxt, "dataTypeNotAvailable", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "dataTypeNotAvailable", -1); + + break; + + /* unknownDataType */ + case 4: + invokeStartElement (pctxt, "unknownDataType", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unknownDataType", -1); + + break; + + /* dataTypeALCombinationNotSupported */ + case 5: + invokeStartElement (pctxt, "dataTypeALCombinationNotSupported", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "dataTypeALCombinationNotSupported", -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) { + /* multicastChannelNotAllowed */ + case 7: + invokeStartElement (pctxt, "multicastChannelNotAllowed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "multicastChannelNotAllowed", -1); + + break; + + /* insufficientBandwidth */ + case 8: + invokeStartElement (pctxt, "insufficientBandwidth", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "insufficientBandwidth", -1); + + break; + + /* separateStackEstablishmentFailed */ + case 9: + invokeStartElement (pctxt, "separateStackEstablishmentFailed", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "separateStackEstablishmentFailed", -1); + + break; + + /* invalidSessionID */ + case 10: + invokeStartElement (pctxt, "invalidSessionID", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "invalidSessionID", -1); + + break; + + /* masterSlaveConflict */ + case 11: + invokeStartElement (pctxt, "masterSlaveConflict", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "masterSlaveConflict", -1); + + break; + + /* waitForCommunicationMode */ + case 12: + invokeStartElement (pctxt, "waitForCommunicationMode", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "waitForCommunicationMode", -1); + + break; + + /* invalidDependentChannel */ + case 13: + invokeStartElement (pctxt, "invalidDependentChannel", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "invalidDependentChannel", -1); + + break; + + /* replacementForRejected */ + case 14: + invokeStartElement (pctxt, "replacementForRejected", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "replacementForRejected", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannelReject (OOCTXT* pctxt, H245OpenLogicalChannelReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1); + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245OpenLogicalChannelReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -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); +} + +/**************************************************************/ +/* */ +/* CloseLogicalChannelAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CloseLogicalChannelAck (OOCTXT* pctxt, H245CloseLogicalChannelAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -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); +} + +/**************************************************************/ +/* */ +/* RequestChannelCloseAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestChannelCloseAck (OOCTXT* pctxt, H245RequestChannelCloseAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -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); +} + +/**************************************************************/ +/* */ +/* RequestChannelCloseReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestChannelCloseReject_cause (OOCTXT* pctxt, H245RequestChannelCloseReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* unspecified */ + case 0: + invokeStartElement (pctxt, "unspecified", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unspecified", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestChannelCloseReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestChannelCloseReject (OOCTXT* pctxt, H245RequestChannelCloseReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -1); + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245RequestChannelCloseReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -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); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendAck_multiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntrySendAck_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendAck_multiplexTableEntryNumber* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntrySendAck (OOCTXT* pctxt, H245MultiplexEntrySendAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode multiplexTableEntryNumber */ + + invokeStartElement (pctxt, "multiplexTableEntryNumber", -1); + + stat = asn1PD_H245MultiplexEntrySendAck_multiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexTableEntryNumber", -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); +} + +/**************************************************************/ +/* */ +/* MultiplexEntryRejectionDescriptions_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* unspecifiedCause */ + case 0: + invokeStartElement (pctxt, "unspecifiedCause", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unspecifiedCause", -1); + + break; + + /* descriptorTooComplex */ + case 1: + invokeStartElement (pctxt, "descriptorTooComplex", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "descriptorTooComplex", -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); +} + +/**************************************************************/ +/* */ +/* MultiplexEntryRejectionDescriptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode multiplexTableEntryNumber */ + + invokeStartElement (pctxt, "multiplexTableEntryNumber", -1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexTableEntryNumber", -1); + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245MultiplexEntryRejectionDescriptions_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -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); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendReject_rejectionDescriptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntrySendReject_rejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntrySendReject_rejectionDescriptions* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + H245MultiplexEntryRejectionDescriptions* 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, H245MultiplexEntryRejectionDescriptions); + + stat = asn1PD_H245MultiplexEntryRejectionDescriptions (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntrySendReject (OOCTXT* pctxt, H245MultiplexEntrySendReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode rejectionDescriptions */ + + invokeStartElement (pctxt, "rejectionDescriptions", -1); + + stat = asn1PD_H245MultiplexEntrySendReject_rejectionDescriptions (pctxt, &pvalue->rejectionDescriptions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rejectionDescriptions", -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); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryAck_entryNumbers */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryAck_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryAck_entryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryAck (OOCTXT* pctxt, H245RequestMultiplexEntryAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode entryNumbers */ + + invokeStartElement (pctxt, "entryNumbers", -1); + + stat = asn1PD_H245RequestMultiplexEntryAck_entryNumbers (pctxt, &pvalue->entryNumbers); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "entryNumbers", -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); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject_entryNumbers */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryReject_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryReject_entryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRejectionDescriptions_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* unspecifiedCause */ + case 0: + invokeStartElement (pctxt, "unspecifiedCause", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unspecifiedCause", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRejectionDescriptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode multiplexTableEntryNumber */ + + invokeStartElement (pctxt, "multiplexTableEntryNumber", -1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexTableEntryNumber", -1); + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245RequestMultiplexEntryRejectionDescriptions_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -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); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject_rejectionDescriptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryReject_rejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryReject_rejectionDescriptions* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + H245RequestMultiplexEntryRejectionDescriptions* 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, H245RequestMultiplexEntryRejectionDescriptions); + + stat = asn1PD_H245RequestMultiplexEntryRejectionDescriptions (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryReject (OOCTXT* pctxt, H245RequestMultiplexEntryReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode entryNumbers */ + + invokeStartElement (pctxt, "entryNumbers", -1); + + stat = asn1PD_H245RequestMultiplexEntryReject_entryNumbers (pctxt, &pvalue->entryNumbers); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "entryNumbers", -1); + + /* decode rejectionDescriptions */ + + invokeStartElement (pctxt, "rejectionDescriptions", -1); + + stat = asn1PD_H245RequestMultiplexEntryReject_rejectionDescriptions (pctxt, &pvalue->rejectionDescriptions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rejectionDescriptions", -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); +} + +/**************************************************************/ +/* */ +/* RequestModeAck_response */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestModeAck_response (OOCTXT* pctxt, H245RequestModeAck_response* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* willTransmitMostPreferredMode */ + case 0: + invokeStartElement (pctxt, "willTransmitMostPreferredMode", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "willTransmitMostPreferredMode", -1); + + break; + + /* willTransmitLessPreferredMode */ + case 1: + invokeStartElement (pctxt, "willTransmitLessPreferredMode", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "willTransmitLessPreferredMode", -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); +} + +/**************************************************************/ +/* */ +/* RequestModeAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestModeAck (OOCTXT* pctxt, H245RequestModeAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode response */ + + invokeStartElement (pctxt, "response", -1); + + stat = asn1PD_H245RequestModeAck_response (pctxt, &pvalue->response); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "response", -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); +} + +/**************************************************************/ +/* */ +/* RequestModeReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestModeReject_cause (OOCTXT* pctxt, H245RequestModeReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* modeUnavailable */ + case 0: + invokeStartElement (pctxt, "modeUnavailable", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "modeUnavailable", -1); + + break; + + /* multipointConstraint */ + case 1: + invokeStartElement (pctxt, "multipointConstraint", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "multipointConstraint", -1); + + break; + + /* requestDenied */ + case 2: + invokeStartElement (pctxt, "requestDenied", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "requestDenied", -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); +} + +/**************************************************************/ +/* */ +/* RequestModeReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestModeReject (OOCTXT* pctxt, H245RequestModeReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245RequestModeReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -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); +} + +/**************************************************************/ +/* */ +/* RoundTripDelayResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RoundTripDelayResponse (OOCTXT* pctxt, H245RoundTripDelayResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -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); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopAck_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaintenanceLoopAck_type (OOCTXT* pctxt, H245MaintenanceLoopAck_type* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* systemLoop */ + case 0: + invokeStartElement (pctxt, "systemLoop", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "systemLoop", -1); + + break; + + /* mediaLoop */ + case 1: + invokeStartElement (pctxt, "mediaLoop", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.mediaLoop); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaLoop", -1); + + break; + + /* logicalChannelLoop */ + case 2: + invokeStartElement (pctxt, "logicalChannelLoop", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelLoop); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelLoop", -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); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaintenanceLoopAck (OOCTXT* pctxt, H245MaintenanceLoopAck* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245MaintenanceLoopAck_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaintenanceLoopReject_type (OOCTXT* pctxt, H245MaintenanceLoopReject_type* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* systemLoop */ + case 0: + invokeStartElement (pctxt, "systemLoop", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "systemLoop", -1); + + break; + + /* mediaLoop */ + case 1: + invokeStartElement (pctxt, "mediaLoop", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.mediaLoop); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaLoop", -1); + + break; + + /* logicalChannelLoop */ + case 2: + invokeStartElement (pctxt, "logicalChannelLoop", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelLoop); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelLoop", -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); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaintenanceLoopReject_cause (OOCTXT* pctxt, H245MaintenanceLoopReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* canNotPerformLoop */ + case 0: + invokeStartElement (pctxt, "canNotPerformLoop", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "canNotPerformLoop", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaintenanceLoopReject (OOCTXT* pctxt, H245MaintenanceLoopReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245MaintenanceLoopReject_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -1); + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245MaintenanceLoopReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -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); +} + +/**************************************************************/ +/* */ +/* CommunicationModeTableEntry_dataType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CommunicationModeTableEntry_dataType (OOCTXT* pctxt, H245CommunicationModeTableEntry_dataType* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* videoData */ + case 0: + invokeStartElement (pctxt, "videoData", -1); + + pvalue->u.videoData = ALLOC_ASN1ELEM (pctxt, H245VideoCapability); + + stat = asn1PD_H245VideoCapability (pctxt, pvalue->u.videoData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoData", -1); + + break; + + /* audioData */ + case 1: + invokeStartElement (pctxt, "audioData", -1); + + pvalue->u.audioData = ALLOC_ASN1ELEM (pctxt, H245AudioCapability); + + stat = asn1PD_H245AudioCapability (pctxt, pvalue->u.audioData); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "audioData", -1); + + break; + + /* data */ + case 2: + invokeStartElement (pctxt, "data", -1); + + pvalue->u.data = ALLOC_ASN1ELEM (pctxt, H245DataApplicationCapability); + + stat = asn1PD_H245DataApplicationCapability (pctxt, pvalue->u.data); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "data", -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); +} + +/**************************************************************/ +/* */ +/* CommunicationModeTableEntry */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CommunicationModeTableEntry (OOCTXT* pctxt, H245CommunicationModeTableEntry* pvalue) +{ + static Asn1SizeCnst sessionDescription_lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* 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.associatedSessionIDPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.terminalLabelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaChannelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaGuaranteedDeliveryPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaControlChannelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.mediaControlGuaranteedDeliveryPresent = optbit; + + /* decode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + invokeStartElement (pctxt, "nonStandard", -1); + + stat = asn1PD_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -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 associatedSessionID */ + + if (pvalue->m.associatedSessionIDPresent) { + invokeStartElement (pctxt, "associatedSessionID", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->associatedSessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->associatedSessionID); + + invokeEndElement (pctxt, "associatedSessionID", -1); + } + + /* decode terminalLabel */ + + if (pvalue->m.terminalLabelPresent) { + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + } + + /* decode sessionDescription */ + + invokeStartElement (pctxt, "sessionDescription", -1); + + addSizeConstraint (pctxt, &sessionDescription_lsize1); + + stat = decodeBMPString (pctxt, &pvalue->sessionDescription, 0); + if (stat != ASN_OK) return stat; + invokeCharStr16BitValue (pctxt, pvalue->sessionDescription.nchars, pvalue->sessionDescription.data); + + invokeEndElement (pctxt, "sessionDescription", -1); + + /* decode dataType */ + + invokeStartElement (pctxt, "dataType", -1); + + stat = asn1PD_H245CommunicationModeTableEntry_dataType (pctxt, &pvalue->dataType); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dataType", -1); + + /* decode mediaChannel */ + + if (pvalue->m.mediaChannelPresent) { + invokeStartElement (pctxt, "mediaChannel", -1); + + stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaChannel", -1); + } + + /* decode mediaGuaranteedDelivery */ + + if (pvalue->m.mediaGuaranteedDeliveryPresent) { + invokeStartElement (pctxt, "mediaGuaranteedDelivery", -1); + + stat = DECODEBIT (pctxt, &pvalue->mediaGuaranteedDelivery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->mediaGuaranteedDelivery); + + invokeEndElement (pctxt, "mediaGuaranteedDelivery", -1); + } + + /* decode mediaControlChannel */ + + if (pvalue->m.mediaControlChannelPresent) { + invokeStartElement (pctxt, "mediaControlChannel", -1); + + stat = asn1PD_H245TransportAddress (pctxt, &pvalue->mediaControlChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mediaControlChannel", -1); + } + + /* decode mediaControlGuaranteedDelivery */ + + if (pvalue->m.mediaControlGuaranteedDeliveryPresent) { + invokeStartElement (pctxt, "mediaControlGuaranteedDelivery", -1); + + stat = DECODEBIT (pctxt, &pvalue->mediaControlGuaranteedDelivery); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->mediaControlGuaranteedDelivery); + + invokeEndElement (pctxt, "mediaControlGuaranteedDelivery", -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.redundancyEncodingPresent = 1; + + invokeStartElement (pctxt, "redundancyEncoding", -1); + + stat = asn1PD_H245RedundancyEncoding (pctxt, &pvalue->redundancyEncoding); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "redundancyEncoding", -1); + break; + + case 1: + pvalue->m.sessionDependencyPresent = 1; + + invokeStartElement (pctxt, "sessionDependency", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sessionDependency, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sessionDependency); + + invokeEndElement (pctxt, "sessionDependency", -1); + break; + + case 2: + pvalue->m.destinationPresent = 1; + + invokeStartElement (pctxt, "destination", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->destination); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "destination", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeResponse_communicationModeTable */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CommunicationModeResponse_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeResponse_communicationModeTable* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245CommunicationModeTableEntry* 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, H245CommunicationModeTableEntry); + + stat = asn1PD_H245CommunicationModeTableEntry (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CommunicationModeResponse (OOCTXT* pctxt, H245CommunicationModeResponse* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 0); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* communicationModeTable */ + case 0: + invokeStartElement (pctxt, "communicationModeTable", -1); + + pvalue->u.communicationModeTable = ALLOC_ASN1ELEM (pctxt, H245CommunicationModeResponse_communicationModeTable); + + stat = asn1PD_H245CommunicationModeResponse_communicationModeTable (pctxt, pvalue->u.communicationModeTable); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "communicationModeTable", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 2; + + stat = decodeByteAlign (pctxt); + if (stat != ASN_OK) return stat; + + stat = decodeOpenType (pctxt, &openType.data, &openType.numocts); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalID */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalID (OOCTXT* pctxt, H245TerminalID* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 128, 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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_mCTerminalIDResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_mCTerminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_mCTerminalIDResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalLabel */ + + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + + /* decode terminalID */ + + invokeStartElement (pctxt, "terminalID", -1); + + stat = asn1PD_H245TerminalID (pctxt, &pvalue->terminalID); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalID", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalIDResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_terminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalIDResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalLabel */ + + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + + /* decode terminalID */ + + invokeStartElement (pctxt, "terminalID", -1); + + stat = asn1PD_H245TerminalID (pctxt, &pvalue->terminalID); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalID", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceID */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceID (OOCTXT* pctxt, H245ConferenceID* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_conferenceIDResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_conferenceIDResponse (OOCTXT* pctxt, H245ConferenceResponse_conferenceIDResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalLabel */ + + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + + /* decode conferenceID */ + + invokeStartElement (pctxt, "conferenceID", -1); + + stat = asn1PD_H245ConferenceID (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; + + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Password */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245Password (OOCTXT* pctxt, H245Password* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_passwordResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_passwordResponse (OOCTXT* pctxt, H245ConferenceResponse_passwordResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalLabel */ + + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + + /* decode password */ + + invokeStartElement (pctxt, "password", -1); + + stat = asn1PD_H245Password (pctxt, &pvalue->password); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "password", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalListResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_terminalListResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalListResponse* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245TerminalLabel* 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, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_makeMeChairResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_makeMeChairResponse (OOCTXT* pctxt, H245ConferenceResponse_makeMeChairResponse* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* grantedChairToken */ + case 0: + invokeStartElement (pctxt, "grantedChairToken", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "grantedChairToken", -1); + + break; + + /* deniedChairToken */ + case 1: + invokeStartElement (pctxt, "deniedChairToken", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "deniedChairToken", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_extensionAddressResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_extensionAddressResponse (OOCTXT* pctxt, H245ConferenceResponse_extensionAddressResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode extensionAddress */ + + invokeStartElement (pctxt, "extensionAddress", -1); + + stat = asn1PD_H245TerminalID (pctxt, &pvalue->extensionAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "extensionAddress", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_chairTokenOwnerResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_chairTokenOwnerResponse (OOCTXT* pctxt, H245ConferenceResponse_chairTokenOwnerResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalLabel */ + + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + + /* decode terminalID */ + + invokeStartElement (pctxt, "terminalID", -1); + + stat = asn1PD_H245TerminalID (pctxt, &pvalue->terminalID); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalID", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalCertificateResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_terminalCertificateResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalCertificateResponse* pvalue) +{ + static Asn1SizeCnst certificateResponse_lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.terminalLabelPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.certificateResponsePresent = optbit; + + /* decode terminalLabel */ + + if (pvalue->m.terminalLabelPresent) { + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + } + + /* decode certificateResponse */ + + if (pvalue->m.certificateResponsePresent) { + invokeStartElement (pctxt, "certificateResponse", -1); + + addSizeConstraint (pctxt, &certificateResponse_lsize1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->certificateResponse); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->certificateResponse.numocts, pvalue->certificateResponse.data); + + invokeEndElement (pctxt, "certificateResponse", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_broadcastMyLogicalChannelResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_broadcastMyLogicalChannelResponse (OOCTXT* pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* grantedBroadcastMyLogicalChannel */ + case 0: + invokeStartElement (pctxt, "grantedBroadcastMyLogicalChannel", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "grantedBroadcastMyLogicalChannel", -1); + + break; + + /* deniedBroadcastMyLogicalChannel */ + case 1: + invokeStartElement (pctxt, "deniedBroadcastMyLogicalChannel", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "deniedBroadcastMyLogicalChannel", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_makeTerminalBroadcasterResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_makeTerminalBroadcasterResponse (OOCTXT* pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* grantedMakeTerminalBroadcaster */ + case 0: + invokeStartElement (pctxt, "grantedMakeTerminalBroadcaster", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "grantedMakeTerminalBroadcaster", -1); + + break; + + /* deniedMakeTerminalBroadcaster */ + case 1: + invokeStartElement (pctxt, "deniedMakeTerminalBroadcaster", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "deniedMakeTerminalBroadcaster", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_sendThisSourceResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse_sendThisSourceResponse (OOCTXT* pctxt, H245ConferenceResponse_sendThisSourceResponse* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* grantedSendThisSource */ + case 0: + invokeStartElement (pctxt, "grantedSendThisSource", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "grantedSendThisSource", -1); + + break; + + /* deniedSendThisSource */ + case 1: + invokeStartElement (pctxt, "deniedSendThisSource", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "deniedSendThisSource", -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); +} + +/**************************************************************/ +/* */ +/* TerminalInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalInformation (OOCTXT* pctxt, H245TerminalInformation* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalLabel */ + + invokeStartElement (pctxt, "terminalLabel", -1); + + stat = asn1PD_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLabel", -1); + + /* decode terminalID */ + + invokeStartElement (pctxt, "terminalID", -1); + + stat = asn1PD_H245TerminalID (pctxt, &pvalue->terminalID); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalID", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245TerminalInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245TerminalInformation (OOCTXT* pctxt, H245_SeqOfH245TerminalInformation* pvalue) +{ + int stat = ASN_OK; + H245TerminalInformation* 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, H245TerminalInformation); + + stat = asn1PD_H245TerminalInformation (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestAllTerminalIDsResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestAllTerminalIDsResponse (OOCTXT* pctxt, H245RequestAllTerminalIDsResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalInformation */ + + invokeStartElement (pctxt, "terminalInformation", -1); + + stat = asn1PD_H245_SeqOfH245TerminalInformation (pctxt, &pvalue->terminalInformation); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalInformation", -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); +} + +/**************************************************************/ +/* */ +/* RemoteMCResponse_reject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RemoteMCResponse_reject (OOCTXT* pctxt, H245RemoteMCResponse_reject* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* unspecified */ + case 0: + invokeStartElement (pctxt, "unspecified", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unspecified", -1); + + break; + + /* functionNotSupported */ + case 1: + invokeStartElement (pctxt, "functionNotSupported", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "functionNotSupported", -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); +} + +/**************************************************************/ +/* */ +/* RemoteMCResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RemoteMCResponse (OOCTXT* pctxt, H245RemoteMCResponse* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* accept */ + case 0: + invokeStartElement (pctxt, "accept", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "accept", -1); + + break; + + /* reject */ + case 1: + invokeStartElement (pctxt, "reject", -1); + + pvalue->u.reject = ALLOC_ASN1ELEM (pctxt, H245RemoteMCResponse_reject); + + stat = asn1PD_H245RemoteMCResponse_reject (pctxt, pvalue->u.reject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reject", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceResponse (OOCTXT* pctxt, H245ConferenceResponse* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* mCTerminalIDResponse */ + case 0: + invokeStartElement (pctxt, "mCTerminalIDResponse", -1); + + pvalue->u.mCTerminalIDResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_mCTerminalIDResponse); + + stat = asn1PD_H245ConferenceResponse_mCTerminalIDResponse (pctxt, pvalue->u.mCTerminalIDResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mCTerminalIDResponse", -1); + + break; + + /* terminalIDResponse */ + case 1: + invokeStartElement (pctxt, "terminalIDResponse", -1); + + pvalue->u.terminalIDResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_terminalIDResponse); + + stat = asn1PD_H245ConferenceResponse_terminalIDResponse (pctxt, pvalue->u.terminalIDResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalIDResponse", -1); + + break; + + /* conferenceIDResponse */ + case 2: + invokeStartElement (pctxt, "conferenceIDResponse", -1); + + pvalue->u.conferenceIDResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_conferenceIDResponse); + + stat = asn1PD_H245ConferenceResponse_conferenceIDResponse (pctxt, pvalue->u.conferenceIDResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "conferenceIDResponse", -1); + + break; + + /* passwordResponse */ + case 3: + invokeStartElement (pctxt, "passwordResponse", -1); + + pvalue->u.passwordResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_passwordResponse); + + stat = asn1PD_H245ConferenceResponse_passwordResponse (pctxt, pvalue->u.passwordResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "passwordResponse", -1); + + break; + + /* terminalListResponse */ + case 4: + invokeStartElement (pctxt, "terminalListResponse", -1); + + pvalue->u.terminalListResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_terminalListResponse); + + stat = asn1PD_H245ConferenceResponse_terminalListResponse (pctxt, pvalue->u.terminalListResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalListResponse", -1); + + break; + + /* videoCommandReject */ + case 5: + invokeStartElement (pctxt, "videoCommandReject", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "videoCommandReject", -1); + + break; + + /* terminalDropReject */ + case 6: + invokeStartElement (pctxt, "terminalDropReject", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "terminalDropReject", -1); + + break; + + /* makeMeChairResponse */ + case 7: + invokeStartElement (pctxt, "makeMeChairResponse", -1); + + pvalue->u.makeMeChairResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_makeMeChairResponse); + + stat = asn1PD_H245ConferenceResponse_makeMeChairResponse (pctxt, pvalue->u.makeMeChairResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "makeMeChairResponse", -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) { + /* extensionAddressResponse */ + case 9: + invokeStartElement (pctxt, "extensionAddressResponse", -1); + + pvalue->u.extensionAddressResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_extensionAddressResponse); + + stat = asn1PD_H245ConferenceResponse_extensionAddressResponse (pctxt, pvalue->u.extensionAddressResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "extensionAddressResponse", -1); + + break; + + /* chairTokenOwnerResponse */ + case 10: + invokeStartElement (pctxt, "chairTokenOwnerResponse", -1); + + pvalue->u.chairTokenOwnerResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_chairTokenOwnerResponse); + + stat = asn1PD_H245ConferenceResponse_chairTokenOwnerResponse (pctxt, pvalue->u.chairTokenOwnerResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "chairTokenOwnerResponse", -1); + + break; + + /* terminalCertificateResponse */ + case 11: + invokeStartElement (pctxt, "terminalCertificateResponse", -1); + + pvalue->u.terminalCertificateResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_terminalCertificateResponse); + + stat = asn1PD_H245ConferenceResponse_terminalCertificateResponse (pctxt, pvalue->u.terminalCertificateResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalCertificateResponse", -1); + + break; + + /* broadcastMyLogicalChannelResponse */ + case 12: + invokeStartElement (pctxt, "broadcastMyLogicalChannelResponse", -1); + + pvalue->u.broadcastMyLogicalChannelResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse); + + stat = asn1PD_H245ConferenceResponse_broadcastMyLogicalChannelResponse (pctxt, pvalue->u.broadcastMyLogicalChannelResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "broadcastMyLogicalChannelResponse", -1); + + break; + + /* makeTerminalBroadcasterResponse */ + case 13: + invokeStartElement (pctxt, "makeTerminalBroadcasterResponse", -1); + + pvalue->u.makeTerminalBroadcasterResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse); + + stat = asn1PD_H245ConferenceResponse_makeTerminalBroadcasterResponse (pctxt, pvalue->u.makeTerminalBroadcasterResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "makeTerminalBroadcasterResponse", -1); + + break; + + /* sendThisSourceResponse */ + case 14: + invokeStartElement (pctxt, "sendThisSourceResponse", -1); + + pvalue->u.sendThisSourceResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse_sendThisSourceResponse); + + stat = asn1PD_H245ConferenceResponse_sendThisSourceResponse (pctxt, pvalue->u.sendThisSourceResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sendThisSourceResponse", -1); + + break; + + /* requestAllTerminalIDsResponse */ + case 15: + invokeStartElement (pctxt, "requestAllTerminalIDsResponse", -1); + + pvalue->u.requestAllTerminalIDsResponse = ALLOC_ASN1ELEM (pctxt, H245RequestAllTerminalIDsResponse); + + stat = asn1PD_H245RequestAllTerminalIDsResponse (pctxt, pvalue->u.requestAllTerminalIDsResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestAllTerminalIDsResponse", -1); + + break; + + /* remoteMCResponse */ + case 16: + invokeStartElement (pctxt, "remoteMCResponse", -1); + + pvalue->u.remoteMCResponse = ALLOC_ASN1ELEM (pctxt, H245RemoteMCResponse); + + stat = asn1PD_H245RemoteMCResponse (pctxt, pvalue->u.remoteMCResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "remoteMCResponse", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_callInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkResponse_callInformation (OOCTXT* pctxt, H245MultilinkResponse_callInformation* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode dialingInformation */ + + invokeStartElement (pctxt, "dialingInformation", -1); + + stat = asn1PD_H245DialingInformation (pctxt, &pvalue->dialingInformation); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "dialingInformation", -1); + + /* decode callAssociationNumber */ + + invokeStartElement (pctxt, "callAssociationNumber", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->callAssociationNumber, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->callAssociationNumber); + + invokeEndElement (pctxt, "callAssociationNumber", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection_responseCode_rejected */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkResponse_addConnection_responseCode_rejected (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode_rejected* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* connectionsNotAvailable */ + case 0: + invokeStartElement (pctxt, "connectionsNotAvailable", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "connectionsNotAvailable", -1); + + break; + + /* userRejected */ + case 1: + invokeStartElement (pctxt, "userRejected", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "userRejected", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection_responseCode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkResponse_addConnection_responseCode (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* accepted */ + case 0: + invokeStartElement (pctxt, "accepted", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "accepted", -1); + + break; + + /* rejected */ + case 1: + invokeStartElement (pctxt, "rejected", -1); + + pvalue->u.rejected = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_addConnection_responseCode_rejected); + + stat = asn1PD_H245MultilinkResponse_addConnection_responseCode_rejected (pctxt, pvalue->u.rejected); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rejected", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkResponse_addConnection (OOCTXT* pctxt, H245MultilinkResponse_addConnection* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode responseCode */ + + invokeStartElement (pctxt, "responseCode", -1); + + stat = asn1PD_H245MultilinkResponse_addConnection_responseCode (pctxt, &pvalue->responseCode); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "responseCode", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_removeConnection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkResponse_removeConnection (OOCTXT* pctxt, H245MultilinkResponse_removeConnection* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode connectionIdentifier */ + + invokeStartElement (pctxt, "connectionIdentifier", -1); + + stat = asn1PD_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "connectionIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_maximumHeaderInterval */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkResponse_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkResponse_maximumHeaderInterval* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode currentInterval */ + + invokeStartElement (pctxt, "currentInterval", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->currentInterval, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->currentInterval); + + invokeEndElement (pctxt, "currentInterval", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkResponse (OOCTXT* pctxt, H245MultilinkResponse* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* callInformation */ + case 1: + invokeStartElement (pctxt, "callInformation", -1); + + pvalue->u.callInformation = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_callInformation); + + stat = asn1PD_H245MultilinkResponse_callInformation (pctxt, pvalue->u.callInformation); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "callInformation", -1); + + break; + + /* addConnection */ + case 2: + invokeStartElement (pctxt, "addConnection", -1); + + pvalue->u.addConnection = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_addConnection); + + stat = asn1PD_H245MultilinkResponse_addConnection (pctxt, pvalue->u.addConnection); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "addConnection", -1); + + break; + + /* removeConnection */ + case 3: + invokeStartElement (pctxt, "removeConnection", -1); + + pvalue->u.removeConnection = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_removeConnection); + + stat = asn1PD_H245MultilinkResponse_removeConnection (pctxt, pvalue->u.removeConnection); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "removeConnection", -1); + + break; + + /* maximumHeaderInterval */ + case 4: + invokeStartElement (pctxt, "maximumHeaderInterval", -1); + + pvalue->u.maximumHeaderInterval = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse_maximumHeaderInterval); + + stat = asn1PD_H245MultilinkResponse_maximumHeaderInterval (pctxt, pvalue->u.maximumHeaderInterval); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "maximumHeaderInterval", -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); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateAcknowledge */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245LogicalChannelRateAcknowledge (OOCTXT* pctxt, H245LogicalChannelRateAcknowledge* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode logicalChannelNumber */ + + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + /* decode maximumBitRate */ + + invokeStartElement (pctxt, "maximumBitRate", -1); + + stat = asn1PD_H245MaximumBitRate (pctxt, &pvalue->maximumBitRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "maximumBitRate", -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); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245LogicalChannelRateRejectReason (OOCTXT* pctxt, H245LogicalChannelRateRejectReason* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* undefinedReason */ + case 0: + invokeStartElement (pctxt, "undefinedReason", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "undefinedReason", -1); + + break; + + /* insufficientResources */ + case 1: + invokeStartElement (pctxt, "insufficientResources", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "insufficientResources", -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); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245LogicalChannelRateReject (OOCTXT* pctxt, H245LogicalChannelRateReject* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.currentMaximumBitRatePresent = optbit; + + /* decode sequenceNumber */ + + invokeStartElement (pctxt, "sequenceNumber", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sequenceNumber", -1); + + /* decode logicalChannelNumber */ + + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + /* decode rejectReason */ + + invokeStartElement (pctxt, "rejectReason", -1); + + stat = asn1PD_H245LogicalChannelRateRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rejectReason", -1); + + /* decode currentMaximumBitRate */ + + if (pvalue->m.currentMaximumBitRatePresent) { + invokeStartElement (pctxt, "currentMaximumBitRate", -1); + + stat = asn1PD_H245MaximumBitRate (pctxt, &pvalue->currentMaximumBitRate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "currentMaximumBitRate", -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); +} + +/**************************************************************/ +/* */ +/* ResponseMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ResponseMessage (OOCTXT* pctxt, H245ResponseMessage* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 18); + 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, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* masterSlaveDeterminationAck */ + case 1: + invokeStartElement (pctxt, "masterSlaveDeterminationAck", -1); + + pvalue->u.masterSlaveDeterminationAck = ALLOC_ASN1ELEM (pctxt, H245MasterSlaveDeterminationAck); + + stat = asn1PD_H245MasterSlaveDeterminationAck (pctxt, pvalue->u.masterSlaveDeterminationAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "masterSlaveDeterminationAck", -1); + + break; + + /* masterSlaveDeterminationReject */ + case 2: + invokeStartElement (pctxt, "masterSlaveDeterminationReject", -1); + + pvalue->u.masterSlaveDeterminationReject = ALLOC_ASN1ELEM (pctxt, H245MasterSlaveDeterminationReject); + + stat = asn1PD_H245MasterSlaveDeterminationReject (pctxt, pvalue->u.masterSlaveDeterminationReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "masterSlaveDeterminationReject", -1); + + break; + + /* terminalCapabilitySetAck */ + case 3: + invokeStartElement (pctxt, "terminalCapabilitySetAck", -1); + + pvalue->u.terminalCapabilitySetAck = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySetAck); + + stat = asn1PD_H245TerminalCapabilitySetAck (pctxt, pvalue->u.terminalCapabilitySetAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalCapabilitySetAck", -1); + + break; + + /* terminalCapabilitySetReject */ + case 4: + invokeStartElement (pctxt, "terminalCapabilitySetReject", -1); + + pvalue->u.terminalCapabilitySetReject = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySetReject); + + stat = asn1PD_H245TerminalCapabilitySetReject (pctxt, pvalue->u.terminalCapabilitySetReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalCapabilitySetReject", -1); + + break; + + /* openLogicalChannelAck */ + case 5: + invokeStartElement (pctxt, "openLogicalChannelAck", -1); + + pvalue->u.openLogicalChannelAck = ALLOC_ASN1ELEM (pctxt, H245OpenLogicalChannelAck); + + stat = asn1PD_H245OpenLogicalChannelAck (pctxt, pvalue->u.openLogicalChannelAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "openLogicalChannelAck", -1); + + break; + + /* openLogicalChannelReject */ + case 6: + invokeStartElement (pctxt, "openLogicalChannelReject", -1); + + pvalue->u.openLogicalChannelReject = ALLOC_ASN1ELEM (pctxt, H245OpenLogicalChannelReject); + + stat = asn1PD_H245OpenLogicalChannelReject (pctxt, pvalue->u.openLogicalChannelReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "openLogicalChannelReject", -1); + + break; + + /* closeLogicalChannelAck */ + case 7: + invokeStartElement (pctxt, "closeLogicalChannelAck", -1); + + pvalue->u.closeLogicalChannelAck = ALLOC_ASN1ELEM (pctxt, H245CloseLogicalChannelAck); + + stat = asn1PD_H245CloseLogicalChannelAck (pctxt, pvalue->u.closeLogicalChannelAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "closeLogicalChannelAck", -1); + + break; + + /* requestChannelCloseAck */ + case 8: + invokeStartElement (pctxt, "requestChannelCloseAck", -1); + + pvalue->u.requestChannelCloseAck = ALLOC_ASN1ELEM (pctxt, H245RequestChannelCloseAck); + + stat = asn1PD_H245RequestChannelCloseAck (pctxt, pvalue->u.requestChannelCloseAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestChannelCloseAck", -1); + + break; + + /* requestChannelCloseReject */ + case 9: + invokeStartElement (pctxt, "requestChannelCloseReject", -1); + + pvalue->u.requestChannelCloseReject = ALLOC_ASN1ELEM (pctxt, H245RequestChannelCloseReject); + + stat = asn1PD_H245RequestChannelCloseReject (pctxt, pvalue->u.requestChannelCloseReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestChannelCloseReject", -1); + + break; + + /* multiplexEntrySendAck */ + case 10: + invokeStartElement (pctxt, "multiplexEntrySendAck", -1); + + pvalue->u.multiplexEntrySendAck = ALLOC_ASN1ELEM (pctxt, H245MultiplexEntrySendAck); + + stat = asn1PD_H245MultiplexEntrySendAck (pctxt, pvalue->u.multiplexEntrySendAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexEntrySendAck", -1); + + break; + + /* multiplexEntrySendReject */ + case 11: + invokeStartElement (pctxt, "multiplexEntrySendReject", -1); + + pvalue->u.multiplexEntrySendReject = ALLOC_ASN1ELEM (pctxt, H245MultiplexEntrySendReject); + + stat = asn1PD_H245MultiplexEntrySendReject (pctxt, pvalue->u.multiplexEntrySendReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexEntrySendReject", -1); + + break; + + /* requestMultiplexEntryAck */ + case 12: + invokeStartElement (pctxt, "requestMultiplexEntryAck", -1); + + pvalue->u.requestMultiplexEntryAck = ALLOC_ASN1ELEM (pctxt, H245RequestMultiplexEntryAck); + + stat = asn1PD_H245RequestMultiplexEntryAck (pctxt, pvalue->u.requestMultiplexEntryAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestMultiplexEntryAck", -1); + + break; + + /* requestMultiplexEntryReject */ + case 13: + invokeStartElement (pctxt, "requestMultiplexEntryReject", -1); + + pvalue->u.requestMultiplexEntryReject = ALLOC_ASN1ELEM (pctxt, H245RequestMultiplexEntryReject); + + stat = asn1PD_H245RequestMultiplexEntryReject (pctxt, pvalue->u.requestMultiplexEntryReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestMultiplexEntryReject", -1); + + break; + + /* requestModeAck */ + case 14: + invokeStartElement (pctxt, "requestModeAck", -1); + + pvalue->u.requestModeAck = ALLOC_ASN1ELEM (pctxt, H245RequestModeAck); + + stat = asn1PD_H245RequestModeAck (pctxt, pvalue->u.requestModeAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestModeAck", -1); + + break; + + /* requestModeReject */ + case 15: + invokeStartElement (pctxt, "requestModeReject", -1); + + pvalue->u.requestModeReject = ALLOC_ASN1ELEM (pctxt, H245RequestModeReject); + + stat = asn1PD_H245RequestModeReject (pctxt, pvalue->u.requestModeReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestModeReject", -1); + + break; + + /* roundTripDelayResponse */ + case 16: + invokeStartElement (pctxt, "roundTripDelayResponse", -1); + + pvalue->u.roundTripDelayResponse = ALLOC_ASN1ELEM (pctxt, H245RoundTripDelayResponse); + + stat = asn1PD_H245RoundTripDelayResponse (pctxt, pvalue->u.roundTripDelayResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "roundTripDelayResponse", -1); + + break; + + /* maintenanceLoopAck */ + case 17: + invokeStartElement (pctxt, "maintenanceLoopAck", -1); + + pvalue->u.maintenanceLoopAck = ALLOC_ASN1ELEM (pctxt, H245MaintenanceLoopAck); + + stat = asn1PD_H245MaintenanceLoopAck (pctxt, pvalue->u.maintenanceLoopAck); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "maintenanceLoopAck", -1); + + break; + + /* maintenanceLoopReject */ + case 18: + invokeStartElement (pctxt, "maintenanceLoopReject", -1); + + pvalue->u.maintenanceLoopReject = ALLOC_ASN1ELEM (pctxt, H245MaintenanceLoopReject); + + stat = asn1PD_H245MaintenanceLoopReject (pctxt, pvalue->u.maintenanceLoopReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "maintenanceLoopReject", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 20; + + 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) { + /* communicationModeResponse */ + case 20: + invokeStartElement (pctxt, "communicationModeResponse", -1); + + pvalue->u.communicationModeResponse = ALLOC_ASN1ELEM (pctxt, H245CommunicationModeResponse); + + stat = asn1PD_H245CommunicationModeResponse (pctxt, pvalue->u.communicationModeResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "communicationModeResponse", -1); + + break; + + /* conferenceResponse */ + case 21: + invokeStartElement (pctxt, "conferenceResponse", -1); + + pvalue->u.conferenceResponse = ALLOC_ASN1ELEM (pctxt, H245ConferenceResponse); + + stat = asn1PD_H245ConferenceResponse (pctxt, pvalue->u.conferenceResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "conferenceResponse", -1); + + break; + + /* multilinkResponse */ + case 22: + invokeStartElement (pctxt, "multilinkResponse", -1); + + pvalue->u.multilinkResponse = ALLOC_ASN1ELEM (pctxt, H245MultilinkResponse); + + stat = asn1PD_H245MultilinkResponse (pctxt, pvalue->u.multilinkResponse); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multilinkResponse", -1); + + break; + + /* logicalChannelRateAcknowledge */ + case 23: + invokeStartElement (pctxt, "logicalChannelRateAcknowledge", -1); + + pvalue->u.logicalChannelRateAcknowledge = ALLOC_ASN1ELEM (pctxt, H245LogicalChannelRateAcknowledge); + + stat = asn1PD_H245LogicalChannelRateAcknowledge (pctxt, pvalue->u.logicalChannelRateAcknowledge); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelRateAcknowledge", -1); + + break; + + /* logicalChannelRateReject */ + case 24: + invokeStartElement (pctxt, "logicalChannelRateReject", -1); + + pvalue->u.logicalChannelRateReject = ALLOC_ASN1ELEM (pctxt, H245LogicalChannelRateReject); + + stat = asn1PD_H245LogicalChannelRateReject (pctxt, pvalue->u.logicalChannelRateReject); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelRateReject", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopOffCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MaintenanceLoopOffCommand (OOCTXT* pctxt, H245MaintenanceLoopOffCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + 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); +} + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest_capabilityTabl */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + ALLOC_ASN1ARRAY (pctxt, pvalue, H245CapabilityTableEntryNumber); + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245CapabilityTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest_capabilityDesc */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245CapabilityDescriptorNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245SendTerminalCapabilitySet_specificRequest (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.capabilityTableEntryNumbersPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.capabilityDescriptorNumbersPresent = optbit; + + /* decode multiplexCapability */ + + invokeStartElement (pctxt, "multiplexCapability", -1); + + stat = DECODEBIT (pctxt, &pvalue->multiplexCapability); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->multiplexCapability); + + invokeEndElement (pctxt, "multiplexCapability", -1); + + /* decode capabilityTableEntryNumbers */ + + if (pvalue->m.capabilityTableEntryNumbersPresent) { + invokeStartElement (pctxt, "capabilityTableEntryNumbers", -1); + + stat = asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (pctxt, &pvalue->capabilityTableEntryNumbers); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilityTableEntryNumbers", -1); + } + + /* decode capabilityDescriptorNumbers */ + + if (pvalue->m.capabilityDescriptorNumbersPresent) { + invokeStartElement (pctxt, "capabilityDescriptorNumbers", -1); + + stat = asn1PD_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (pctxt, &pvalue->capabilityDescriptorNumbers); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "capabilityDescriptorNumbers", -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); +} + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245SendTerminalCapabilitySet (OOCTXT* pctxt, H245SendTerminalCapabilitySet* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* specificRequest */ + case 0: + invokeStartElement (pctxt, "specificRequest", -1); + + pvalue->u.specificRequest = ALLOC_ASN1ELEM (pctxt, H245SendTerminalCapabilitySet_specificRequest); + + stat = asn1PD_H245SendTerminalCapabilitySet_specificRequest (pctxt, pvalue->u.specificRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "specificRequest", -1); + + break; + + /* genericRequest */ + case 1: + invokeStartElement (pctxt, "genericRequest", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "genericRequest", -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); +} + +/**************************************************************/ +/* */ +/* EncryptionCommand_encryptionAlgorithmID */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EncryptionCommand_encryptionAlgorithmID (OOCTXT* pctxt, H245EncryptionCommand_encryptionAlgorithmID* pvalue) +{ + int stat = ASN_OK; + + /* decode h233AlgorithmIdentifier */ + + invokeStartElement (pctxt, "h233AlgorithmIdentifier", -1); + + stat = asn1PD_H245SequenceNumber (pctxt, &pvalue->h233AlgorithmIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h233AlgorithmIdentifier", -1); + + /* decode associatedAlgorithm */ + + invokeStartElement (pctxt, "associatedAlgorithm", -1); + + stat = asn1PD_H245NonStandardParameter (pctxt, &pvalue->associatedAlgorithm); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "associatedAlgorithm", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EncryptionCommand (OOCTXT* pctxt, H245EncryptionCommand* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* encryptionSE */ + case 0: + invokeStartElement (pctxt, "encryptionSE", -1); + + pvalue->u.encryptionSE = ALLOC_ASN1ELEM (pctxt, ASN1DynOctStr); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)pvalue->u.encryptionSE); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->u.encryptionSE->numocts, pvalue->u.encryptionSE->data); + + invokeEndElement (pctxt, "encryptionSE", -1); + + break; + + /* encryptionIVRequest */ + case 1: + invokeStartElement (pctxt, "encryptionIVRequest", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "encryptionIVRequest", -1); + + break; + + /* encryptionAlgorithmID */ + case 2: + invokeStartElement (pctxt, "encryptionAlgorithmID", -1); + + pvalue->u.encryptionAlgorithmID = ALLOC_ASN1ELEM (pctxt, H245EncryptionCommand_encryptionAlgorithmID); + + stat = asn1PD_H245EncryptionCommand_encryptionAlgorithmID (pctxt, pvalue->u.encryptionAlgorithmID); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionAlgorithmID", -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); +} + +/**************************************************************/ +/* */ +/* FlowControlCommand_scope */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FlowControlCommand_scope (OOCTXT* pctxt, H245FlowControlCommand_scope* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 2); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* logicalChannelNumber */ + case 0: + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + break; + + /* resourceID */ + case 1: + invokeStartElement (pctxt, "resourceID", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.resourceID); + + invokeEndElement (pctxt, "resourceID", -1); + + break; + + /* wholeMultiplex */ + case 2: + invokeStartElement (pctxt, "wholeMultiplex", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "wholeMultiplex", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlCommand_restriction */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FlowControlCommand_restriction (OOCTXT* pctxt, H245FlowControlCommand_restriction* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* maximumBitRate */ + case 0: + invokeStartElement (pctxt, "maximumBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->u.maximumBitRate, 0U, 16777215U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.maximumBitRate); + + invokeEndElement (pctxt, "maximumBitRate", -1); + + break; + + /* noRestriction */ + case 1: + invokeStartElement (pctxt, "noRestriction", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noRestriction", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FlowControlCommand (OOCTXT* pctxt, H245FlowControlCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode scope */ + + invokeStartElement (pctxt, "scope", -1); + + stat = asn1PD_H245FlowControlCommand_scope (pctxt, &pvalue->scope); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "scope", -1); + + /* decode restriction */ + + invokeStartElement (pctxt, "restriction", -1); + + stat = asn1PD_H245FlowControlCommand_restriction (pctxt, &pvalue->restriction); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "restriction", -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); +} + +/**************************************************************/ +/* */ +/* EndSessionCommand_gstnOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EndSessionCommand_gstnOptions (OOCTXT* pctxt, H245EndSessionCommand_gstnOptions* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* telephonyMode */ + case 0: + invokeStartElement (pctxt, "telephonyMode", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "telephonyMode", -1); + + break; + + /* v8bis */ + case 1: + invokeStartElement (pctxt, "v8bis", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "v8bis", -1); + + break; + + /* v34DSVD */ + case 2: + invokeStartElement (pctxt, "v34DSVD", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "v34DSVD", -1); + + break; + + /* v34DuplexFAX */ + case 3: + invokeStartElement (pctxt, "v34DuplexFAX", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "v34DuplexFAX", -1); + + break; + + /* v34H324 */ + case 4: + invokeStartElement (pctxt, "v34H324", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "v34H324", -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); +} + +/**************************************************************/ +/* */ +/* EndSessionCommand_isdnOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EndSessionCommand_isdnOptions (OOCTXT* pctxt, H245EndSessionCommand_isdnOptions* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* telephonyMode */ + case 0: + invokeStartElement (pctxt, "telephonyMode", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "telephonyMode", -1); + + break; + + /* v140 */ + case 1: + invokeStartElement (pctxt, "v140", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "v140", -1); + + break; + + /* terminalOnHold */ + case 2: + invokeStartElement (pctxt, "terminalOnHold", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "terminalOnHold", -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); +} + +/**************************************************************/ +/* */ +/* EndSessionCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EndSessionCommand (OOCTXT* pctxt, H245EndSessionCommand* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* disconnect */ + case 1: + invokeStartElement (pctxt, "disconnect", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "disconnect", -1); + + break; + + /* gstnOptions */ + case 2: + invokeStartElement (pctxt, "gstnOptions", -1); + + pvalue->u.gstnOptions = ALLOC_ASN1ELEM (pctxt, H245EndSessionCommand_gstnOptions); + + stat = asn1PD_H245EndSessionCommand_gstnOptions (pctxt, pvalue->u.gstnOptions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "gstnOptions", -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) { + /* isdnOptions */ + case 4: + invokeStartElement (pctxt, "isdnOptions", -1); + + pvalue->u.isdnOptions = ALLOC_ASN1ELEM (pctxt, H245EndSessionCommand_isdnOptions); + + stat = asn1PD_H245EndSessionCommand_isdnOptions (pctxt, pvalue->u.isdnOptions); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "isdnOptions", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoFastUpdateGOB */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousCommand_type_videoFastUpdateGOB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB* pvalue) +{ + int stat = ASN_OK; + + /* decode firstGOB */ + + invokeStartElement (pctxt, "firstGOB", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->firstGOB, 0U, 17U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->firstGOB); + + invokeEndElement (pctxt, "firstGOB", -1); + + /* decode numberOfGOBs */ + + invokeStartElement (pctxt, "numberOfGOBs", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->numberOfGOBs, 1U, 18U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfGOBs); + + invokeEndElement (pctxt, "numberOfGOBs", -1); + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoFastUpdateMB */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousCommand_type_videoFastUpdateMB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.firstGOBPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.firstMBPresent = optbit; + + /* decode firstGOB */ + + if (pvalue->m.firstGOBPresent) { + invokeStartElement (pctxt, "firstGOB", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->firstGOB, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->firstGOB); + + invokeEndElement (pctxt, "firstGOB", -1); + } + + /* decode firstMB */ + + if (pvalue->m.firstMBPresent) { + invokeStartElement (pctxt, "firstMB", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->firstMB, 1U, 8192U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->firstMB); + + invokeEndElement (pctxt, "firstMB", -1); + } + + /* decode numberOfMBs */ + + invokeStartElement (pctxt, "numberOfMBs", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->numberOfMBs, 1U, 8192U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfMBs); + + invokeEndElement (pctxt, "numberOfMBs", -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); +} + +/**************************************************************/ +/* */ +/* KeyProtectionMethod */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245KeyProtectionMethod (OOCTXT* pctxt, H245KeyProtectionMethod* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode secureChannel */ + + invokeStartElement (pctxt, "secureChannel", -1); + + stat = DECODEBIT (pctxt, &pvalue->secureChannel); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->secureChannel); + + invokeEndElement (pctxt, "secureChannel", -1); + + /* decode sharedSecret */ + + invokeStartElement (pctxt, "sharedSecret", -1); + + stat = DECODEBIT (pctxt, &pvalue->sharedSecret); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->sharedSecret); + + invokeEndElement (pctxt, "sharedSecret", -1); + + /* decode certProtectedKey */ + + invokeStartElement (pctxt, "certProtectedKey", -1); + + stat = DECODEBIT (pctxt, &pvalue->certProtectedKey); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->certProtectedKey); + + invokeEndElement (pctxt, "certProtectedKey", -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); +} + +/**************************************************************/ +/* */ +/* EncryptionUpdateRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245EncryptionUpdateRequest (OOCTXT* pctxt, H245EncryptionUpdateRequest* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.keyProtectionMethodPresent = optbit; + + /* decode keyProtectionMethod */ + + if (pvalue->m.keyProtectionMethodPresent) { + invokeStartElement (pctxt, "keyProtectionMethod", -1); + + stat = asn1PD_H245KeyProtectionMethod (pctxt, &pvalue->keyProtectionMethod); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "keyProtectionMethod", -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); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_progressiveRefinementStart_rep */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* doOneProgression */ + case 0: + invokeStartElement (pctxt, "doOneProgression", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "doOneProgression", -1); + + break; + + /* doContinuousProgressions */ + case 1: + invokeStartElement (pctxt, "doContinuousProgressions", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "doContinuousProgressions", -1); + + break; + + /* doOneIndependentProgression */ + case 2: + invokeStartElement (pctxt, "doOneIndependentProgression", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "doOneIndependentProgression", -1); + + break; + + /* doContinuousIndependentProgressions */ + case 3: + invokeStartElement (pctxt, "doContinuousIndependentProgressions", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "doContinuousIndependentProgressions", -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); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_progressiveRefinementStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode repeatCount */ + + invokeStartElement (pctxt, "repeatCount", -1); + + stat = asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (pctxt, &pvalue->repeatCount); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "repeatCount", -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); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoBadMBs */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousCommand_type_videoBadMBs (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoBadMBs* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode firstMB */ + + invokeStartElement (pctxt, "firstMB", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->firstMB, 1U, 9216U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->firstMB); + + invokeEndElement (pctxt, "firstMB", -1); + + /* decode numberOfMBs */ + + invokeStartElement (pctxt, "numberOfMBs", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->numberOfMBs, 1U, 9216U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfMBs); + + invokeEndElement (pctxt, "numberOfMBs", -1); + + /* decode temporalReference */ + + invokeStartElement (pctxt, "temporalReference", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->temporalReference, 0U, 1023U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->temporalReference); + + invokeEndElement (pctxt, "temporalReference", -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); +} + +/**************************************************************/ +/* */ +/* PictureReference */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245PictureReference (OOCTXT* pctxt, H245PictureReference* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* pictureNumber */ + case 0: + invokeStartElement (pctxt, "pictureNumber", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.pictureNumber, 0U, 1023U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.pictureNumber); + + invokeEndElement (pctxt, "pictureNumber", -1); + + break; + + /* longTermPictureIndex */ + case 1: + invokeStartElement (pctxt, "longTermPictureIndex", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->u.longTermPictureIndex, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.longTermPictureIndex); + + invokeEndElement (pctxt, "longTermPictureIndex", -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); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245PictureReference */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245_SeqOfH245PictureReference (OOCTXT* pctxt, H245_SeqOfH245PictureReference* pvalue) +{ + int stat = ASN_OK; + H245PictureReference* 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, H245PictureReference); + + stat = asn1PD_H245PictureReference (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + if(lstat == ASN_OK) break; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_lostPartialPicture */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousCommand_type_lostPartialPicture (OOCTXT* pctxt, H245MiscellaneousCommand_type_lostPartialPicture* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode pictureReference */ + + invokeStartElement (pctxt, "pictureReference", -1); + + stat = asn1PD_H245PictureReference (pctxt, &pvalue->pictureReference); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "pictureReference", -1); + + /* decode firstMB */ + + invokeStartElement (pctxt, "firstMB", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->firstMB, 1U, 9216U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->firstMB); + + invokeEndElement (pctxt, "firstMB", -1); + + /* decode numberOfMBs */ + + invokeStartElement (pctxt, "numberOfMBs", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->numberOfMBs, 1U, 9216U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfMBs); + + invokeEndElement (pctxt, "numberOfMBs", -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); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousCommand_type (OOCTXT* pctxt, H245MiscellaneousCommand_type* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 9); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* equaliseDelay */ + case 0: + invokeStartElement (pctxt, "equaliseDelay", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "equaliseDelay", -1); + + break; + + /* zeroDelay */ + case 1: + invokeStartElement (pctxt, "zeroDelay", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "zeroDelay", -1); + + break; + + /* multipointModeCommand */ + case 2: + invokeStartElement (pctxt, "multipointModeCommand", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "multipointModeCommand", -1); + + break; + + /* cancelMultipointModeCommand */ + case 3: + invokeStartElement (pctxt, "cancelMultipointModeCommand", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelMultipointModeCommand", -1); + + break; + + /* videoFreezePicture */ + case 4: + invokeStartElement (pctxt, "videoFreezePicture", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "videoFreezePicture", -1); + + break; + + /* videoFastUpdatePicture */ + case 5: + invokeStartElement (pctxt, "videoFastUpdatePicture", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "videoFastUpdatePicture", -1); + + break; + + /* videoFastUpdateGOB */ + case 6: + invokeStartElement (pctxt, "videoFastUpdateGOB", -1); + + pvalue->u.videoFastUpdateGOB = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB); + + stat = asn1PD_H245MiscellaneousCommand_type_videoFastUpdateGOB (pctxt, pvalue->u.videoFastUpdateGOB); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoFastUpdateGOB", -1); + + break; + + /* videoTemporalSpatialTradeOff */ + case 7: + invokeStartElement (pctxt, "videoTemporalSpatialTradeOff", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->u.videoTemporalSpatialTradeOff, 0U, 31U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.videoTemporalSpatialTradeOff); + + invokeEndElement (pctxt, "videoTemporalSpatialTradeOff", -1); + + break; + + /* videoSendSyncEveryGOB */ + case 8: + invokeStartElement (pctxt, "videoSendSyncEveryGOB", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "videoSendSyncEveryGOB", -1); + + break; + + /* videoSendSyncEveryGOBCancel */ + case 9: + invokeStartElement (pctxt, "videoSendSyncEveryGOBCancel", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "videoSendSyncEveryGOBCancel", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 11; + + 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) { + /* videoFastUpdateMB */ + case 11: + invokeStartElement (pctxt, "videoFastUpdateMB", -1); + + pvalue->u.videoFastUpdateMB = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB); + + stat = asn1PD_H245MiscellaneousCommand_type_videoFastUpdateMB (pctxt, pvalue->u.videoFastUpdateMB); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoFastUpdateMB", -1); + + break; + + /* maxH223MUXPDUsize */ + case 12: + invokeStartElement (pctxt, "maxH223MUXPDUsize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.maxH223MUXPDUsize, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.maxH223MUXPDUsize); + + invokeEndElement (pctxt, "maxH223MUXPDUsize", -1); + + break; + + /* encryptionUpdate */ + case 13: + invokeStartElement (pctxt, "encryptionUpdate", -1); + + pvalue->u.encryptionUpdate = ALLOC_ASN1ELEM (pctxt, H245EncryptionSync); + + stat = asn1PD_H245EncryptionSync (pctxt, pvalue->u.encryptionUpdate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionUpdate", -1); + + break; + + /* encryptionUpdateRequest */ + case 14: + invokeStartElement (pctxt, "encryptionUpdateRequest", -1); + + pvalue->u.encryptionUpdateRequest = ALLOC_ASN1ELEM (pctxt, H245EncryptionUpdateRequest); + + stat = asn1PD_H245EncryptionUpdateRequest (pctxt, pvalue->u.encryptionUpdateRequest); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionUpdateRequest", -1); + + break; + + /* switchReceiveMediaOff */ + case 15: + invokeStartElement (pctxt, "switchReceiveMediaOff", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "switchReceiveMediaOff", -1); + + break; + + /* switchReceiveMediaOn */ + case 16: + invokeStartElement (pctxt, "switchReceiveMediaOn", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "switchReceiveMediaOn", -1); + + break; + + /* progressiveRefinementStart */ + case 17: + invokeStartElement (pctxt, "progressiveRefinementStart", -1); + + pvalue->u.progressiveRefinementStart = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart); + + stat = asn1PD_H245MiscellaneousCommand_type_progressiveRefinementStart (pctxt, pvalue->u.progressiveRefinementStart); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "progressiveRefinementStart", -1); + + break; + + /* progressiveRefinementAbortOne */ + case 18: + invokeStartElement (pctxt, "progressiveRefinementAbortOne", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "progressiveRefinementAbortOne", -1); + + break; + + /* progressiveRefinementAbortContinuous */ + case 19: + invokeStartElement (pctxt, "progressiveRefinementAbortContinuous", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "progressiveRefinementAbortContinuous", -1); + + break; + + /* videoBadMBs */ + case 20: + invokeStartElement (pctxt, "videoBadMBs", -1); + + pvalue->u.videoBadMBs = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_videoBadMBs); + + stat = asn1PD_H245MiscellaneousCommand_type_videoBadMBs (pctxt, pvalue->u.videoBadMBs); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoBadMBs", -1); + + break; + + /* lostPicture */ + case 21: + invokeStartElement (pctxt, "lostPicture", -1); + + pvalue->u.lostPicture = ALLOC_ASN1ELEM (pctxt, H245_SeqOfH245PictureReference); + + stat = asn1PD_H245_SeqOfH245PictureReference (pctxt, pvalue->u.lostPicture); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "lostPicture", -1); + + break; + + /* lostPartialPicture */ + case 22: + invokeStartElement (pctxt, "lostPartialPicture", -1); + + pvalue->u.lostPartialPicture = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand_type_lostPartialPicture); + + stat = asn1PD_H245MiscellaneousCommand_type_lostPartialPicture (pctxt, pvalue->u.lostPartialPicture); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "lostPartialPicture", -1); + + break; + + /* recoveryReferencePicture */ + case 23: + invokeStartElement (pctxt, "recoveryReferencePicture", -1); + + pvalue->u.recoveryReferencePicture = ALLOC_ASN1ELEM (pctxt, H245_SeqOfH245PictureReference); + + stat = asn1PD_H245_SeqOfH245PictureReference (pctxt, pvalue->u.recoveryReferencePicture); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "recoveryReferencePicture", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousCommand (OOCTXT* pctxt, H245MiscellaneousCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode logicalChannelNumber */ + + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245MiscellaneousCommand_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* CommunicationModeCommand_communicationModeTable */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CommunicationModeCommand_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeCommand_communicationModeTable* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + H245CommunicationModeTableEntry* 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, H245CommunicationModeTableEntry); + + stat = asn1PD_H245CommunicationModeTableEntry (pctxt, pdata); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + dListAppendNode (pctxt, pvalue, pdata); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CommunicationModeCommand (OOCTXT* pctxt, H245CommunicationModeCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode communicationModeTable */ + + invokeStartElement (pctxt, "communicationModeTable", -1); + + stat = asn1PD_H245CommunicationModeCommand_communicationModeTable (pctxt, &pvalue->communicationModeTable); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "communicationModeTable", -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); +} + +/**************************************************************/ +/* */ +/* SubstituteConferenceIDCommand_conferenceIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245SubstituteConferenceIDCommand_conferenceIdentifier (OOCTXT* pctxt, H245SubstituteConferenceIDCommand_conferenceIdentifier* 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); +} + +/**************************************************************/ +/* */ +/* SubstituteConferenceIDCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245SubstituteConferenceIDCommand (OOCTXT* pctxt, H245SubstituteConferenceIDCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode conferenceIdentifier */ + + invokeStartElement (pctxt, "conferenceIdentifier", -1); + + stat = asn1PD_H245SubstituteConferenceIDCommand_conferenceIdentifier (pctxt, &pvalue->conferenceIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "conferenceIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceCommand (OOCTXT* pctxt, H245ConferenceCommand* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* broadcastMyLogicalChannel */ + case 0: + invokeStartElement (pctxt, "broadcastMyLogicalChannel", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.broadcastMyLogicalChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "broadcastMyLogicalChannel", -1); + + break; + + /* cancelBroadcastMyLogicalChannel */ + case 1: + invokeStartElement (pctxt, "cancelBroadcastMyLogicalChannel", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.cancelBroadcastMyLogicalChannel); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cancelBroadcastMyLogicalChannel", -1); + + break; + + /* makeTerminalBroadcaster */ + case 2: + invokeStartElement (pctxt, "makeTerminalBroadcaster", -1); + + pvalue->u.makeTerminalBroadcaster = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.makeTerminalBroadcaster); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "makeTerminalBroadcaster", -1); + + break; + + /* cancelMakeTerminalBroadcaster */ + case 3: + invokeStartElement (pctxt, "cancelMakeTerminalBroadcaster", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelMakeTerminalBroadcaster", -1); + + break; + + /* sendThisSource */ + case 4: + invokeStartElement (pctxt, "sendThisSource", -1); + + pvalue->u.sendThisSource = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.sendThisSource); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sendThisSource", -1); + + break; + + /* cancelSendThisSource */ + case 5: + invokeStartElement (pctxt, "cancelSendThisSource", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelSendThisSource", -1); + + break; + + /* dropConference */ + case 6: + invokeStartElement (pctxt, "dropConference", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "dropConference", -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) { + /* substituteConferenceIDCommand */ + case 8: + invokeStartElement (pctxt, "substituteConferenceIDCommand", -1); + + pvalue->u.substituteConferenceIDCommand = ALLOC_ASN1ELEM (pctxt, H245SubstituteConferenceIDCommand); + + stat = asn1PD_H245SubstituteConferenceIDCommand (pctxt, pvalue->u.substituteConferenceIDCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "substituteConferenceIDCommand", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration_h223ModeChange */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223MultiplexReconfiguration_h223ModeChange (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223ModeChange* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* toLevel0 */ + case 0: + invokeStartElement (pctxt, "toLevel0", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "toLevel0", -1); + + break; + + /* toLevel1 */ + case 1: + invokeStartElement (pctxt, "toLevel1", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "toLevel1", -1); + + break; + + /* toLevel2 */ + case 2: + invokeStartElement (pctxt, "toLevel2", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "toLevel2", -1); + + break; + + /* toLevel2withOptionalHeader */ + case 3: + invokeStartElement (pctxt, "toLevel2withOptionalHeader", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "toLevel2withOptionalHeader", -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); +} + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration_h223AnnexADoubleFlag */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* start */ + case 0: + invokeStartElement (pctxt, "start", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "start", -1); + + break; + + /* stop */ + case 1: + invokeStartElement (pctxt, "stop", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "stop", -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); +} + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223MultiplexReconfiguration (OOCTXT* pctxt, H245H223MultiplexReconfiguration* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* h223ModeChange */ + case 0: + invokeStartElement (pctxt, "h223ModeChange", -1); + + pvalue->u.h223ModeChange = ALLOC_ASN1ELEM (pctxt, H245H223MultiplexReconfiguration_h223ModeChange); + + stat = asn1PD_H245H223MultiplexReconfiguration_h223ModeChange (pctxt, pvalue->u.h223ModeChange); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223ModeChange", -1); + + break; + + /* h223AnnexADoubleFlag */ + case 1: + invokeStartElement (pctxt, "h223AnnexADoubleFlag", -1); + + pvalue->u.h223AnnexADoubleFlag = ALLOC_ASN1ELEM (pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag); + + stat = asn1PD_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (pctxt, pvalue->u.h223AnnexADoubleFlag); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223AnnexADoubleFlag", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1_clockRecovery */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_clockRecovery* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* nullClockRecovery */ + case 0: + invokeStartElement (pctxt, "nullClockRecovery", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "nullClockRecovery", -1); + + break; + + /* srtsClockRecovery */ + case 1: + invokeStartElement (pctxt, "srtsClockRecovery", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "srtsClockRecovery", -1); + + break; + + /* adaptiveClockRecovery */ + case 2: + invokeStartElement (pctxt, "adaptiveClockRecovery", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "adaptiveClockRecovery", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1_errorCorrection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_errorCorrection* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* nullErrorCorrection */ + case 0: + invokeStartElement (pctxt, "nullErrorCorrection", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "nullErrorCorrection", -1); + + break; + + /* longInterleaver */ + case 1: + invokeStartElement (pctxt, "longInterleaver", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "longInterleaver", -1); + + break; + + /* shortInterleaver */ + case 2: + invokeStartElement (pctxt, "shortInterleaver", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "shortInterleaver", -1); + + break; + + /* errorCorrectionOnly */ + case 3: + invokeStartElement (pctxt, "errorCorrectionOnly", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "errorCorrectionOnly", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand_aal_aal1 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode clockRecovery */ + + invokeStartElement (pctxt, "clockRecovery", -1); + + stat = asn1PD_H245NewATMVCCommand_aal_aal1_clockRecovery (pctxt, &pvalue->clockRecovery); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "clockRecovery", -1); + + /* decode errorCorrection */ + + invokeStartElement (pctxt, "errorCorrection", -1); + + stat = asn1PD_H245NewATMVCCommand_aal_aal1_errorCorrection (pctxt, &pvalue->errorCorrection); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "errorCorrection", -1); + + /* decode structuredDataTransfer */ + + invokeStartElement (pctxt, "structuredDataTransfer", -1); + + stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->structuredDataTransfer); + + invokeEndElement (pctxt, "structuredDataTransfer", -1); + + /* decode partiallyFilledCells */ + + invokeStartElement (pctxt, "partiallyFilledCells", -1); + + stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->partiallyFilledCells); + + invokeEndElement (pctxt, "partiallyFilledCells", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal5 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand_aal_aal5 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal5* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardMaximumSDUSize */ + + invokeStartElement (pctxt, "forwardMaximumSDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->forwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->forwardMaximumSDUSize); + + invokeEndElement (pctxt, "forwardMaximumSDUSize", -1); + + /* decode backwardMaximumSDUSize */ + + invokeStartElement (pctxt, "backwardMaximumSDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->backwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->backwardMaximumSDUSize); + + invokeEndElement (pctxt, "backwardMaximumSDUSize", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand_aal (OOCTXT* pctxt, H245NewATMVCCommand_aal* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* aal1 */ + case 0: + invokeStartElement (pctxt, "aal1", -1); + + pvalue->u.aal1 = ALLOC_ASN1ELEM (pctxt, H245NewATMVCCommand_aal_aal1); + + stat = asn1PD_H245NewATMVCCommand_aal_aal1 (pctxt, pvalue->u.aal1); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal1", -1); + + break; + + /* aal5 */ + case 1: + invokeStartElement (pctxt, "aal5", -1); + + pvalue->u.aal5 = ALLOC_ASN1ELEM (pctxt, H245NewATMVCCommand_aal_aal5); + + stat = asn1PD_H245NewATMVCCommand_aal_aal5 (pctxt, pvalue->u.aal5); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal5", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_multiplex */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_multiplex* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* noMultiplex */ + case 0: + invokeStartElement (pctxt, "noMultiplex", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noMultiplex", -1); + + break; + + /* transportStream */ + case 1: + invokeStartElement (pctxt, "transportStream", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "transportStream", -1); + + break; + + /* programStream */ + case 2: + invokeStartElement (pctxt, "programStream", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "programStream", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_reverseParameters_multiplex */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters_multiplex* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* noMultiplex */ + case 0: + invokeStartElement (pctxt, "noMultiplex", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noMultiplex", -1); + + break; + + /* transportStream */ + case 1: + invokeStartElement (pctxt, "transportStream", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "transportStream", -1); + + break; + + /* programStream */ + case 2: + invokeStartElement (pctxt, "programStream", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "programStream", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_reverseParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand_reverseParameters (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -1); + + /* decode bitRateLockedToPCRClock */ + + invokeStartElement (pctxt, "bitRateLockedToPCRClock", -1); + + stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToPCRClock); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->bitRateLockedToPCRClock); + + invokeEndElement (pctxt, "bitRateLockedToPCRClock", -1); + + /* decode bitRateLockedToNetworkClock */ + + invokeStartElement (pctxt, "bitRateLockedToNetworkClock", -1); + + stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToNetworkClock); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->bitRateLockedToNetworkClock); + + invokeEndElement (pctxt, "bitRateLockedToNetworkClock", -1); + + /* decode multiplex */ + + invokeStartElement (pctxt, "multiplex", -1); + + stat = asn1PD_H245NewATMVCCommand_reverseParameters_multiplex (pctxt, &pvalue->multiplex); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplex", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCCommand (OOCTXT* pctxt, H245NewATMVCCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode resourceID */ + + invokeStartElement (pctxt, "resourceID", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->resourceID); + + invokeEndElement (pctxt, "resourceID", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -1); + + /* decode bitRateLockedToPCRClock */ + + invokeStartElement (pctxt, "bitRateLockedToPCRClock", -1); + + stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToPCRClock); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->bitRateLockedToPCRClock); + + invokeEndElement (pctxt, "bitRateLockedToPCRClock", -1); + + /* decode bitRateLockedToNetworkClock */ + + invokeStartElement (pctxt, "bitRateLockedToNetworkClock", -1); + + stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToNetworkClock); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->bitRateLockedToNetworkClock); + + invokeEndElement (pctxt, "bitRateLockedToNetworkClock", -1); + + /* decode aal */ + + invokeStartElement (pctxt, "aal", -1); + + stat = asn1PD_H245NewATMVCCommand_aal (pctxt, &pvalue->aal); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal", -1); + + /* decode multiplex */ + + invokeStartElement (pctxt, "multiplex", -1); + + stat = asn1PD_H245NewATMVCCommand_multiplex (pctxt, &pvalue->multiplex); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplex", -1); + + /* decode reverseParameters */ + + invokeStartElement (pctxt, "reverseParameters", -1); + + stat = asn1PD_H245NewATMVCCommand_reverseParameters (pctxt, &pvalue->reverseParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reverseParameters", -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); +} + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationCommand_status */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MobileMultilinkReconfigurationCommand_status (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand_status* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* synchronized_ */ + case 0: + invokeStartElement (pctxt, "synchronized_", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "synchronized_", -1); + + break; + + /* reconfiguration */ + case 1: + invokeStartElement (pctxt, "reconfiguration", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "reconfiguration", -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); +} + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MobileMultilinkReconfigurationCommand (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sampleSize */ + + invokeStartElement (pctxt, "sampleSize", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sampleSize, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sampleSize); + + invokeEndElement (pctxt, "sampleSize", -1); + + /* decode samplesPerFrame */ + + invokeStartElement (pctxt, "samplesPerFrame", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->samplesPerFrame, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->samplesPerFrame); + + invokeEndElement (pctxt, "samplesPerFrame", -1); + + /* decode status */ + + invokeStartElement (pctxt, "status", -1); + + stat = asn1PD_H245MobileMultilinkReconfigurationCommand_status (pctxt, &pvalue->status); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "status", -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); +} + +/**************************************************************/ +/* */ +/* CommandMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245CommandMessage (OOCTXT* pctxt, H245CommandMessage* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* maintenanceLoopOffCommand */ + case 1: + invokeStartElement (pctxt, "maintenanceLoopOffCommand", -1); + + pvalue->u.maintenanceLoopOffCommand = ALLOC_ASN1ELEM (pctxt, H245MaintenanceLoopOffCommand); + + stat = asn1PD_H245MaintenanceLoopOffCommand (pctxt, pvalue->u.maintenanceLoopOffCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "maintenanceLoopOffCommand", -1); + + break; + + /* sendTerminalCapabilitySet */ + case 2: + invokeStartElement (pctxt, "sendTerminalCapabilitySet", -1); + + pvalue->u.sendTerminalCapabilitySet = ALLOC_ASN1ELEM (pctxt, H245SendTerminalCapabilitySet); + + stat = asn1PD_H245SendTerminalCapabilitySet (pctxt, pvalue->u.sendTerminalCapabilitySet); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "sendTerminalCapabilitySet", -1); + + break; + + /* encryptionCommand */ + case 3: + invokeStartElement (pctxt, "encryptionCommand", -1); + + pvalue->u.encryptionCommand = ALLOC_ASN1ELEM (pctxt, H245EncryptionCommand); + + stat = asn1PD_H245EncryptionCommand (pctxt, pvalue->u.encryptionCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "encryptionCommand", -1); + + break; + + /* flowControlCommand */ + case 4: + invokeStartElement (pctxt, "flowControlCommand", -1); + + pvalue->u.flowControlCommand = ALLOC_ASN1ELEM (pctxt, H245FlowControlCommand); + + stat = asn1PD_H245FlowControlCommand (pctxt, pvalue->u.flowControlCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "flowControlCommand", -1); + + break; + + /* endSessionCommand */ + case 5: + invokeStartElement (pctxt, "endSessionCommand", -1); + + pvalue->u.endSessionCommand = ALLOC_ASN1ELEM (pctxt, H245EndSessionCommand); + + stat = asn1PD_H245EndSessionCommand (pctxt, pvalue->u.endSessionCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "endSessionCommand", -1); + + break; + + /* miscellaneousCommand */ + case 6: + invokeStartElement (pctxt, "miscellaneousCommand", -1); + + pvalue->u.miscellaneousCommand = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousCommand); + + stat = asn1PD_H245MiscellaneousCommand (pctxt, pvalue->u.miscellaneousCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "miscellaneousCommand", -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) { + /* communicationModeCommand */ + case 8: + invokeStartElement (pctxt, "communicationModeCommand", -1); + + pvalue->u.communicationModeCommand = ALLOC_ASN1ELEM (pctxt, H245CommunicationModeCommand); + + stat = asn1PD_H245CommunicationModeCommand (pctxt, pvalue->u.communicationModeCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "communicationModeCommand", -1); + + break; + + /* conferenceCommand */ + case 9: + invokeStartElement (pctxt, "conferenceCommand", -1); + + pvalue->u.conferenceCommand = ALLOC_ASN1ELEM (pctxt, H245ConferenceCommand); + + stat = asn1PD_H245ConferenceCommand (pctxt, pvalue->u.conferenceCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "conferenceCommand", -1); + + break; + + /* h223MultiplexReconfiguration */ + case 10: + invokeStartElement (pctxt, "h223MultiplexReconfiguration", -1); + + pvalue->u.h223MultiplexReconfiguration = ALLOC_ASN1ELEM (pctxt, H245H223MultiplexReconfiguration); + + stat = asn1PD_H245H223MultiplexReconfiguration (pctxt, pvalue->u.h223MultiplexReconfiguration); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223MultiplexReconfiguration", -1); + + break; + + /* newATMVCCommand */ + case 11: + invokeStartElement (pctxt, "newATMVCCommand", -1); + + pvalue->u.newATMVCCommand = ALLOC_ASN1ELEM (pctxt, H245NewATMVCCommand); + + stat = asn1PD_H245NewATMVCCommand (pctxt, pvalue->u.newATMVCCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "newATMVCCommand", -1); + + break; + + /* mobileMultilinkReconfigurationCommand */ + case 12: + invokeStartElement (pctxt, "mobileMultilinkReconfigurationCommand", -1); + + pvalue->u.mobileMultilinkReconfigurationCommand = ALLOC_ASN1ELEM (pctxt, H245MobileMultilinkReconfigurationCommand); + + stat = asn1PD_H245MobileMultilinkReconfigurationCommand (pctxt, pvalue->u.mobileMultilinkReconfigurationCommand); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mobileMultilinkReconfigurationCommand", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FunctionNotUnderstood */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FunctionNotUnderstood (OOCTXT* pctxt, H245FunctionNotUnderstood* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 2); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* request */ + case 0: + invokeStartElement (pctxt, "request", -1); + + pvalue->u.request = ALLOC_ASN1ELEM (pctxt, H245RequestMessage); + + stat = asn1PD_H245RequestMessage (pctxt, pvalue->u.request); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "request", -1); + + break; + + /* response */ + case 1: + invokeStartElement (pctxt, "response", -1); + + pvalue->u.response = ALLOC_ASN1ELEM (pctxt, H245ResponseMessage); + + stat = asn1PD_H245ResponseMessage (pctxt, pvalue->u.response); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "response", -1); + + break; + + /* command */ + case 2: + invokeStartElement (pctxt, "command", -1); + + pvalue->u.command = ALLOC_ASN1ELEM (pctxt, H245CommandMessage); + + stat = asn1PD_H245CommandMessage (pctxt, pvalue->u.command); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "command", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MasterSlaveDeterminationRelease (OOCTXT* pctxt, H245MasterSlaveDeterminationRelease* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + 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); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalCapabilitySetRelease (OOCTXT* pctxt, H245TerminalCapabilitySetRelease* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + 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); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245OpenLogicalChannelConfirm (OOCTXT* pctxt, H245OpenLogicalChannelConfirm* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -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); +} + +/**************************************************************/ +/* */ +/* RequestChannelCloseRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestChannelCloseRelease (OOCTXT* pctxt, H245RequestChannelCloseRelease* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardLogicalChannelNumber */ + + invokeStartElement (pctxt, "forwardLogicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "forwardLogicalChannelNumber", -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); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendRelease_multiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendRelease_multiplexTableEntryNumber* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultiplexEntrySendRelease (OOCTXT* pctxt, H245MultiplexEntrySendRelease* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode multiplexTableEntryNumber */ + + invokeStartElement (pctxt, "multiplexTableEntryNumber", -1); + + stat = asn1PD_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexTableEntryNumber", -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); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRelease_entryNumbers */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryRelease_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryRelease_entryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* decode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = decodeLength (pctxt, &pvalue->n); + if (stat != ASN_OK) return stat; + + /* decode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + invokeStartElement (pctxt, "elem", xx1); + + stat = asn1PD_H245MultiplexTableEntryNumber (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + invokeEndElement (pctxt, "elem", xx1); + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestMultiplexEntryRelease (OOCTXT* pctxt, H245RequestMultiplexEntryRelease* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode entryNumbers */ + + invokeStartElement (pctxt, "entryNumbers", -1); + + stat = asn1PD_H245RequestMultiplexEntryRelease_entryNumbers (pctxt, &pvalue->entryNumbers); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "entryNumbers", -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); +} + +/**************************************************************/ +/* */ +/* RequestModeRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245RequestModeRelease (OOCTXT* pctxt, H245RequestModeRelease* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + 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); +} + +/**************************************************************/ +/* */ +/* MiscellaneousIndication_type_videoNotDecodedMBs */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousIndication_type_videoNotDecodedMBs (OOCTXT* pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode firstMB */ + + invokeStartElement (pctxt, "firstMB", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->firstMB, 1U, 8192U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->firstMB); + + invokeEndElement (pctxt, "firstMB", -1); + + /* decode numberOfMBs */ + + invokeStartElement (pctxt, "numberOfMBs", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->numberOfMBs, 1U, 8192U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->numberOfMBs); + + invokeEndElement (pctxt, "numberOfMBs", -1); + + /* decode temporalReference */ + + invokeStartElement (pctxt, "temporalReference", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->temporalReference, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->temporalReference); + + invokeEndElement (pctxt, "temporalReference", -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); +} + +/**************************************************************/ +/* */ +/* MiscellaneousIndication_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousIndication_type (OOCTXT* pctxt, H245MiscellaneousIndication_type* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 9); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* logicalChannelActive */ + case 0: + invokeStartElement (pctxt, "logicalChannelActive", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "logicalChannelActive", -1); + + break; + + /* logicalChannelInactive */ + case 1: + invokeStartElement (pctxt, "logicalChannelInactive", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "logicalChannelInactive", -1); + + break; + + /* multipointConference */ + case 2: + invokeStartElement (pctxt, "multipointConference", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "multipointConference", -1); + + break; + + /* cancelMultipointConference */ + case 3: + invokeStartElement (pctxt, "cancelMultipointConference", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelMultipointConference", -1); + + break; + + /* multipointZeroComm */ + case 4: + invokeStartElement (pctxt, "multipointZeroComm", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "multipointZeroComm", -1); + + break; + + /* cancelMultipointZeroComm */ + case 5: + invokeStartElement (pctxt, "cancelMultipointZeroComm", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelMultipointZeroComm", -1); + + break; + + /* multipointSecondaryStatus */ + case 6: + invokeStartElement (pctxt, "multipointSecondaryStatus", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "multipointSecondaryStatus", -1); + + break; + + /* cancelMultipointSecondaryStatus */ + case 7: + invokeStartElement (pctxt, "cancelMultipointSecondaryStatus", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelMultipointSecondaryStatus", -1); + + break; + + /* videoIndicateReadyToActivate */ + case 8: + invokeStartElement (pctxt, "videoIndicateReadyToActivate", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "videoIndicateReadyToActivate", -1); + + break; + + /* videoTemporalSpatialTradeOff */ + case 9: + invokeStartElement (pctxt, "videoTemporalSpatialTradeOff", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->u.videoTemporalSpatialTradeOff, 0U, 31U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.videoTemporalSpatialTradeOff); + + invokeEndElement (pctxt, "videoTemporalSpatialTradeOff", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 11; + + 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) { + /* videoNotDecodedMBs */ + case 11: + invokeStartElement (pctxt, "videoNotDecodedMBs", -1); + + pvalue->u.videoNotDecodedMBs = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs); + + stat = asn1PD_H245MiscellaneousIndication_type_videoNotDecodedMBs (pctxt, pvalue->u.videoNotDecodedMBs); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoNotDecodedMBs", -1); + + break; + + /* transportCapability */ + case 12: + invokeStartElement (pctxt, "transportCapability", -1); + + pvalue->u.transportCapability = ALLOC_ASN1ELEM (pctxt, H245TransportCapability); + + stat = asn1PD_H245TransportCapability (pctxt, pvalue->u.transportCapability); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "transportCapability", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MiscellaneousIndication (OOCTXT* pctxt, H245MiscellaneousIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode logicalChannelNumber */ + + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + /* decode type */ + + invokeStartElement (pctxt, "type", -1); + + stat = asn1PD_H245MiscellaneousIndication_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "type", -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); +} + +/**************************************************************/ +/* */ +/* JitterIndication_scope */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245JitterIndication_scope (OOCTXT* pctxt, H245JitterIndication_scope* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 2); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* logicalChannelNumber */ + case 0: + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + break; + + /* resourceID */ + case 1: + invokeStartElement (pctxt, "resourceID", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.resourceID); + + invokeEndElement (pctxt, "resourceID", -1); + + break; + + /* wholeMultiplex */ + case 2: + invokeStartElement (pctxt, "wholeMultiplex", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "wholeMultiplex", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* JitterIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245JitterIndication (OOCTXT* pctxt, H245JitterIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.skippedFrameCountPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.additionalDecoderBufferPresent = optbit; + + /* decode scope */ + + invokeStartElement (pctxt, "scope", -1); + + stat = asn1PD_H245JitterIndication_scope (pctxt, &pvalue->scope); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "scope", -1); + + /* decode estimatedReceivedJitterMantissa */ + + invokeStartElement (pctxt, "estimatedReceivedJitterMantissa", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->estimatedReceivedJitterMantissa, 0U, 3U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->estimatedReceivedJitterMantissa); + + invokeEndElement (pctxt, "estimatedReceivedJitterMantissa", -1); + + /* decode estimatedReceivedJitterExponent */ + + invokeStartElement (pctxt, "estimatedReceivedJitterExponent", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->estimatedReceivedJitterExponent, 0U, 7U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->estimatedReceivedJitterExponent); + + invokeEndElement (pctxt, "estimatedReceivedJitterExponent", -1); + + /* decode skippedFrameCount */ + + if (pvalue->m.skippedFrameCountPresent) { + invokeStartElement (pctxt, "skippedFrameCount", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->skippedFrameCount, 0U, 15U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->skippedFrameCount); + + invokeEndElement (pctxt, "skippedFrameCount", -1); + } + + /* decode additionalDecoderBuffer */ + + if (pvalue->m.additionalDecoderBufferPresent) { + invokeStartElement (pctxt, "additionalDecoderBuffer", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->additionalDecoderBuffer, 0U, 262143U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->additionalDecoderBuffer); + + invokeEndElement (pctxt, "additionalDecoderBuffer", -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); +} + +/**************************************************************/ +/* */ +/* H223SkewIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H223SkewIndication (OOCTXT* pctxt, H245H223SkewIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode logicalChannelNumber1 */ + + invokeStartElement (pctxt, "logicalChannelNumber1", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber1); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber1", -1); + + /* decode logicalChannelNumber2 */ + + invokeStartElement (pctxt, "logicalChannelNumber2", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber2); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber2", -1); + + /* decode skew */ + + invokeStartElement (pctxt, "skew", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->skew, 0U, 4095U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->skew); + + invokeEndElement (pctxt, "skew", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1_clockRecovery */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_clockRecovery* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* nullClockRecovery */ + case 0: + invokeStartElement (pctxt, "nullClockRecovery", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "nullClockRecovery", -1); + + break; + + /* srtsClockRecovery */ + case 1: + invokeStartElement (pctxt, "srtsClockRecovery", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "srtsClockRecovery", -1); + + break; + + /* adaptiveClockRecovery */ + case 2: + invokeStartElement (pctxt, "adaptiveClockRecovery", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "adaptiveClockRecovery", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1_errorCorrection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_errorCorrection* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* nullErrorCorrection */ + case 0: + invokeStartElement (pctxt, "nullErrorCorrection", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "nullErrorCorrection", -1); + + break; + + /* longInterleaver */ + case 1: + invokeStartElement (pctxt, "longInterleaver", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "longInterleaver", -1); + + break; + + /* shortInterleaver */ + case 2: + invokeStartElement (pctxt, "shortInterleaver", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "shortInterleaver", -1); + + break; + + /* errorCorrectionOnly */ + case 3: + invokeStartElement (pctxt, "errorCorrectionOnly", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "errorCorrectionOnly", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication_aal_aal1 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode clockRecovery */ + + invokeStartElement (pctxt, "clockRecovery", -1); + + stat = asn1PD_H245NewATMVCIndication_aal_aal1_clockRecovery (pctxt, &pvalue->clockRecovery); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "clockRecovery", -1); + + /* decode errorCorrection */ + + invokeStartElement (pctxt, "errorCorrection", -1); + + stat = asn1PD_H245NewATMVCIndication_aal_aal1_errorCorrection (pctxt, &pvalue->errorCorrection); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "errorCorrection", -1); + + /* decode structuredDataTransfer */ + + invokeStartElement (pctxt, "structuredDataTransfer", -1); + + stat = DECODEBIT (pctxt, &pvalue->structuredDataTransfer); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->structuredDataTransfer); + + invokeEndElement (pctxt, "structuredDataTransfer", -1); + + /* decode partiallyFilledCells */ + + invokeStartElement (pctxt, "partiallyFilledCells", -1); + + stat = DECODEBIT (pctxt, &pvalue->partiallyFilledCells); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->partiallyFilledCells); + + invokeEndElement (pctxt, "partiallyFilledCells", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal5 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication_aal_aal5 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal5* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode forwardMaximumSDUSize */ + + invokeStartElement (pctxt, "forwardMaximumSDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->forwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->forwardMaximumSDUSize); + + invokeEndElement (pctxt, "forwardMaximumSDUSize", -1); + + /* decode backwardMaximumSDUSize */ + + invokeStartElement (pctxt, "backwardMaximumSDUSize", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->backwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->backwardMaximumSDUSize); + + invokeEndElement (pctxt, "backwardMaximumSDUSize", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication_aal (OOCTXT* pctxt, H245NewATMVCIndication_aal* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* aal1 */ + case 0: + invokeStartElement (pctxt, "aal1", -1); + + pvalue->u.aal1 = ALLOC_ASN1ELEM (pctxt, H245NewATMVCIndication_aal_aal1); + + stat = asn1PD_H245NewATMVCIndication_aal_aal1 (pctxt, pvalue->u.aal1); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal1", -1); + + break; + + /* aal5 */ + case 1: + invokeStartElement (pctxt, "aal5", -1); + + pvalue->u.aal5 = ALLOC_ASN1ELEM (pctxt, H245NewATMVCIndication_aal_aal5); + + stat = asn1PD_H245NewATMVCIndication_aal_aal5 (pctxt, pvalue->u.aal5); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal5", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_multiplex */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_multiplex* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* noMultiplex */ + case 0: + invokeStartElement (pctxt, "noMultiplex", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noMultiplex", -1); + + break; + + /* transportStream */ + case 1: + invokeStartElement (pctxt, "transportStream", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "transportStream", -1); + + break; + + /* programStream */ + case 2: + invokeStartElement (pctxt, "programStream", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "programStream", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_reverseParameters_multiplex */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters_multiplex* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* noMultiplex */ + case 0: + invokeStartElement (pctxt, "noMultiplex", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noMultiplex", -1); + + break; + + /* transportStream */ + case 1: + invokeStartElement (pctxt, "transportStream", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "transportStream", -1); + + break; + + /* programStream */ + case 2: + invokeStartElement (pctxt, "programStream", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "programStream", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_reverseParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication_reverseParameters (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -1); + + /* decode bitRateLockedToPCRClock */ + + invokeStartElement (pctxt, "bitRateLockedToPCRClock", -1); + + stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToPCRClock); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->bitRateLockedToPCRClock); + + invokeEndElement (pctxt, "bitRateLockedToPCRClock", -1); + + /* decode bitRateLockedToNetworkClock */ + + invokeStartElement (pctxt, "bitRateLockedToNetworkClock", -1); + + stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToNetworkClock); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->bitRateLockedToNetworkClock); + + invokeEndElement (pctxt, "bitRateLockedToNetworkClock", -1); + + /* decode multiplex */ + + invokeStartElement (pctxt, "multiplex", -1); + + stat = asn1PD_H245NewATMVCIndication_reverseParameters_multiplex (pctxt, &pvalue->multiplex); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplex", -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); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245NewATMVCIndication (OOCTXT* pctxt, H245NewATMVCIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + /* decode resourceID */ + + invokeStartElement (pctxt, "resourceID", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->resourceID); + + invokeEndElement (pctxt, "resourceID", -1); + + /* decode bitRate */ + + invokeStartElement (pctxt, "bitRate", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->bitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->bitRate); + + invokeEndElement (pctxt, "bitRate", -1); + + /* decode bitRateLockedToPCRClock */ + + invokeStartElement (pctxt, "bitRateLockedToPCRClock", -1); + + stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToPCRClock); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->bitRateLockedToPCRClock); + + invokeEndElement (pctxt, "bitRateLockedToPCRClock", -1); + + /* decode bitRateLockedToNetworkClock */ + + invokeStartElement (pctxt, "bitRateLockedToNetworkClock", -1); + + stat = DECODEBIT (pctxt, &pvalue->bitRateLockedToNetworkClock); + if (stat != ASN_OK) return stat; + invokeBoolValue (pctxt, pvalue->bitRateLockedToNetworkClock); + + invokeEndElement (pctxt, "bitRateLockedToNetworkClock", -1); + + /* decode aal */ + + invokeStartElement (pctxt, "aal", -1); + + stat = asn1PD_H245NewATMVCIndication_aal (pctxt, &pvalue->aal); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "aal", -1); + + /* decode multiplex */ + + invokeStartElement (pctxt, "multiplex", -1); + + stat = asn1PD_H245NewATMVCIndication_multiplex (pctxt, &pvalue->multiplex); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplex", -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.reverseParametersPresent = 1; + + invokeStartElement (pctxt, "reverseParameters", -1); + + stat = asn1PD_H245NewATMVCIndication_reverseParameters (pctxt, &pvalue->reverseParameters); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "reverseParameters", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_userInputSupportIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UserInputIndication_userInputSupportIndication (OOCTXT* pctxt, H245UserInputIndication_userInputSupportIndication* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* basicString */ + case 1: + invokeStartElement (pctxt, "basicString", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "basicString", -1); + + break; + + /* iA5String */ + case 2: + invokeStartElement (pctxt, "iA5String", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "iA5String", -1); + + break; + + /* generalString */ + case 3: + invokeStartElement (pctxt, "generalString", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "generalString", -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); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_signal_rtp */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UserInputIndication_signal_rtp (OOCTXT* pctxt, H245UserInputIndication_signal_rtp* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.timestampPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.expirationTimePresent = optbit; + + /* decode timestamp */ + + if (pvalue->m.timestampPresent) { + invokeStartElement (pctxt, "timestamp", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->timestamp, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->timestamp); + + invokeEndElement (pctxt, "timestamp", -1); + } + + /* decode expirationTime */ + + if (pvalue->m.expirationTimePresent) { + invokeStartElement (pctxt, "expirationTime", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->expirationTime, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->expirationTime); + + invokeEndElement (pctxt, "expirationTime", -1); + } + + /* decode logicalChannelNumber */ + + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -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); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_signal */ +/* */ +/**************************************************************/ + +extern EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet; + +EXTERN int asn1PD_H245UserInputIndication_signal (OOCTXT* pctxt, H245UserInputIndication_signal* pvalue) +{ + static Asn1SizeCnst signalType_lsize1 = { 0, 1, 1, 0 }; + int stat = ASN_OK; + OOCTXT lctxt; + OOCTXT lctxt2; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.durationPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.rtpPresent = optbit; + + /* decode signalType */ + + invokeStartElement (pctxt, "signalType", -1); + + addSizeConstraint (pctxt, &signalType_lsize1); + + stat = decodeConstrainedStringEx (pctxt, &pvalue->signalType, gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet, 8, 5, 7); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->signalType); + + invokeEndElement (pctxt, "signalType", -1); + + /* decode duration */ + + if (pvalue->m.durationPresent) { + invokeStartElement (pctxt, "duration", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->duration, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->duration); + + invokeEndElement (pctxt, "duration", -1); + } + + /* decode rtp */ + + if (pvalue->m.rtpPresent) { + invokeStartElement (pctxt, "rtp", -1); + + stat = asn1PD_H245UserInputIndication_signal_rtp (pctxt, &pvalue->rtp); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rtp", -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.rtpPayloadIndicationPresent = 1; + + invokeStartElement (pctxt, "rtpPayloadIndication", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "rtpPayloadIndication", -1); + break; + + default: + pctxt->buffer.byteIndex += openType.numocts; + } + copyContext (pctxt, &lctxt2); + } + else { /* unknown element */ + pctxt->buffer.byteIndex += openType.numocts; + } + } + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_signalUpdate_rtp */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UserInputIndication_signalUpdate_rtp (OOCTXT* pctxt, H245UserInputIndication_signalUpdate_rtp* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode logicalChannelNumber */ + + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -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); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_signalUpdate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UserInputIndication_signalUpdate (OOCTXT* pctxt, H245UserInputIndication_signalUpdate* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.rtpPresent = optbit; + + /* decode duration */ + + invokeStartElement (pctxt, "duration", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->duration, 1U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->duration); + + invokeEndElement (pctxt, "duration", -1); + + /* decode rtp */ + + if (pvalue->m.rtpPresent) { + invokeStartElement (pctxt, "rtp", -1); + + stat = asn1PD_H245UserInputIndication_signalUpdate_rtp (pctxt, &pvalue->rtp); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "rtp", -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); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_extendedAlphanumeric */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UserInputIndication_extendedAlphanumeric (OOCTXT* pctxt, H245UserInputIndication_extendedAlphanumeric* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.rtpPayloadIndicationPresent = optbit; + + /* decode alphanumeric */ + + invokeStartElement (pctxt, "alphanumeric", -1); + + stat = decodeVarWidthCharString (pctxt, &pvalue->alphanumeric); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->alphanumeric); + + invokeEndElement (pctxt, "alphanumeric", -1); + + /* decode rtpPayloadIndication */ + + if (pvalue->m.rtpPayloadIndicationPresent) { + invokeStartElement (pctxt, "rtpPayloadIndication", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "rtpPayloadIndication", -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); +} + +/**************************************************************/ +/* */ +/* UserInputIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245UserInputIndication (OOCTXT* pctxt, H245UserInputIndication* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + 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) { + /* nonStandard */ + case 0: + invokeStartElement (pctxt, "nonStandard", -1); + + pvalue->u.nonStandard = ALLOC_ASN1ELEM (pctxt, H245NonStandardParameter); + + stat = asn1PD_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* alphanumeric */ + case 1: + invokeStartElement (pctxt, "alphanumeric", -1); + + stat = decodeVarWidthCharString (pctxt, &pvalue->u.alphanumeric); + if (stat != ASN_OK) return stat; + invokeCharStrValue (pctxt, pvalue->u.alphanumeric); + + invokeEndElement (pctxt, "alphanumeric", -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) { + /* userInputSupportIndication */ + case 3: + invokeStartElement (pctxt, "userInputSupportIndication", -1); + + pvalue->u.userInputSupportIndication = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication_userInputSupportIndication); + + stat = asn1PD_H245UserInputIndication_userInputSupportIndication (pctxt, pvalue->u.userInputSupportIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "userInputSupportIndication", -1); + + break; + + /* signal */ + case 4: + invokeStartElement (pctxt, "signal", -1); + + pvalue->u.signal = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication_signal); + + stat = asn1PD_H245UserInputIndication_signal (pctxt, pvalue->u.signal); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "signal", -1); + + break; + + /* signalUpdate */ + case 5: + invokeStartElement (pctxt, "signalUpdate", -1); + + pvalue->u.signalUpdate = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication_signalUpdate); + + stat = asn1PD_H245UserInputIndication_signalUpdate (pctxt, pvalue->u.signalUpdate); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "signalUpdate", -1); + + break; + + /* extendedAlphanumeric */ + case 6: + invokeStartElement (pctxt, "extendedAlphanumeric", -1); + + pvalue->u.extendedAlphanumeric = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication_extendedAlphanumeric); + + stat = asn1PD_H245UserInputIndication_extendedAlphanumeric (pctxt, pvalue->u.extendedAlphanumeric); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "extendedAlphanumeric", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250MaximumSkewIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245H2250MaximumSkewIndication (OOCTXT* pctxt, H245H2250MaximumSkewIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode logicalChannelNumber1 */ + + invokeStartElement (pctxt, "logicalChannelNumber1", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber1); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber1", -1); + + /* decode logicalChannelNumber2 */ + + invokeStartElement (pctxt, "logicalChannelNumber2", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->logicalChannelNumber2); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber2", -1); + + /* decode maximumSkew */ + + invokeStartElement (pctxt, "maximumSkew", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->maximumSkew, 0U, 4095U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->maximumSkew); + + invokeEndElement (pctxt, "maximumSkew", -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); +} + +/**************************************************************/ +/* */ +/* MCLocationIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MCLocationIndication (OOCTXT* pctxt, H245MCLocationIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode signalAddress */ + + invokeStartElement (pctxt, "signalAddress", -1); + + stat = asn1PD_H245TransportAddress (pctxt, &pvalue->signalAddress); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "signalAddress", -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); +} + +/**************************************************************/ +/* */ +/* TerminalYouAreSeeingInSubPictureNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245TerminalYouAreSeeingInSubPictureNumber (OOCTXT* pctxt, H245TerminalYouAreSeeingInSubPictureNumber* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode terminalNumber */ + + invokeStartElement (pctxt, "terminalNumber", -1); + + stat = asn1PD_H245TerminalNumber (pctxt, &pvalue->terminalNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalNumber", -1); + + /* decode subPictureNumber */ + + invokeStartElement (pctxt, "subPictureNumber", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->subPictureNumber, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->subPictureNumber); + + invokeEndElement (pctxt, "subPictureNumber", -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); +} + +/**************************************************************/ +/* */ +/* VideoIndicateCompose */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VideoIndicateCompose (OOCTXT* pctxt, H245VideoIndicateCompose* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode compositionNumber */ + + invokeStartElement (pctxt, "compositionNumber", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->compositionNumber, 0U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->compositionNumber); + + invokeEndElement (pctxt, "compositionNumber", -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); +} + +/**************************************************************/ +/* */ +/* ConferenceIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245ConferenceIndication (OOCTXT* pctxt, H245ConferenceIndication* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 9); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* sbeNumber */ + case 0: + invokeStartElement (pctxt, "sbeNumber", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->u.sbeNumber, 0U, 9U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.sbeNumber); + + invokeEndElement (pctxt, "sbeNumber", -1); + + break; + + /* terminalNumberAssign */ + case 1: + invokeStartElement (pctxt, "terminalNumberAssign", -1); + + pvalue->u.terminalNumberAssign = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.terminalNumberAssign); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalNumberAssign", -1); + + break; + + /* terminalJoinedConference */ + case 2: + invokeStartElement (pctxt, "terminalJoinedConference", -1); + + pvalue->u.terminalJoinedConference = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.terminalJoinedConference); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalJoinedConference", -1); + + break; + + /* terminalLeftConference */ + case 3: + invokeStartElement (pctxt, "terminalLeftConference", -1); + + pvalue->u.terminalLeftConference = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.terminalLeftConference); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalLeftConference", -1); + + break; + + /* seenByAtLeastOneOther */ + case 4: + invokeStartElement (pctxt, "seenByAtLeastOneOther", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "seenByAtLeastOneOther", -1); + + break; + + /* cancelSeenByAtLeastOneOther */ + case 5: + invokeStartElement (pctxt, "cancelSeenByAtLeastOneOther", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelSeenByAtLeastOneOther", -1); + + break; + + /* seenByAll */ + case 6: + invokeStartElement (pctxt, "seenByAll", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "seenByAll", -1); + + break; + + /* cancelSeenByAll */ + case 7: + invokeStartElement (pctxt, "cancelSeenByAll", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "cancelSeenByAll", -1); + + break; + + /* terminalYouAreSeeing */ + case 8: + invokeStartElement (pctxt, "terminalYouAreSeeing", -1); + + pvalue->u.terminalYouAreSeeing = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.terminalYouAreSeeing); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalYouAreSeeing", -1); + + break; + + /* requestForFloor */ + case 9: + invokeStartElement (pctxt, "requestForFloor", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "requestForFloor", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 11; + + 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) { + /* withdrawChairToken */ + case 11: + invokeStartElement (pctxt, "withdrawChairToken", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "withdrawChairToken", -1); + + break; + + /* floorRequested */ + case 12: + invokeStartElement (pctxt, "floorRequested", -1); + + pvalue->u.floorRequested = ALLOC_ASN1ELEM (pctxt, H245TerminalLabel); + + stat = asn1PD_H245TerminalLabel (pctxt, pvalue->u.floorRequested); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "floorRequested", -1); + + break; + + /* terminalYouAreSeeingInSubPictureNumber */ + case 13: + invokeStartElement (pctxt, "terminalYouAreSeeingInSubPictureNumber", -1); + + pvalue->u.terminalYouAreSeeingInSubPictureNumber = ALLOC_ASN1ELEM (pctxt, H245TerminalYouAreSeeingInSubPictureNumber); + + stat = asn1PD_H245TerminalYouAreSeeingInSubPictureNumber (pctxt, pvalue->u.terminalYouAreSeeingInSubPictureNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalYouAreSeeingInSubPictureNumber", -1); + + break; + + /* videoIndicateCompose */ + case 14: + invokeStartElement (pctxt, "videoIndicateCompose", -1); + + pvalue->u.videoIndicateCompose = ALLOC_ASN1ELEM (pctxt, H245VideoIndicateCompose); + + stat = asn1PD_H245VideoIndicateCompose (pctxt, pvalue->u.videoIndicateCompose); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "videoIndicateCompose", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VendorIdentification_productNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VendorIdentification_productNumber (OOCTXT* pctxt, H245VendorIdentification_productNumber* 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); +} + +/**************************************************************/ +/* */ +/* VendorIdentification_versionNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VendorIdentification_versionNumber (OOCTXT* pctxt, H245VendorIdentification_versionNumber* 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); +} + +/**************************************************************/ +/* */ +/* VendorIdentification */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245VendorIdentification (OOCTXT* pctxt, H245VendorIdentification* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.productNumberPresent = optbit; + + DECODEBIT (pctxt, &optbit); + pvalue->m.versionNumberPresent = optbit; + + /* decode vendor */ + + invokeStartElement (pctxt, "vendor", -1); + + stat = asn1PD_H245NonStandardIdentifier (pctxt, &pvalue->vendor); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "vendor", -1); + + /* decode productNumber */ + + if (pvalue->m.productNumberPresent) { + invokeStartElement (pctxt, "productNumber", -1); + + stat = asn1PD_H245VendorIdentification_productNumber (pctxt, &pvalue->productNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "productNumber", -1); + } + + /* decode versionNumber */ + + if (pvalue->m.versionNumberPresent) { + invokeStartElement (pctxt, "versionNumber", -1); + + stat = asn1PD_H245VendorIdentification_versionNumber (pctxt, &pvalue->versionNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "versionNumber", -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); +} + +/**************************************************************/ +/* */ +/* FunctionNotSupported_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FunctionNotSupported_cause (OOCTXT* pctxt, H245FunctionNotSupported_cause* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* syntaxError */ + case 0: + invokeStartElement (pctxt, "syntaxError", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "syntaxError", -1); + + break; + + /* semanticError */ + case 1: + invokeStartElement (pctxt, "semanticError", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "semanticError", -1); + + break; + + /* unknownFunction */ + case 2: + invokeStartElement (pctxt, "unknownFunction", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "unknownFunction", -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); +} + +/**************************************************************/ +/* */ +/* FunctionNotSupported */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FunctionNotSupported (OOCTXT* pctxt, H245FunctionNotSupported* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* optional bits */ + + memset (&pvalue->m, 0, sizeof(pvalue->m)); + + DECODEBIT (pctxt, &optbit); + pvalue->m.returnedFunctionPresent = optbit; + + /* decode cause */ + + invokeStartElement (pctxt, "cause", -1); + + stat = asn1PD_H245FunctionNotSupported_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "cause", -1); + + /* decode returnedFunction */ + + if (pvalue->m.returnedFunctionPresent) { + invokeStartElement (pctxt, "returnedFunction", -1); + + stat = decodeDynOctetString (pctxt, (ASN1DynOctStr*)&pvalue->returnedFunction); + if (stat != ASN_OK) return stat; + invokeOctStrValue (pctxt, pvalue->returnedFunction.numocts, pvalue->returnedFunction.data); + + invokeEndElement (pctxt, "returnedFunction", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkIndication_crcDesired */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkIndication_crcDesired (OOCTXT* pctxt, H245MultilinkIndication_crcDesired* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + 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); +} + +/**************************************************************/ +/* */ +/* MultilinkIndication_excessiveError */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkIndication_excessiveError (OOCTXT* pctxt, H245MultilinkIndication_excessiveError* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode connectionIdentifier */ + + invokeStartElement (pctxt, "connectionIdentifier", -1); + + stat = asn1PD_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "connectionIdentifier", -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); +} + +/**************************************************************/ +/* */ +/* MultilinkIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultilinkIndication (OOCTXT* pctxt, H245MultilinkIndication* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* crcDesired */ + case 1: + invokeStartElement (pctxt, "crcDesired", -1); + + pvalue->u.crcDesired = ALLOC_ASN1ELEM (pctxt, H245MultilinkIndication_crcDesired); + + stat = asn1PD_H245MultilinkIndication_crcDesired (pctxt, pvalue->u.crcDesired); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "crcDesired", -1); + + break; + + /* excessiveError */ + case 2: + invokeStartElement (pctxt, "excessiveError", -1); + + pvalue->u.excessiveError = ALLOC_ASN1ELEM (pctxt, H245MultilinkIndication_excessiveError); + + stat = asn1PD_H245MultilinkIndication_excessiveError (pctxt, pvalue->u.excessiveError); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "excessiveError", -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); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245LogicalChannelRateRelease (OOCTXT* pctxt, H245LogicalChannelRateRelease* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + 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); +} + +/**************************************************************/ +/* */ +/* FlowControlIndication_scope */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FlowControlIndication_scope (OOCTXT* pctxt, H245FlowControlIndication_scope* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 2); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* logicalChannelNumber */ + case 0: + invokeStartElement (pctxt, "logicalChannelNumber", -1); + + stat = asn1PD_H245LogicalChannelNumber (pctxt, &pvalue->u.logicalChannelNumber); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelNumber", -1); + + break; + + /* resourceID */ + case 1: + invokeStartElement (pctxt, "resourceID", -1); + + stat = decodeConsUInt16 (pctxt, &pvalue->u.resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.resourceID); + + invokeEndElement (pctxt, "resourceID", -1); + + break; + + /* wholeMultiplex */ + case 2: + invokeStartElement (pctxt, "wholeMultiplex", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "wholeMultiplex", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlIndication_restriction */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FlowControlIndication_restriction (OOCTXT* pctxt, H245FlowControlIndication_restriction* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + + stat = decodeConsUnsigned (pctxt, &ui, 0, 1); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 1; + + switch (ui) { + /* maximumBitRate */ + case 0: + invokeStartElement (pctxt, "maximumBitRate", -1); + + stat = decodeConsUnsigned (pctxt, &pvalue->u.maximumBitRate, 0U, 16777215U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->u.maximumBitRate); + + invokeEndElement (pctxt, "maximumBitRate", -1); + + break; + + /* noRestriction */ + case 1: + invokeStartElement (pctxt, "noRestriction", -1); + + /* NULL */ + invokeNullValue (pctxt); + + invokeEndElement (pctxt, "noRestriction", -1); + + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245FlowControlIndication (OOCTXT* pctxt, H245FlowControlIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode scope */ + + invokeStartElement (pctxt, "scope", -1); + + stat = asn1PD_H245FlowControlIndication_scope (pctxt, &pvalue->scope); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "scope", -1); + + /* decode restriction */ + + invokeStartElement (pctxt, "restriction", -1); + + stat = asn1PD_H245FlowControlIndication_restriction (pctxt, &pvalue->restriction); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "restriction", -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); +} + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MobileMultilinkReconfigurationIndication (OOCTXT* pctxt, H245MobileMultilinkReconfigurationIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1UINT bitcnt; + ASN1UINT i; + ASN1BOOL optbit; + ASN1BOOL extbit; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + /* decode sampleSize */ + + invokeStartElement (pctxt, "sampleSize", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->sampleSize, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->sampleSize); + + invokeEndElement (pctxt, "sampleSize", -1); + + /* decode samplesPerFrame */ + + invokeStartElement (pctxt, "samplesPerFrame", -1); + + stat = decodeConsUInt8 (pctxt, &pvalue->samplesPerFrame, 1U, 255U); + if (stat != ASN_OK) return stat; + invokeUIntValue (pctxt, pvalue->samplesPerFrame); + + invokeEndElement (pctxt, "samplesPerFrame", -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); +} + +/**************************************************************/ +/* */ +/* IndicationMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245IndicationMessage (OOCTXT* pctxt, H245IndicationMessage* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + OOCTXT lctxt; + + /* extension bit */ + + DECODEBIT (pctxt, &extbit); + + if (!extbit) { + stat = decodeConsUnsigned (pctxt, &ui, 0, 13); + 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, H245NonStandardMessage); + + stat = asn1PD_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "nonStandard", -1); + + break; + + /* functionNotUnderstood */ + case 1: + invokeStartElement (pctxt, "functionNotUnderstood", -1); + + pvalue->u.functionNotUnderstood = ALLOC_ASN1ELEM (pctxt, H245FunctionNotUnderstood); + + stat = asn1PD_H245FunctionNotUnderstood (pctxt, pvalue->u.functionNotUnderstood); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "functionNotUnderstood", -1); + + break; + + /* masterSlaveDeterminationRelease */ + case 2: + invokeStartElement (pctxt, "masterSlaveDeterminationRelease", -1); + + pvalue->u.masterSlaveDeterminationRelease = ALLOC_ASN1ELEM (pctxt, H245MasterSlaveDeterminationRelease); + + stat = asn1PD_H245MasterSlaveDeterminationRelease (pctxt, pvalue->u.masterSlaveDeterminationRelease); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "masterSlaveDeterminationRelease", -1); + + break; + + /* terminalCapabilitySetRelease */ + case 3: + invokeStartElement (pctxt, "terminalCapabilitySetRelease", -1); + + pvalue->u.terminalCapabilitySetRelease = ALLOC_ASN1ELEM (pctxt, H245TerminalCapabilitySetRelease); + + stat = asn1PD_H245TerminalCapabilitySetRelease (pctxt, pvalue->u.terminalCapabilitySetRelease); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "terminalCapabilitySetRelease", -1); + + break; + + /* openLogicalChannelConfirm */ + case 4: + invokeStartElement (pctxt, "openLogicalChannelConfirm", -1); + + pvalue->u.openLogicalChannelConfirm = ALLOC_ASN1ELEM (pctxt, H245OpenLogicalChannelConfirm); + + stat = asn1PD_H245OpenLogicalChannelConfirm (pctxt, pvalue->u.openLogicalChannelConfirm); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "openLogicalChannelConfirm", -1); + + break; + + /* requestChannelCloseRelease */ + case 5: + invokeStartElement (pctxt, "requestChannelCloseRelease", -1); + + pvalue->u.requestChannelCloseRelease = ALLOC_ASN1ELEM (pctxt, H245RequestChannelCloseRelease); + + stat = asn1PD_H245RequestChannelCloseRelease (pctxt, pvalue->u.requestChannelCloseRelease); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestChannelCloseRelease", -1); + + break; + + /* multiplexEntrySendRelease */ + case 6: + invokeStartElement (pctxt, "multiplexEntrySendRelease", -1); + + pvalue->u.multiplexEntrySendRelease = ALLOC_ASN1ELEM (pctxt, H245MultiplexEntrySendRelease); + + stat = asn1PD_H245MultiplexEntrySendRelease (pctxt, pvalue->u.multiplexEntrySendRelease); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multiplexEntrySendRelease", -1); + + break; + + /* requestMultiplexEntryRelease */ + case 7: + invokeStartElement (pctxt, "requestMultiplexEntryRelease", -1); + + pvalue->u.requestMultiplexEntryRelease = ALLOC_ASN1ELEM (pctxt, H245RequestMultiplexEntryRelease); + + stat = asn1PD_H245RequestMultiplexEntryRelease (pctxt, pvalue->u.requestMultiplexEntryRelease); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestMultiplexEntryRelease", -1); + + break; + + /* requestModeRelease */ + case 8: + invokeStartElement (pctxt, "requestModeRelease", -1); + + pvalue->u.requestModeRelease = ALLOC_ASN1ELEM (pctxt, H245RequestModeRelease); + + stat = asn1PD_H245RequestModeRelease (pctxt, pvalue->u.requestModeRelease); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "requestModeRelease", -1); + + break; + + /* miscellaneousIndication */ + case 9: + invokeStartElement (pctxt, "miscellaneousIndication", -1); + + pvalue->u.miscellaneousIndication = ALLOC_ASN1ELEM (pctxt, H245MiscellaneousIndication); + + stat = asn1PD_H245MiscellaneousIndication (pctxt, pvalue->u.miscellaneousIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "miscellaneousIndication", -1); + + break; + + /* jitterIndication */ + case 10: + invokeStartElement (pctxt, "jitterIndication", -1); + + pvalue->u.jitterIndication = ALLOC_ASN1ELEM (pctxt, H245JitterIndication); + + stat = asn1PD_H245JitterIndication (pctxt, pvalue->u.jitterIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "jitterIndication", -1); + + break; + + /* h223SkewIndication */ + case 11: + invokeStartElement (pctxt, "h223SkewIndication", -1); + + pvalue->u.h223SkewIndication = ALLOC_ASN1ELEM (pctxt, H245H223SkewIndication); + + stat = asn1PD_H245H223SkewIndication (pctxt, pvalue->u.h223SkewIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h223SkewIndication", -1); + + break; + + /* newATMVCIndication */ + case 12: + invokeStartElement (pctxt, "newATMVCIndication", -1); + + pvalue->u.newATMVCIndication = ALLOC_ASN1ELEM (pctxt, H245NewATMVCIndication); + + stat = asn1PD_H245NewATMVCIndication (pctxt, pvalue->u.newATMVCIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "newATMVCIndication", -1); + + break; + + /* userInput */ + case 13: + invokeStartElement (pctxt, "userInput", -1); + + pvalue->u.userInput = ALLOC_ASN1ELEM (pctxt, H245UserInputIndication); + + stat = asn1PD_H245UserInputIndication (pctxt, pvalue->u.userInput); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "userInput", -1); + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + stat = decodeSmallNonNegWholeNumber (pctxt, &ui); + if (stat != ASN_OK) return stat; + else pvalue->t = ui + 15; + + 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) { + /* h2250MaximumSkewIndication */ + case 15: + invokeStartElement (pctxt, "h2250MaximumSkewIndication", -1); + + pvalue->u.h2250MaximumSkewIndication = ALLOC_ASN1ELEM (pctxt, H245H2250MaximumSkewIndication); + + stat = asn1PD_H245H2250MaximumSkewIndication (pctxt, pvalue->u.h2250MaximumSkewIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "h2250MaximumSkewIndication", -1); + + break; + + /* mcLocationIndication */ + case 16: + invokeStartElement (pctxt, "mcLocationIndication", -1); + + pvalue->u.mcLocationIndication = ALLOC_ASN1ELEM (pctxt, H245MCLocationIndication); + + stat = asn1PD_H245MCLocationIndication (pctxt, pvalue->u.mcLocationIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mcLocationIndication", -1); + + break; + + /* conferenceIndication */ + case 17: + invokeStartElement (pctxt, "conferenceIndication", -1); + + pvalue->u.conferenceIndication = ALLOC_ASN1ELEM (pctxt, H245ConferenceIndication); + + stat = asn1PD_H245ConferenceIndication (pctxt, pvalue->u.conferenceIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "conferenceIndication", -1); + + break; + + /* vendorIdentification */ + case 18: + invokeStartElement (pctxt, "vendorIdentification", -1); + + pvalue->u.vendorIdentification = ALLOC_ASN1ELEM (pctxt, H245VendorIdentification); + + stat = asn1PD_H245VendorIdentification (pctxt, pvalue->u.vendorIdentification); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "vendorIdentification", -1); + + break; + + /* functionNotSupported */ + case 19: + invokeStartElement (pctxt, "functionNotSupported", -1); + + pvalue->u.functionNotSupported = ALLOC_ASN1ELEM (pctxt, H245FunctionNotSupported); + + stat = asn1PD_H245FunctionNotSupported (pctxt, pvalue->u.functionNotSupported); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "functionNotSupported", -1); + + break; + + /* multilinkIndication */ + case 20: + invokeStartElement (pctxt, "multilinkIndication", -1); + + pvalue->u.multilinkIndication = ALLOC_ASN1ELEM (pctxt, H245MultilinkIndication); + + stat = asn1PD_H245MultilinkIndication (pctxt, pvalue->u.multilinkIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "multilinkIndication", -1); + + break; + + /* logicalChannelRateRelease */ + case 21: + invokeStartElement (pctxt, "logicalChannelRateRelease", -1); + + pvalue->u.logicalChannelRateRelease = ALLOC_ASN1ELEM (pctxt, H245LogicalChannelRateRelease); + + stat = asn1PD_H245LogicalChannelRateRelease (pctxt, pvalue->u.logicalChannelRateRelease); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "logicalChannelRateRelease", -1); + + break; + + /* flowControlIndication */ + case 22: + invokeStartElement (pctxt, "flowControlIndication", -1); + + pvalue->u.flowControlIndication = ALLOC_ASN1ELEM (pctxt, H245FlowControlIndication); + + stat = asn1PD_H245FlowControlIndication (pctxt, pvalue->u.flowControlIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "flowControlIndication", -1); + + break; + + /* mobileMultilinkReconfigurationIndication */ + case 23: + invokeStartElement (pctxt, "mobileMultilinkReconfigurationIndication", -1); + + pvalue->u.mobileMultilinkReconfigurationIndication = ALLOC_ASN1ELEM (pctxt, H245MobileMultilinkReconfigurationIndication); + + stat = asn1PD_H245MobileMultilinkReconfigurationIndication (pctxt, pvalue->u.mobileMultilinkReconfigurationIndication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "mobileMultilinkReconfigurationIndication", -1); + + break; + + default:; + } + + copyContext (pctxt, &lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultimediaSystemControlMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PD_H245MultimediaSystemControlMessage (OOCTXT* pctxt, H245MultimediaSystemControlMessage* pvalue) +{ + int stat = ASN_OK; + ASN1UINT ui; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* 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) { + /* request */ + case 0: + invokeStartElement (pctxt, "request", -1); + + pvalue->u.request = ALLOC_ASN1ELEM (pctxt, H245RequestMessage); + + stat = asn1PD_H245RequestMessage (pctxt, pvalue->u.request); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "request", -1); + + break; + + /* response */ + case 1: + invokeStartElement (pctxt, "response", -1); + + pvalue->u.response = ALLOC_ASN1ELEM (pctxt, H245ResponseMessage); + + stat = asn1PD_H245ResponseMessage (pctxt, pvalue->u.response); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "response", -1); + + break; + + /* command */ + case 2: + invokeStartElement (pctxt, "command", -1); + + pvalue->u.command = ALLOC_ASN1ELEM (pctxt, H245CommandMessage); + + stat = asn1PD_H245CommandMessage (pctxt, pvalue->u.command); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "command", -1); + + break; + + /* indication */ + case 3: + invokeStartElement (pctxt, "indication", -1); + + pvalue->u.indication = ALLOC_ASN1ELEM (pctxt, H245IndicationMessage); + + stat = asn1PD_H245IndicationMessage (pctxt, pvalue->u.indication); + if (stat != ASN_OK) return stat; + + invokeEndElement (pctxt, "indication", -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); +} + diff --git a/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c new file mode 100644 index 000000000..ac124d96d --- /dev/null +++ b/addons/ooh323c/src/h323/MULTIMEDIA-SYSTEM-CONTROLEnc.c @@ -0,0 +1,26599 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * This file was generated by the Objective Systems ASN1C Compiler + * (http://www.obj-sys.com). Version: 5.72, Date: 22-Mar-2005. + */ +#include "ooasn1.h" +#include "MULTIMEDIA-SYSTEM-CONTROL.h" + +/**************************************************************/ +/* */ +/* NonStandardIdentifier_h221NonStandard */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NonStandardIdentifier_h221NonStandard (OOCTXT* pctxt, H245NonStandardIdentifier_h221NonStandard* pvalue) +{ + int stat = ASN_OK; + + /* encode t35CountryCode */ + + stat = encodeConsUnsigned (pctxt, pvalue->t35CountryCode, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode t35Extension */ + + stat = encodeConsUnsigned (pctxt, pvalue->t35Extension, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode manufacturerCode */ + + stat = encodeConsUnsigned (pctxt, pvalue->manufacturerCode, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NonStandardIdentifier (OOCTXT* pctxt, H245NonStandardIdentifier* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* object */ + case 1: + stat = encodeObjectIdentifier (pctxt, pvalue->u.object); + if (stat != ASN_OK) return stat; + break; + + /* h221NonStandard */ + case 2: + stat = asn1PE_H245NonStandardIdentifier_h221NonStandard (pctxt, pvalue->u.h221NonStandard); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NonStandardParameter (OOCTXT* pctxt, H245NonStandardParameter* pvalue) +{ + int stat = ASN_OK; + + /* encode nonStandardIdentifier */ + + stat = asn1PE_H245NonStandardIdentifier (pctxt, &pvalue->nonStandardIdentifier); + if (stat != ASN_OK) return stat; + + /* encode data */ + + stat = encodeOctetString (pctxt, pvalue->data.numocts, pvalue->data.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* V42bis */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V42bis (OOCTXT* pctxt, H245V42bis* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode numberOfCodewords */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfCodewords, 1U, 65536U); + if (stat != ASN_OK) return stat; + + /* encode maximumStringLength */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumStringLength, 1U, 256U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CompressionType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CompressionType (OOCTXT* pctxt, H245CompressionType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* v42bis */ + case 1: + stat = asn1PE_H245V42bis (pctxt, pvalue->u.v42bis); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataProtocolCapability_v76wCompression */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataProtocolCapability_v76wCompression (OOCTXT* pctxt, H245DataProtocolCapability_v76wCompression* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* transmitCompression */ + case 1: + stat = asn1PE_H245CompressionType (pctxt, pvalue->u.transmitCompression); + if (stat != ASN_OK) return stat; + break; + + /* receiveCompression */ + case 2: + stat = asn1PE_H245CompressionType (pctxt, pvalue->u.receiveCompression); + if (stat != ASN_OK) return stat; + break; + + /* transmitAndReceiveCompression */ + case 3: + stat = asn1PE_H245CompressionType (pctxt, pvalue->u.transmitAndReceiveCompression); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataProtocolCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataProtocolCapability (OOCTXT* pctxt, H245DataProtocolCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 7); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* v14buffered */ + case 2: + /* NULL */ + break; + + /* v42lapm */ + case 3: + /* NULL */ + break; + + /* hdlcFrameTunnelling */ + case 4: + /* NULL */ + break; + + /* h310SeparateVCStack */ + case 5: + /* NULL */ + break; + + /* h310SingleVCStack */ + case 6: + /* NULL */ + break; + + /* transparent */ + case 7: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* segmentationAndReassembly */ + case 8: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* hdlcFrameTunnelingwSAR */ + case 9: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* v120 */ + case 10: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* separateLANStack */ + case 11: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* v76wCompression */ + case 12: + stat = asn1PE_H245DataProtocolCapability_v76wCompression (&lctxt, pvalue->u.v76wCompression); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* tcp */ + case 13: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* udp */ + case 14: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* T38FaxRateManagement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245T38FaxRateManagement (OOCTXT* pctxt, H245T38FaxRateManagement* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* localTCF */ + case 1: + /* NULL */ + break; + + /* transferredTCF */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* T38FaxUdpOptions_t38FaxUdpEC */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245T38FaxUdpOptions_t38FaxUdpEC (OOCTXT* pctxt, H245T38FaxUdpOptions_t38FaxUdpEC* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* t38UDPFEC */ + case 1: + /* NULL */ + break; + + /* t38UDPRedundancy */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* T38FaxUdpOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245T38FaxUdpOptions (OOCTXT* pctxt, H245T38FaxUdpOptions* pvalue) +{ + int stat = ASN_OK; + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxMaxBufferPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxMaxDatagramPresent); + + /* encode t38FaxMaxBuffer */ + + if (pvalue->m.t38FaxMaxBufferPresent) { + stat = encodeUnconsInteger (pctxt, pvalue->t38FaxMaxBuffer); + if (stat != ASN_OK) return stat; + } + + /* encode t38FaxMaxDatagram */ + + if (pvalue->m.t38FaxMaxDatagramPresent) { + stat = encodeUnconsInteger (pctxt, pvalue->t38FaxMaxDatagram); + if (stat != ASN_OK) return stat; + } + + /* encode t38FaxUdpEC */ + + stat = asn1PE_H245T38FaxUdpOptions_t38FaxUdpEC (pctxt, &pvalue->t38FaxUdpEC); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* T38FaxTcpOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245T38FaxTcpOptions (OOCTXT* pctxt, H245T38FaxTcpOptions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode t38TCPBidirectionalMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->t38TCPBidirectionalMode); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* T38FaxProfile */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245T38FaxProfile (OOCTXT* pctxt, H245T38FaxProfile* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.versionPresent || + pvalue->m.t38FaxRateManagementPresent || + pvalue->m.t38FaxUdpOptionsPresent || + pvalue->m.t38FaxTcpOptionsPresent); + + encodeBit (pctxt, extbit); + + /* encode fillBitRemoval */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fillBitRemoval); + if (stat != ASN_OK) return stat; + + /* encode transcodingJBIG */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->transcodingJBIG); + if (stat != ASN_OK) return stat; + + /* encode transcodingMMR */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->transcodingMMR); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 3); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.versionPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxRateManagementPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxUdpOptionsPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t38FaxTcpOptionsPresent); + /* encode extension elements */ + + if (pvalue->m.versionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->version, 0U, 255U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.t38FaxRateManagementPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245T38FaxRateManagement (&lctxt, &pvalue->t38FaxRateManagement); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.t38FaxUdpOptionsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245T38FaxUdpOptions (&lctxt, &pvalue->t38FaxUdpOptions); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.t38FaxTcpOptionsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245T38FaxTcpOptions (&lctxt, &pvalue->t38FaxTcpOptions); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NonStandardMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NonStandardMessage (OOCTXT* pctxt, H245NonStandardMessage* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode nonStandardData */ + + stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDetermination */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MasterSlaveDetermination (OOCTXT* pctxt, H245MasterSlaveDetermination* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalType */ + + stat = encodeConsUnsigned (pctxt, pvalue->terminalType, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode statusDeterminationNumber */ + + stat = encodeConsUnsigned (pctxt, pvalue->statusDeterminationNumber, 0U, 16777215U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* SequenceNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245SequenceNumber (OOCTXT* pctxt, H245SequenceNumber value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 0U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_aal1 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VCCapability_aal1 (OOCTXT* pctxt, H245VCCapability_aal1* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode nullClockRecovery */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nullClockRecovery); + if (stat != ASN_OK) return stat; + + /* encode srtsClockRecovery */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->srtsClockRecovery); + if (stat != ASN_OK) return stat; + + /* encode adaptiveClockRecovery */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->adaptiveClockRecovery); + if (stat != ASN_OK) return stat; + + /* encode nullErrorCorrection */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nullErrorCorrection); + if (stat != ASN_OK) return stat; + + /* encode longInterleaver */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->longInterleaver); + if (stat != ASN_OK) return stat; + + /* encode shortInterleaver */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->shortInterleaver); + if (stat != ASN_OK) return stat; + + /* encode errorCorrectionOnly */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->errorCorrectionOnly); + if (stat != ASN_OK) return stat; + + /* encode structuredDataTransfer */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->structuredDataTransfer); + if (stat != ASN_OK) return stat; + + /* encode partiallyFilledCells */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partiallyFilledCells); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_aal5 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VCCapability_aal5 (OOCTXT* pctxt, H245VCCapability_aal5* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardMaximumSDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->forwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode backwardMaximumSDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->backwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates_type_rangeOfBitRates */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VCCapability_availableBitRates_type_rangeOfBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates_type_rangeOfBitRates* pvalue) +{ + int stat = ASN_OK; + + /* encode lowerBitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->lowerBitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode higherBitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->higherBitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VCCapability_availableBitRates_type (OOCTXT* pctxt, H245VCCapability_availableBitRates_type* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* singleBitRate */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.singleBitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* rangeOfBitRates */ + case 2: + stat = asn1PE_H245VCCapability_availableBitRates_type_rangeOfBitRates (pctxt, pvalue->u.rangeOfBitRates); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_availableBitRates */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VCCapability_availableBitRates (OOCTXT* pctxt, H245VCCapability_availableBitRates* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = asn1PE_H245VCCapability_availableBitRates_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Q2931Address_address_nsapAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245Q2931Address_address_nsapAddress (OOCTXT* pctxt, H245Q2931Address_address_nsapAddress* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Q2931Address_address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245Q2931Address_address (OOCTXT* pctxt, H245Q2931Address_address* pvalue) +{ + static Asn1SizeCnst internationalNumber_lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* internationalNumber */ + case 1: + addSizeConstraint (pctxt, &internationalNumber_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->u.internationalNumber, NUM_CANSET, 4, 4, 4); + if (stat != ASN_OK) return stat; + break; + + /* nsapAddress */ + case 2: + stat = asn1PE_H245Q2931Address_address_nsapAddress (pctxt, pvalue->u.nsapAddress); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Q2931Address_subaddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245Q2931Address_subaddress (OOCTXT* pctxt, H245Q2931Address_subaddress* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Q2931Address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245Q2931Address (OOCTXT* pctxt, H245Q2931Address* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.subaddressPresent); + + /* encode address */ + + stat = asn1PE_H245Q2931Address_address (pctxt, &pvalue->address); + if (stat != ASN_OK) return stat; + + /* encode subaddress */ + + if (pvalue->m.subaddressPresent) { + stat = asn1PE_H245Q2931Address_subaddress (pctxt, &pvalue->subaddress); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_aal1ViaGateway_gatewayAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VCCapability_aal1ViaGateway_gatewayAddress (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway_gatewayAddress* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245Q2931Address (pctxt, ((H245Q2931Address*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability_aal1ViaGateway */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VCCapability_aal1ViaGateway (OOCTXT* pctxt, H245VCCapability_aal1ViaGateway* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode gatewayAddress */ + + stat = asn1PE_H245VCCapability_aal1ViaGateway_gatewayAddress (pctxt, &pvalue->gatewayAddress); + if (stat != ASN_OK) return stat; + + /* encode nullClockRecovery */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nullClockRecovery); + if (stat != ASN_OK) return stat; + + /* encode srtsClockRecovery */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->srtsClockRecovery); + if (stat != ASN_OK) return stat; + + /* encode adaptiveClockRecovery */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->adaptiveClockRecovery); + if (stat != ASN_OK) return stat; + + /* encode nullErrorCorrection */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nullErrorCorrection); + if (stat != ASN_OK) return stat; + + /* encode longInterleaver */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->longInterleaver); + if (stat != ASN_OK) return stat; + + /* encode shortInterleaver */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->shortInterleaver); + if (stat != ASN_OK) return stat; + + /* encode errorCorrectionOnly */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->errorCorrectionOnly); + if (stat != ASN_OK) return stat; + + /* encode structuredDataTransfer */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->structuredDataTransfer); + if (stat != ASN_OK) return stat; + + /* encode partiallyFilledCells */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partiallyFilledCells); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VCCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VCCapability (OOCTXT* pctxt, H245VCCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.aal1ViaGatewayPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.aal1Present); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.aal5Present); + + /* encode aal1 */ + + if (pvalue->m.aal1Present) { + stat = asn1PE_H245VCCapability_aal1 (pctxt, &pvalue->aal1); + if (stat != ASN_OK) return stat; + } + + /* encode aal5 */ + + if (pvalue->m.aal5Present) { + stat = asn1PE_H245VCCapability_aal5 (pctxt, &pvalue->aal5); + if (stat != ASN_OK) return stat; + } + + /* encode transportStream */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->transportStream); + if (stat != ASN_OK) return stat; + + /* encode programStream */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->programStream); + if (stat != ASN_OK) return stat; + + /* encode availableBitRates */ + + stat = asn1PE_H245VCCapability_availableBitRates (pctxt, &pvalue->availableBitRates); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.aal1ViaGatewayPresent); + /* encode extension elements */ + + if (pvalue->m.aal1ViaGatewayPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245VCCapability_aal1ViaGateway (&lctxt, &pvalue->aal1ViaGateway); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SetOfH245VCCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SetOfH245VCCapability (OOCTXT* pctxt, H245_SetOfH245VCCapability* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245VCCapability (pctxt, ((H245VCCapability*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H222Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H222Capability (OOCTXT* pctxt, H245H222Capability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode numberOfVCs */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfVCs, 1U, 256U); + if (stat != ASN_OK) return stat; + + /* encode vcCapability */ + + stat = asn1PE_H245_SetOfH245VCCapability (pctxt, &pvalue->vcCapability); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223Capability_h223MultiplexTableCapability_enhanced */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223Capability_h223MultiplexTableCapability_enhanced (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability_enhanced* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode maximumNestingDepth */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumNestingDepth, 1U, 15U); + if (stat != ASN_OK) return stat; + + /* encode maximumElementListSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumElementListSize, 2U, 255U); + if (stat != ASN_OK) return stat; + + /* encode maximumSubElementListSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumSubElementListSize, 2U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223Capability_h223MultiplexTableCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223Capability_h223MultiplexTableCapability (OOCTXT* pctxt, H245H223Capability_h223MultiplexTableCapability* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* basic */ + case 1: + /* NULL */ + break; + + /* enhanced */ + case 2: + stat = asn1PE_H245H223Capability_h223MultiplexTableCapability_enhanced (pctxt, pvalue->u.enhanced); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223Capability_mobileOperationTransmitCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223Capability_mobileOperationTransmitCapability (OOCTXT* pctxt, H245H223Capability_mobileOperationTransmitCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode modeChangeCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->modeChangeCapability); + if (stat != ASN_OK) return stat; + + /* encode h223AnnexA */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h223AnnexA); + if (stat != ASN_OK) return stat; + + /* encode h223AnnexADoubleFlag */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h223AnnexADoubleFlag); + if (stat != ASN_OK) return stat; + + /* encode h223AnnexB */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h223AnnexB); + if (stat != ASN_OK) return stat; + + /* encode h223AnnexBwithHeader */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h223AnnexBwithHeader); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AnnexCCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AnnexCCapability (OOCTXT* pctxt, H245H223AnnexCCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.rsCodeCapabilityPresent); + + encodeBit (pctxt, extbit); + + /* encode videoWithAL1M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL1M); + if (stat != ASN_OK) return stat; + + /* encode videoWithAL2M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL2M); + if (stat != ASN_OK) return stat; + + /* encode videoWithAL3M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL3M); + if (stat != ASN_OK) return stat; + + /* encode audioWithAL1M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL1M); + if (stat != ASN_OK) return stat; + + /* encode audioWithAL2M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL2M); + if (stat != ASN_OK) return stat; + + /* encode audioWithAL3M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL3M); + if (stat != ASN_OK) return stat; + + /* encode dataWithAL1M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL1M); + if (stat != ASN_OK) return stat; + + /* encode dataWithAL2M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL2M); + if (stat != ASN_OK) return stat; + + /* encode dataWithAL3M */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL3M); + if (stat != ASN_OK) return stat; + + /* encode alpduInterleaving */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alpduInterleaving); + if (stat != ASN_OK) return stat; + + /* encode maximumAL1MPDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumAL1MPDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode maximumAL2MSDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumAL2MSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode maximumAL3MSDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumAL3MSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rsCodeCapabilityPresent); + /* encode extension elements */ + + if (pvalue->m.rsCodeCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->rsCodeCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223Capability_mobileMultilinkFrameCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223Capability_mobileMultilinkFrameCapability (OOCTXT* pctxt, H245H223Capability_mobileMultilinkFrameCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode maximumSampleSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumSampleSize, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode maximumPayloadLength */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumPayloadLength, 1U, 65025U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223Capability (OOCTXT* pctxt, H245H223Capability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.maxMUXPDUSizeCapabilityPresent || + pvalue->m.nsrpSupportPresent || + pvalue->m.mobileOperationTransmitCapabilityPresent || + pvalue->m.h223AnnexCCapabilityPresent || + pvalue->m.bitRatePresent || + pvalue->m.mobileMultilinkFrameCapabilityPresent); + + encodeBit (pctxt, extbit); + + /* encode transportWithI_frames */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->transportWithI_frames); + if (stat != ASN_OK) return stat; + + /* encode videoWithAL1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL1); + if (stat != ASN_OK) return stat; + + /* encode videoWithAL2 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL2); + if (stat != ASN_OK) return stat; + + /* encode videoWithAL3 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoWithAL3); + if (stat != ASN_OK) return stat; + + /* encode audioWithAL1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL1); + if (stat != ASN_OK) return stat; + + /* encode audioWithAL2 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL2); + if (stat != ASN_OK) return stat; + + /* encode audioWithAL3 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioWithAL3); + if (stat != ASN_OK) return stat; + + /* encode dataWithAL1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL1); + if (stat != ASN_OK) return stat; + + /* encode dataWithAL2 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL2); + if (stat != ASN_OK) return stat; + + /* encode dataWithAL3 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataWithAL3); + if (stat != ASN_OK) return stat; + + /* encode maximumAl2SDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumAl2SDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode maximumAl3SDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumAl3SDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode maximumDelayJitter */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumDelayJitter, 0U, 1023U); + if (stat != ASN_OK) return stat; + + /* encode h223MultiplexTableCapability */ + + stat = asn1PE_H245H223Capability_h223MultiplexTableCapability (pctxt, &pvalue->h223MultiplexTableCapability); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 5); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maxMUXPDUSizeCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nsrpSupportPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mobileOperationTransmitCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h223AnnexCCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bitRatePresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mobileMultilinkFrameCapabilityPresent); + /* encode extension elements */ + + if (pvalue->m.maxMUXPDUSizeCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->maxMUXPDUSizeCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.nsrpSupportPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->nsrpSupport); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.mobileOperationTransmitCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H223Capability_mobileOperationTransmitCapability (&lctxt, &pvalue->mobileOperationTransmitCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h223AnnexCCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H223AnnexCCapability (&lctxt, &pvalue->h223AnnexCCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.bitRatePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->bitRate, 1U, 19200U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.mobileMultilinkFrameCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H223Capability_mobileMultilinkFrameCapability (&lctxt, &pvalue->mobileMultilinkFrameCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* V75Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V75Capability (OOCTXT* pctxt, H245V75Capability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode audioHeader */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioHeader); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* V76Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V76Capability (OOCTXT* pctxt, H245V76Capability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode suspendResumeCapabilitywAddress */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->suspendResumeCapabilitywAddress); + if (stat != ASN_OK) return stat; + + /* encode suspendResumeCapabilitywoAddress */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->suspendResumeCapabilitywoAddress); + if (stat != ASN_OK) return stat; + + /* encode rejCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->rejCapability); + if (stat != ASN_OK) return stat; + + /* encode sREJCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->sREJCapability); + if (stat != ASN_OK) return stat; + + /* encode mREJCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mREJCapability); + if (stat != ASN_OK) return stat; + + /* encode crc8bitCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->crc8bitCapability); + if (stat != ASN_OK) return stat; + + /* encode crc16bitCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->crc16bitCapability); + if (stat != ASN_OK) return stat; + + /* encode crc32bitCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->crc32bitCapability); + if (stat != ASN_OK) return stat; + + /* encode uihCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->uihCapability); + if (stat != ASN_OK) return stat; + + /* encode numOfDLCS */ + + stat = encodeConsUnsigned (pctxt, pvalue->numOfDLCS, 2U, 8191U); + if (stat != ASN_OK) return stat; + + /* encode twoOctetAddressFieldCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->twoOctetAddressFieldCapability); + if (stat != ASN_OK) return stat; + + /* encode loopBackTestCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->loopBackTestCapability); + if (stat != ASN_OK) return stat; + + /* encode n401Capability */ + + stat = encodeConsUnsigned (pctxt, pvalue->n401Capability, 1U, 4095U); + if (stat != ASN_OK) return stat; + + /* encode maxWindowSizeCapability */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxWindowSizeCapability, 1U, 127U); + if (stat != ASN_OK) return stat; + + /* encode v75Capability */ + + stat = asn1PE_H245V75Capability (pctxt, &pvalue->v75Capability); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* T84Profile_t84Restricted */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245T84Profile_t84Restricted (OOCTXT* pctxt, H245T84Profile_t84Restricted* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode qcif */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->qcif); + if (stat != ASN_OK) return stat; + + /* encode cif */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->cif); + if (stat != ASN_OK) return stat; + + /* encode ccir601Seq */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->ccir601Seq); + if (stat != ASN_OK) return stat; + + /* encode ccir601Prog */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->ccir601Prog); + if (stat != ASN_OK) return stat; + + /* encode hdtvSeq */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->hdtvSeq); + if (stat != ASN_OK) return stat; + + /* encode hdtvProg */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->hdtvProg); + if (stat != ASN_OK) return stat; + + /* encode g3FacsMH200x100 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->g3FacsMH200x100); + if (stat != ASN_OK) return stat; + + /* encode g3FacsMH200x200 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->g3FacsMH200x200); + if (stat != ASN_OK) return stat; + + /* encode g4FacsMMR200x100 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->g4FacsMMR200x100); + if (stat != ASN_OK) return stat; + + /* encode g4FacsMMR200x200 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->g4FacsMMR200x200); + if (stat != ASN_OK) return stat; + + /* encode jbig200x200Seq */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->jbig200x200Seq); + if (stat != ASN_OK) return stat; + + /* encode jbig200x200Prog */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->jbig200x200Prog); + if (stat != ASN_OK) return stat; + + /* encode jbig300x300Seq */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->jbig300x300Seq); + if (stat != ASN_OK) return stat; + + /* encode jbig300x300Prog */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->jbig300x300Prog); + if (stat != ASN_OK) return stat; + + /* encode digPhotoLow */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoLow); + if (stat != ASN_OK) return stat; + + /* encode digPhotoMedSeq */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoMedSeq); + if (stat != ASN_OK) return stat; + + /* encode digPhotoMedProg */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoMedProg); + if (stat != ASN_OK) return stat; + + /* encode digPhotoHighSeq */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoHighSeq); + if (stat != ASN_OK) return stat; + + /* encode digPhotoHighProg */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->digPhotoHighProg); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* T84Profile */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245T84Profile (OOCTXT* pctxt, H245T84Profile* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* t84Unrestricted */ + case 1: + /* NULL */ + break; + + /* t84Restricted */ + case 2: + stat = asn1PE_H245T84Profile_t84Restricted (pctxt, pvalue->u.t84Restricted); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_t84 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataApplicationCapability_application_t84 (OOCTXT* pctxt, H245DataApplicationCapability_application_t84* pvalue) +{ + int stat = ASN_OK; + + /* encode t84Protocol */ + + stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t84Protocol); + if (stat != ASN_OK) return stat; + + /* encode t84Profile */ + + stat = asn1PE_H245T84Profile (pctxt, &pvalue->t84Profile); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_nlpid */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataApplicationCapability_application_nlpid (OOCTXT* pctxt, H245DataApplicationCapability_application_nlpid* pvalue) +{ + int stat = ASN_OK; + + /* encode nlpidProtocol */ + + stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->nlpidProtocol); + if (stat != ASN_OK) return stat; + + /* encode nlpidData */ + + stat = encodeOctetString (pctxt, pvalue->nlpidData.numocts, pvalue->nlpidData.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application_t38fax */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataApplicationCapability_application_t38fax (OOCTXT* pctxt, H245DataApplicationCapability_application_t38fax* pvalue) +{ + int stat = ASN_OK; + + /* encode t38FaxProtocol */ + + stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol); + if (stat != ASN_OK) return stat; + + /* encode t38FaxProfile */ + + stat = asn1PE_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityIdentifier_uuid */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CapabilityIdentifier_uuid (OOCTXT* pctxt, H245CapabilityIdentifier_uuid* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CapabilityIdentifier (OOCTXT* pctxt, H245CapabilityIdentifier* pvalue) +{ + static Asn1SizeCnst domainBased_lsize1 = { 0, 1, 64, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* standard */ + case 1: + stat = encodeObjectIdentifier (pctxt, pvalue->u.standard); + if (stat != ASN_OK) return stat; + break; + + /* h221NonStandard */ + case 2: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.h221NonStandard); + if (stat != ASN_OK) return stat; + break; + + /* uuid */ + case 3: + stat = asn1PE_H245CapabilityIdentifier_uuid (pctxt, pvalue->u.uuid); + if (stat != ASN_OK) return stat; + break; + + /* domainBased */ + case 4: + addSizeConstraint (pctxt, &domainBased_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->u.domainBased, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ParameterIdentifier_uuid */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ParameterIdentifier_uuid (OOCTXT* pctxt, H245ParameterIdentifier_uuid* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ParameterIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ParameterIdentifier (OOCTXT* pctxt, H245ParameterIdentifier* pvalue) +{ + static Asn1SizeCnst domainBased_lsize1 = { 0, 1, 64, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* standard */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.standard, 0U, 127U); + if (stat != ASN_OK) return stat; + + break; + + /* h221NonStandard */ + case 2: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.h221NonStandard); + if (stat != ASN_OK) return stat; + break; + + /* uuid */ + case 3: + stat = asn1PE_H245ParameterIdentifier_uuid (pctxt, pvalue->u.uuid); + if (stat != ASN_OK) return stat; + break; + + /* domainBased */ + case 4: + addSizeConstraint (pctxt, &domainBased_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->u.domainBased, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ParameterValue */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ParameterValue (OOCTXT* pctxt, H245ParameterValue* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 8); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* logical */ + case 1: + /* NULL */ + break; + + /* booleanArray */ + case 2: + stat = encodeConsUnsigned (pctxt, pvalue->u.booleanArray, 0U, 255U); + if (stat != ASN_OK) return stat; + + break; + + /* unsignedMin */ + case 3: + stat = encodeConsUnsigned (pctxt, pvalue->u.unsignedMin, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* unsignedMax */ + case 4: + stat = encodeConsUnsigned (pctxt, pvalue->u.unsignedMax, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* unsigned32Min */ + case 5: + stat = encodeConsUnsigned (pctxt, pvalue->u.unsigned32Min, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + break; + + /* unsigned32Max */ + case 6: + stat = encodeConsUnsigned (pctxt, pvalue->u.unsigned32Max, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + break; + + /* octetString */ + case 7: + stat = encodeOctetString (pctxt, pvalue->u.octetString->numocts, pvalue->u.octetString->data); + if (stat != ASN_OK) return stat; + break; + + /* genericParameter */ + case 8: + stat = asn1PE_H245_SeqOfH245GenericParameter (pctxt, (H245_SeqOfH245GenericParameter*)pvalue->u.genericParameter); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245ParameterIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245ParameterIdentifier (OOCTXT* pctxt, H245_SeqOfH245ParameterIdentifier* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245ParameterIdentifier (pctxt, ((H245ParameterIdentifier*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GenericParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245GenericParameter (OOCTXT* pctxt, H245GenericParameter* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.supersedesPresent); + + /* encode parameterIdentifier */ + + stat = asn1PE_H245ParameterIdentifier (pctxt, &pvalue->parameterIdentifier); + if (stat != ASN_OK) return stat; + + /* encode parameterValue */ + + stat = asn1PE_H245ParameterValue (pctxt, &pvalue->parameterValue); + if (stat != ASN_OK) return stat; + + /* encode supersedes */ + + if (pvalue->m.supersedesPresent) { + stat = asn1PE_H245_SeqOfH245ParameterIdentifier (pctxt, &pvalue->supersedes); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245GenericParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245GenericParameter (OOCTXT* pctxt, H245_SeqOfH245GenericParameter* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245GenericParameter (pctxt, ((H245GenericParameter*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GenericCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245GenericCapability (OOCTXT* pctxt, H245GenericCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maxBitRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.collapsingPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonCollapsingPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonCollapsingRawPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportPresent); + + /* encode capabilityIdentifier */ + + stat = asn1PE_H245CapabilityIdentifier (pctxt, &pvalue->capabilityIdentifier); + if (stat != ASN_OK) return stat; + + /* encode maxBitRate */ + + if (pvalue->m.maxBitRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + /* encode collapsing */ + + if (pvalue->m.collapsingPresent) { + stat = asn1PE_H245_SeqOfH245GenericParameter (pctxt, &pvalue->collapsing); + if (stat != ASN_OK) return stat; + } + + /* encode nonCollapsing */ + + if (pvalue->m.nonCollapsingPresent) { + stat = asn1PE_H245_SeqOfH245GenericParameter (pctxt, &pvalue->nonCollapsing); + if (stat != ASN_OK) return stat; + } + + /* encode nonCollapsingRaw */ + + if (pvalue->m.nonCollapsingRawPresent) { + stat = encodeOctetString (pctxt, pvalue->nonCollapsingRaw.numocts, pvalue->nonCollapsingRaw.data); + if (stat != ASN_OK) return stat; + } + + /* encode transport */ + + if (pvalue->m.transportPresent) { + stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->transport); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability_application */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataApplicationCapability_application (OOCTXT* pctxt, H245DataApplicationCapability_application* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 10); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* t120 */ + case 2: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t120); + if (stat != ASN_OK) return stat; + break; + + /* dsm_cc */ + case 3: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.dsm_cc); + if (stat != ASN_OK) return stat; + break; + + /* userData */ + case 4: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.userData); + if (stat != ASN_OK) return stat; + break; + + /* t84 */ + case 5: + stat = asn1PE_H245DataApplicationCapability_application_t84 (pctxt, pvalue->u.t84); + if (stat != ASN_OK) return stat; + break; + + /* t434 */ + case 6: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t434); + if (stat != ASN_OK) return stat; + break; + + /* h224 */ + case 7: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.h224); + if (stat != ASN_OK) return stat; + break; + + /* nlpid */ + case 8: + stat = asn1PE_H245DataApplicationCapability_application_nlpid (pctxt, pvalue->u.nlpid); + if (stat != ASN_OK) return stat; + break; + + /* dsvdControl */ + case 9: + /* NULL */ + break; + + /* h222DataPartitioning */ + case 10: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.h222DataPartitioning); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* t30fax */ + case 11: + stat = asn1PE_H245DataProtocolCapability (&lctxt, pvalue->u.t30fax); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* t140 */ + case 12: + stat = asn1PE_H245DataProtocolCapability (&lctxt, pvalue->u.t140); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* t38fax */ + case 13: + stat = asn1PE_H245DataApplicationCapability_application_t38fax (&lctxt, pvalue->u.t38fax); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericDataCapability */ + case 14: + stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericDataCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataApplicationCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataApplicationCapability (OOCTXT* pctxt, H245DataApplicationCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode application */ + + stat = asn1PE_H245DataApplicationCapability_application (pctxt, &pvalue->application); + if (stat != ASN_OK) return stat; + + /* encode maxBitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245DataApplicationCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245DataApplicationCapability (OOCTXT* pctxt, H245_SeqOfH245DataApplicationCapability* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245DataApplicationCapability (pctxt, ((H245DataApplicationCapability*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaDistributionCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MediaDistributionCapability (OOCTXT* pctxt, H245MediaDistributionCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.centralizedDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.distributedDataPresent); + + /* encode centralizedControl */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->centralizedControl); + if (stat != ASN_OK) return stat; + + /* encode distributedControl */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->distributedControl); + if (stat != ASN_OK) return stat; + + /* encode centralizedAudio */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->centralizedAudio); + if (stat != ASN_OK) return stat; + + /* encode distributedAudio */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->distributedAudio); + if (stat != ASN_OK) return stat; + + /* encode centralizedVideo */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->centralizedVideo); + if (stat != ASN_OK) return stat; + + /* encode distributedVideo */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->distributedVideo); + if (stat != ASN_OK) return stat; + + /* encode centralizedData */ + + if (pvalue->m.centralizedDataPresent) { + stat = asn1PE_H245_SeqOfH245DataApplicationCapability (pctxt, &pvalue->centralizedData); + if (stat != ASN_OK) return stat; + } + + /* encode distributedData */ + + if (pvalue->m.distributedDataPresent) { + stat = asn1PE_H245_SeqOfH245DataApplicationCapability (pctxt, &pvalue->distributedData); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245MediaDistributionCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245MediaDistributionCapability (OOCTXT* pctxt, H245_SeqOfH245MediaDistributionCapability* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245MediaDistributionCapability (pctxt, ((H245MediaDistributionCapability*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultipointCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultipointCapability (OOCTXT* pctxt, H245MultipointCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode multicastCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multicastCapability); + if (stat != ASN_OK) return stat; + + /* encode multiUniCastConference */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multiUniCastConference); + if (stat != ASN_OK) return stat; + + /* encode mediaDistributionCapability */ + + stat = asn1PE_H245_SeqOfH245MediaDistributionCapability (pctxt, &pvalue->mediaDistributionCapability); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250Capability_mcCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H2250Capability_mcCapability (OOCTXT* pctxt, H245H2250Capability_mcCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode centralizedConferenceMC */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->centralizedConferenceMC); + if (stat != ASN_OK) return stat; + + /* encode decentralizedConferenceMC */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->decentralizedConferenceMC); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPPayloadType_payloadDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RTPPayloadType_payloadDescriptor (OOCTXT* pctxt, H245RTPPayloadType_payloadDescriptor* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandardIdentifier */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandardIdentifier); + if (stat != ASN_OK) return stat; + break; + + /* rfc_number */ + case 2: + if ( (pvalue->u.rfc_number >= 1 && pvalue->u.rfc_number <= 32768) ) { + extbit = 0; + } + else extbit = 1; + + /* extension bit */ + + encodeBit (pctxt, extbit); + + if (extbit) { + stat = encodeUnconsInteger (pctxt, pvalue->u.rfc_number); + if (stat != ASN_OK) return stat; + } + else { + stat = encodeConsInteger (pctxt, pvalue->u.rfc_number, 1, 32768); + if (stat != ASN_OK) return stat; + } + break; + + /* oid */ + case 3: + stat = encodeObjectIdentifier (pctxt, pvalue->u.oid); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPPayloadType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RTPPayloadType (OOCTXT* pctxt, H245RTPPayloadType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.payloadTypePresent); + + /* encode payloadDescriptor */ + + stat = asn1PE_H245RTPPayloadType_payloadDescriptor (pctxt, &pvalue->payloadDescriptor); + if (stat != ASN_OK) return stat; + + /* encode payloadType */ + + if (pvalue->m.payloadTypePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->payloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaPacketizationCapability_rtpPayloadType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MediaPacketizationCapability_rtpPayloadType (OOCTXT* pctxt, H245MediaPacketizationCapability_rtpPayloadType* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245RTPPayloadType (pctxt, ((H245RTPPayloadType*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaPacketizationCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MediaPacketizationCapability (OOCTXT* pctxt, H245MediaPacketizationCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.rtpPayloadTypePresent); + + encodeBit (pctxt, extbit); + + /* encode h261aVideoPacketization */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->h261aVideoPacketization); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpPayloadTypePresent); + /* encode extension elements */ + + if (pvalue->m.rtpPayloadTypePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245MediaPacketizationCapability_rtpPayloadType (&lctxt, &pvalue->rtpPayloadType); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* QOSMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245QOSMode (OOCTXT* pctxt, H245QOSMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* guaranteedQOS */ + case 1: + /* NULL */ + break; + + /* controlledLoad */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RSVPParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RSVPParameters (OOCTXT* pctxt, H245RSVPParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qosModePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.tokenRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bucketSizePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.peakRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.minPolicedPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.maxPktSizePresent); + + /* encode qosMode */ + + if (pvalue->m.qosModePresent) { + stat = asn1PE_H245QOSMode (pctxt, &pvalue->qosMode); + if (stat != ASN_OK) return stat; + } + + /* encode tokenRate */ + + if (pvalue->m.tokenRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->tokenRate, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + /* encode bucketSize */ + + if (pvalue->m.bucketSizePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->bucketSize, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + /* encode peakRate */ + + if (pvalue->m.peakRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->peakRate, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + /* encode minPoliced */ + + if (pvalue->m.minPolicedPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->minPoliced, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + /* encode maxPktSize */ + + if (pvalue->m.maxPktSizePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->maxPktSize, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ATMParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ATMParameters (OOCTXT* pctxt, H245ATMParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode maxNTUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxNTUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode atmUBR */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmUBR); + if (stat != ASN_OK) return stat; + + /* encode atmrtVBR */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmrtVBR); + if (stat != ASN_OK) return stat; + + /* encode atmnrtVBR */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmnrtVBR); + if (stat != ASN_OK) return stat; + + /* encode atmABR */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmABR); + if (stat != ASN_OK) return stat; + + /* encode atmCBR */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->atmCBR); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* QOSCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245QOSCapability (OOCTXT* pctxt, H245QOSCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rsvpParametersPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.atmParametersPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode rsvpParameters */ + + if (pvalue->m.rsvpParametersPresent) { + stat = asn1PE_H245RSVPParameters (pctxt, &pvalue->rsvpParameters); + if (stat != ASN_OK) return stat; + } + + /* encode atmParameters */ + + if (pvalue->m.atmParametersPresent) { + stat = asn1PE_H245ATMParameters (pctxt, &pvalue->atmParameters); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportCapability_qOSCapabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TransportCapability_qOSCapabilities (OOCTXT* pctxt, H245TransportCapability_qOSCapabilities* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245QOSCapability (pctxt, ((H245QOSCapability*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaTransportType_atm_AAL5_compressed */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MediaTransportType_atm_AAL5_compressed (OOCTXT* pctxt, H245MediaTransportType_atm_AAL5_compressed* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode variable_delta */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->variable_delta); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaTransportType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MediaTransportType (OOCTXT* pctxt, H245MediaTransportType* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* ip_UDP */ + case 1: + /* NULL */ + break; + + /* ip_TCP */ + case 2: + /* NULL */ + break; + + /* atm_AAL5_UNIDIR */ + case 3: + /* NULL */ + break; + + /* atm_AAL5_BIDIR */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* atm_AAL5_compressed */ + case 5: + stat = asn1PE_H245MediaTransportType_atm_AAL5_compressed (&lctxt, pvalue->u.atm_AAL5_compressed); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaChannelCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MediaChannelCapability (OOCTXT* pctxt, H245MediaChannelCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaTransportPresent); + + /* encode mediaTransport */ + + if (pvalue->m.mediaTransportPresent) { + stat = asn1PE_H245MediaTransportType (pctxt, &pvalue->mediaTransport); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportCapability_mediaChannelCapabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TransportCapability_mediaChannelCapabilities (OOCTXT* pctxt, H245TransportCapability_mediaChannelCapabilities* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245MediaChannelCapability (pctxt, ((H245MediaChannelCapability*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TransportCapability (OOCTXT* pctxt, H245TransportCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qOSCapabilitiesPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaChannelCapabilitiesPresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + /* encode qOSCapabilities */ + + if (pvalue->m.qOSCapabilitiesPresent) { + stat = asn1PE_H245TransportCapability_qOSCapabilities (pctxt, &pvalue->qOSCapabilities); + if (stat != ASN_OK) return stat; + } + + /* encode mediaChannelCapabilities */ + + if (pvalue->m.mediaChannelCapabilitiesPresent) { + stat = asn1PE_H245TransportCapability_mediaChannelCapabilities (pctxt, &pvalue->mediaChannelCapabilities); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyFrameMapping_frameSequence */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RTPH263VideoRedundancyFrameMapping_frameSequence (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping_frameSequence* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 0U, 255U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyFrameMapping */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RTPH263VideoRedundancyFrameMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyFrameMapping* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode threadNumber */ + + stat = encodeConsUnsigned (pctxt, pvalue->threadNumber, 0U, 15U); + if (stat != ASN_OK) return stat; + + /* encode frameSequence */ + + stat = asn1PE_H245RTPH263VideoRedundancyFrameMapping_frameSequence (pctxt, &pvalue->frameSequence); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_frameToThreadMapping_cust */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245RTPH263VideoRedundancyFrameMapping (pctxt, ((H245RTPH263VideoRedundancyFrameMapping*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_frameToThreadMapping */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_frameToThreadMapping* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* roundrobin */ + case 1: + /* NULL */ + break; + + /* custom */ + case 2: + stat = asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping_custom (pctxt, pvalue->u.custom); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding_containedThreads */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding_containedThreads (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding_containedThreads* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 0U, 15U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RTPH263VideoRedundancyEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RTPH263VideoRedundancyEncoding (OOCTXT* pctxt, H245RTPH263VideoRedundancyEncoding* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.containedThreadsPresent); + + /* encode numberOfThreads */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfThreads, 1U, 16U); + if (stat != ASN_OK) return stat; + + /* encode framesBetweenSyncPoints */ + + stat = encodeConsUnsigned (pctxt, pvalue->framesBetweenSyncPoints, 1U, 256U); + if (stat != ASN_OK) return stat; + + /* encode frameToThreadMapping */ + + stat = asn1PE_H245RTPH263VideoRedundancyEncoding_frameToThreadMapping (pctxt, &pvalue->frameToThreadMapping); + if (stat != ASN_OK) return stat; + + /* encode containedThreads */ + + if (pvalue->m.containedThreadsPresent) { + stat = asn1PE_H245RTPH263VideoRedundancyEncoding_containedThreads (pctxt, &pvalue->containedThreads); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingMethod */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingMethod (OOCTXT* pctxt, H245RedundancyEncodingMethod* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* rtpAudioRedundancyEncoding */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* rtpH263VideoRedundancyEncoding */ + case 3: + stat = asn1PE_H245RTPH263VideoRedundancyEncoding (&lctxt, pvalue->u.rtpH263VideoRedundancyEncoding); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityTableEntryNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CapabilityTableEntryNumber (OOCTXT* pctxt, H245CapabilityTableEntryNumber value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 1U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingCapability_secondaryEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingCapability_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingCapability_secondaryEncoding* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingCapability (OOCTXT* pctxt, H245RedundancyEncodingCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.secondaryEncodingPresent); + + /* encode redundancyEncodingMethod */ + + stat = asn1PE_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod); + if (stat != ASN_OK) return stat; + + /* encode primaryEncoding */ + + stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->primaryEncoding); + if (stat != ASN_OK) return stat; + + /* encode secondaryEncoding */ + + if (pvalue->m.secondaryEncodingPresent) { + stat = asn1PE_H245RedundancyEncodingCapability_secondaryEncoding (pctxt, &pvalue->secondaryEncoding); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250Capability_redundancyEncodingCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H2250Capability_redundancyEncodingCapability (OOCTXT* pctxt, H245H2250Capability_redundancyEncodingCapability* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245RedundancyEncodingCapability (pctxt, ((H245RedundancyEncodingCapability*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H2250Capability (OOCTXT* pctxt, H245H2250Capability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.transportCapabilityPresent || + pvalue->m.redundancyEncodingCapabilityPresent || + pvalue->m.logicalChannelSwitchingCapabilityPresent || + pvalue->m.t120DynamicPortCapabilityPresent); + + encodeBit (pctxt, extbit); + + /* encode maximumAudioDelayJitter */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumAudioDelayJitter, 0U, 1023U); + if (stat != ASN_OK) return stat; + + /* encode receiveMultipointCapability */ + + stat = asn1PE_H245MultipointCapability (pctxt, &pvalue->receiveMultipointCapability); + if (stat != ASN_OK) return stat; + + /* encode transmitMultipointCapability */ + + stat = asn1PE_H245MultipointCapability (pctxt, &pvalue->transmitMultipointCapability); + if (stat != ASN_OK) return stat; + + /* encode receiveAndTransmitMultipointCapability */ + + stat = asn1PE_H245MultipointCapability (pctxt, &pvalue->receiveAndTransmitMultipointCapability); + if (stat != ASN_OK) return stat; + + /* encode mcCapability */ + + stat = asn1PE_H245H2250Capability_mcCapability (pctxt, &pvalue->mcCapability); + if (stat != ASN_OK) return stat; + + /* encode rtcpVideoControlCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->rtcpVideoControlCapability); + if (stat != ASN_OK) return stat; + + /* encode mediaPacketizationCapability */ + + stat = asn1PE_H245MediaPacketizationCapability (pctxt, &pvalue->mediaPacketizationCapability); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 3); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.redundancyEncodingCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.logicalChannelSwitchingCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t120DynamicPortCapabilityPresent); + /* encode extension elements */ + + if (pvalue->m.transportCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245TransportCapability (&lctxt, &pvalue->transportCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.redundancyEncodingCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H2250Capability_redundancyEncodingCapability (&lctxt, &pvalue->redundancyEncodingCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.logicalChannelSwitchingCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->logicalChannelSwitchingCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.t120DynamicPortCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->t120DynamicPortCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexCapability (OOCTXT* pctxt, H245MultiplexCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* h222Capability */ + case 2: + stat = asn1PE_H245H222Capability (pctxt, pvalue->u.h222Capability); + if (stat != ASN_OK) return stat; + break; + + /* h223Capability */ + case 3: + stat = asn1PE_H245H223Capability (pctxt, pvalue->u.h223Capability); + if (stat != ASN_OK) return stat; + break; + + /* v76Capability */ + case 4: + stat = asn1PE_H245V76Capability (pctxt, pvalue->u.v76Capability); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* h2250Capability */ + case 5: + stat = asn1PE_H245H2250Capability (&lctxt, pvalue->u.h2250Capability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericMultiplexCapability */ + case 6: + stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericMultiplexCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H261VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H261VideoCapability (OOCTXT* pctxt, H245H261VideoCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.videoBadMBsCapPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifMPIPresent); + + /* encode qcifMPI */ + + if (pvalue->m.qcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->qcifMPI, 1U, 4U); + if (stat != ASN_OK) return stat; + + } + + /* encode cifMPI */ + + if (pvalue->m.cifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cifMPI, 1U, 4U); + if (stat != ASN_OK) return stat; + + } + + /* encode temporalSpatialTradeOffCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->temporalSpatialTradeOffCapability); + if (stat != ASN_OK) return stat; + + /* encode maxBitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 1U, 19200U); + if (stat != ASN_OK) return stat; + + /* encode stillImageTransmission */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->stillImageTransmission); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBadMBsCapPresent); + /* encode extension elements */ + + if (pvalue->m.videoBadMBsCapPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoBadMBsCap); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H262VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H262VideoCapability (OOCTXT* pctxt, H245H262VideoCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.videoBadMBsCapPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBitRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.vbvBufferSizePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.samplesPerLinePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.linesPerFramePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.framesPerSecondPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.luminanceSampleRatePresent); + + /* encode profileAndLevel_SPatML */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_SPatML); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_MPatLL */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_MPatLL); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_MPatML */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_MPatML); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_MPatH_14 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_MPatH_14); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_MPatHL */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_MPatHL); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_SNRatLL */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_SNRatLL); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_SNRatML */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_SNRatML); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_SpatialatH_14 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_SpatialatH_14); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_HPatML */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_HPatML); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_HPatH_14 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_HPatH_14); + if (stat != ASN_OK) return stat; + + /* encode profileAndLevel_HPatHL */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->profileAndLevel_HPatHL); + if (stat != ASN_OK) return stat; + + /* encode videoBitRate */ + + if (pvalue->m.videoBitRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->videoBitRate, 0U, 1073741823U); + if (stat != ASN_OK) return stat; + + } + + /* encode vbvBufferSize */ + + if (pvalue->m.vbvBufferSizePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->vbvBufferSize, 0U, 262143U); + if (stat != ASN_OK) return stat; + + } + + /* encode samplesPerLine */ + + if (pvalue->m.samplesPerLinePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->samplesPerLine, 0U, 16383U); + if (stat != ASN_OK) return stat; + + } + + /* encode linesPerFrame */ + + if (pvalue->m.linesPerFramePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->linesPerFrame, 0U, 16383U); + if (stat != ASN_OK) return stat; + + } + + /* encode framesPerSecond */ + + if (pvalue->m.framesPerSecondPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->framesPerSecond, 0U, 15U); + if (stat != ASN_OK) return stat; + + } + + /* encode luminanceSampleRate */ + + if (pvalue->m.luminanceSampleRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBadMBsCapPresent); + /* encode extension elements */ + + if (pvalue->m.videoBadMBsCapPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoBadMBsCap); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransparencyParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TransparencyParameters (OOCTXT* pctxt, H245TransparencyParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode presentationOrder */ + + stat = encodeConsUnsigned (pctxt, pvalue->presentationOrder, 1U, 256U); + if (stat != ASN_OK) return stat; + + /* encode offset_x */ + + stat = encodeConsInteger (pctxt, pvalue->offset_x, -262144, 262143); + if (stat != ASN_OK) return stat; + + /* encode offset_y */ + + stat = encodeConsInteger (pctxt, pvalue->offset_y, -262144, 262143); + if (stat != ASN_OK) return stat; + + /* encode scale_x */ + + stat = encodeConsUnsigned (pctxt, pvalue->scale_x, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode scale_y */ + + stat = encodeConsUnsigned (pctxt, pvalue->scale_y, 1U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection_additionalPictureMemory */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RefPictureSelection_additionalPictureMemory (OOCTXT* pctxt, H245RefPictureSelection_additionalPictureMemory* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sqcifAdditionalPictureMemoryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifAdditionalPictureMemoryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifAdditionalPictureMemoryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif4AdditionalPictureMemoryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif16AdditionalPictureMemoryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bigCpfAdditionalPictureMemoryPresent); + + /* encode sqcifAdditionalPictureMemory */ + + if (pvalue->m.sqcifAdditionalPictureMemoryPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->sqcifAdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + + } + + /* encode qcifAdditionalPictureMemory */ + + if (pvalue->m.qcifAdditionalPictureMemoryPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->qcifAdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + + } + + /* encode cifAdditionalPictureMemory */ + + if (pvalue->m.cifAdditionalPictureMemoryPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cifAdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + + } + + /* encode cif4AdditionalPictureMemory */ + + if (pvalue->m.cif4AdditionalPictureMemoryPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cif4AdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + + } + + /* encode cif16AdditionalPictureMemory */ + + if (pvalue->m.cif16AdditionalPictureMemoryPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cif16AdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + + } + + /* encode bigCpfAdditionalPictureMemory */ + + if (pvalue->m.bigCpfAdditionalPictureMemoryPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->bigCpfAdditionalPictureMemory, 1U, 256U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection_videoBackChannelSend */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RefPictureSelection_videoBackChannelSend (OOCTXT* pctxt, H245RefPictureSelection_videoBackChannelSend* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* none */ + case 1: + /* NULL */ + break; + + /* ackMessageOnly */ + case 2: + /* NULL */ + break; + + /* nackMessageOnly */ + case 3: + /* NULL */ + break; + + /* ackOrNackMessageOnly */ + case 4: + /* NULL */ + break; + + /* ackAndNackMessage */ + case 5: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection_enhancedReferencePicSelect_subPictur */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode mpuHorizMBs */ + + stat = encodeConsUnsigned (pctxt, pvalue->mpuHorizMBs, 1U, 128U); + if (stat != ASN_OK) return stat; + + /* encode mpuVertMBs */ + + stat = encodeConsUnsigned (pctxt, pvalue->mpuVertMBs, 1U, 72U); + if (stat != ASN_OK) return stat; + + /* encode mpuTotalNumber */ + + stat = encodeConsUnsigned (pctxt, pvalue->mpuTotalNumber, 1U, 65536U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection_enhancedReferencePicSelect */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RefPictureSelection_enhancedReferencePicSelect (OOCTXT* pctxt, H245RefPictureSelection_enhancedReferencePicSelect* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.subPictureRemovalParametersPresent); + + /* encode subPictureRemovalParameters */ + + if (pvalue->m.subPictureRemovalParametersPresent) { + stat = asn1PE_H245RefPictureSelection_enhancedReferencePicSelect_subPictureRemovalParameters (pctxt, &pvalue->subPictureRemovalParameters); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RefPictureSelection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RefPictureSelection (OOCTXT* pctxt, H245RefPictureSelection* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.enhancedReferencePicSelectPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.additionalPictureMemoryPresent); + + /* encode additionalPictureMemory */ + + if (pvalue->m.additionalPictureMemoryPresent) { + stat = asn1PE_H245RefPictureSelection_additionalPictureMemory (pctxt, &pvalue->additionalPictureMemory); + if (stat != ASN_OK) return stat; + } + + /* encode videoMux */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoMux); + if (stat != ASN_OK) return stat; + + /* encode videoBackChannelSend */ + + stat = asn1PE_H245RefPictureSelection_videoBackChannelSend (pctxt, &pvalue->videoBackChannelSend); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.enhancedReferencePicSelectPresent); + /* encode extension elements */ + + if (pvalue->m.enhancedReferencePicSelectPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245RefPictureSelection_enhancedReferencePicSelect (&lctxt, &pvalue->enhancedReferencePicSelect); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureClockFrequency */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureClockFrequency (OOCTXT* pctxt, H245CustomPictureClockFrequency* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sqcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif4MPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif16MPIPresent); + + /* encode clockConversionCode */ + + stat = encodeConsUnsigned (pctxt, pvalue->clockConversionCode, 1000U, 1001U); + if (stat != ASN_OK) return stat; + + /* encode clockDivisor */ + + stat = encodeConsUnsigned (pctxt, pvalue->clockDivisor, 1U, 127U); + if (stat != ASN_OK) return stat; + + /* encode sqcifMPI */ + + if (pvalue->m.sqcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->sqcifMPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + + } + + /* encode qcifMPI */ + + if (pvalue->m.qcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->qcifMPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + + } + + /* encode cifMPI */ + + if (pvalue->m.cifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cifMPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + + } + + /* encode cif4MPI */ + + if (pvalue->m.cif4MPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cif4MPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + + } + + /* encode cif16MPI */ + + if (pvalue->m.cif16MPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cif16MPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263Options_customPictureClockFrequency */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263Options_customPictureClockFrequency (OOCTXT* pctxt, H245H263Options_customPictureClockFrequency* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245CustomPictureClockFrequency (pctxt, ((H245CustomPictureClockFrequency*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI_customPCF_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureFormat_mPI_customPCF_element (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF_element* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode clockConversionCode */ + + stat = encodeConsUnsigned (pctxt, pvalue->clockConversionCode, 1000U, 1001U); + if (stat != ASN_OK) return stat; + + /* encode clockDivisor */ + + stat = encodeConsUnsigned (pctxt, pvalue->clockDivisor, 1U, 127U); + if (stat != ASN_OK) return stat; + + /* encode customMPI */ + + stat = encodeConsUnsigned (pctxt, pvalue->customMPI, 1U, 2048U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI_customPCF */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureFormat_mPI_customPCF (OOCTXT* pctxt, H245CustomPictureFormat_mPI_customPCF* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245CustomPictureFormat_mPI_customPCF_element (pctxt, ((H245CustomPictureFormat_mPI_customPCF_element*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_mPI */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureFormat_mPI (OOCTXT* pctxt, H245CustomPictureFormat_mPI* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.standardMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.customPCFPresent); + + /* encode standardMPI */ + + if (pvalue->m.standardMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->standardMPI, 1U, 31U); + if (stat != ASN_OK) return stat; + + } + + /* encode customPCF */ + + if (pvalue->m.customPCFPresent) { + stat = asn1PE_H245CustomPictureFormat_mPI_customPCF (pctxt, &pvalue->customPCF); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_pixelAspectCo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = encodeConsUnsigned (pctxt, pvalue->elem[xx1], 1U, 14U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_extendedPAR_e */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode width */ + + stat = encodeConsUnsigned (pctxt, pvalue->width, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode height */ + + stat = encodeConsUnsigned (pctxt, pvalue->height, 1U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation_extendedPAR */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation_extendedPAR* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element (pctxt, ((H245CustomPictureFormat_pixelAspectInformation_extendedPAR_element*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat_pixelAspectInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureFormat_pixelAspectInformation (OOCTXT* pctxt, H245CustomPictureFormat_pixelAspectInformation* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* anyPixelAspectRatio */ + case 1: + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->u.anyPixelAspectRatio); + if (stat != ASN_OK) return stat; + break; + + /* pixelAspectCode */ + case 2: + stat = asn1PE_H245CustomPictureFormat_pixelAspectInformation_pixelAspectCode (pctxt, pvalue->u.pixelAspectCode); + if (stat != ASN_OK) return stat; + break; + + /* extendedPAR */ + case 3: + stat = asn1PE_H245CustomPictureFormat_pixelAspectInformation_extendedPAR (pctxt, pvalue->u.extendedPAR); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CustomPictureFormat */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CustomPictureFormat (OOCTXT* pctxt, H245CustomPictureFormat* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode maxCustomPictureWidth */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxCustomPictureWidth, 1U, 2048U); + if (stat != ASN_OK) return stat; + + /* encode maxCustomPictureHeight */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxCustomPictureHeight, 1U, 2048U); + if (stat != ASN_OK) return stat; + + /* encode minCustomPictureWidth */ + + stat = encodeConsUnsigned (pctxt, pvalue->minCustomPictureWidth, 1U, 2048U); + if (stat != ASN_OK) return stat; + + /* encode minCustomPictureHeight */ + + stat = encodeConsUnsigned (pctxt, pvalue->minCustomPictureHeight, 1U, 2048U); + if (stat != ASN_OK) return stat; + + /* encode mPI */ + + stat = asn1PE_H245CustomPictureFormat_mPI (pctxt, &pvalue->mPI); + if (stat != ASN_OK) return stat; + + /* encode pixelAspectInformation */ + + stat = asn1PE_H245CustomPictureFormat_pixelAspectInformation (pctxt, &pvalue->pixelAspectInformation); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263Options_customPictureFormat */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263Options_customPictureFormat (OOCTXT* pctxt, H245H263Options_customPictureFormat* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245CustomPictureFormat (pctxt, ((H245CustomPictureFormat*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263Version3Options */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263Version3Options (OOCTXT* pctxt, H245H263Version3Options* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode dataPartitionedSlices */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dataPartitionedSlices); + if (stat != ASN_OK) return stat; + + /* encode fixedPointIDCT0 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fixedPointIDCT0); + if (stat != ASN_OK) return stat; + + /* encode interlacedFields */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->interlacedFields); + if (stat != ASN_OK) return stat; + + /* encode currentPictureHeaderRepetition */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->currentPictureHeaderRepetition); + if (stat != ASN_OK) return stat; + + /* encode previousPictureHeaderRepetition */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->previousPictureHeaderRepetition); + if (stat != ASN_OK) return stat; + + /* encode nextPictureHeaderRepetition */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->nextPictureHeaderRepetition); + if (stat != ASN_OK) return stat; + + /* encode pictureNumber */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->pictureNumber); + if (stat != ASN_OK) return stat; + + /* encode spareReferencePictures */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->spareReferencePictures); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263ModeComboFlags */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263ModeComboFlags (OOCTXT* pctxt, H245H263ModeComboFlags* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.enhancedReferencePicSelectPresent || + pvalue->m.h263Version3OptionsPresent); + + encodeBit (pctxt, extbit); + + /* encode unrestrictedVector */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unrestrictedVector); + if (stat != ASN_OK) return stat; + + /* encode arithmeticCoding */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->arithmeticCoding); + if (stat != ASN_OK) return stat; + + /* encode advancedPrediction */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedPrediction); + if (stat != ASN_OK) return stat; + + /* encode pbFrames */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->pbFrames); + if (stat != ASN_OK) return stat; + + /* encode advancedIntraCodingMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedIntraCodingMode); + if (stat != ASN_OK) return stat; + + /* encode deblockingFilterMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->deblockingFilterMode); + if (stat != ASN_OK) return stat; + + /* encode unlimitedMotionVectors */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unlimitedMotionVectors); + if (stat != ASN_OK) return stat; + + /* encode slicesInOrder_NonRect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesInOrder_NonRect); + if (stat != ASN_OK) return stat; + + /* encode slicesInOrder_Rect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesInOrder_Rect); + if (stat != ASN_OK) return stat; + + /* encode slicesNoOrder_NonRect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesNoOrder_NonRect); + if (stat != ASN_OK) return stat; + + /* encode slicesNoOrder_Rect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesNoOrder_Rect); + if (stat != ASN_OK) return stat; + + /* encode improvedPBFramesMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->improvedPBFramesMode); + if (stat != ASN_OK) return stat; + + /* encode referencePicSelect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->referencePicSelect); + if (stat != ASN_OK) return stat; + + /* encode dynamicPictureResizingByFour */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicPictureResizingByFour); + if (stat != ASN_OK) return stat; + + /* encode dynamicPictureResizingSixteenthPel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicPictureResizingSixteenthPel); + if (stat != ASN_OK) return stat; + + /* encode dynamicWarpingHalfPel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicWarpingHalfPel); + if (stat != ASN_OK) return stat; + + /* encode dynamicWarpingSixteenthPel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicWarpingSixteenthPel); + if (stat != ASN_OK) return stat; + + /* encode reducedResolutionUpdate */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->reducedResolutionUpdate); + if (stat != ASN_OK) return stat; + + /* encode independentSegmentDecoding */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->independentSegmentDecoding); + if (stat != ASN_OK) return stat; + + /* encode alternateInterVLCMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alternateInterVLCMode); + if (stat != ASN_OK) return stat; + + /* encode modifiedQuantizationMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->modifiedQuantizationMode); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.enhancedReferencePicSelectPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263Version3OptionsPresent); + /* encode extension elements */ + + if (pvalue->m.enhancedReferencePicSelectPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->enhancedReferencePicSelect); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h263Version3OptionsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H263Version3Options (&lctxt, &pvalue->h263Version3Options); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263VideoModeCombos_h263VideoCoupledModes */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263VideoModeCombos_h263VideoCoupledModes (OOCTXT* pctxt, H245H263VideoModeCombos_h263VideoCoupledModes* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245H263ModeComboFlags (pctxt, ((H245H263ModeComboFlags*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263VideoModeCombos */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263VideoModeCombos (OOCTXT* pctxt, H245H263VideoModeCombos* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode h263VideoUncoupledModes */ + + stat = asn1PE_H245H263ModeComboFlags (pctxt, &pvalue->h263VideoUncoupledModes); + if (stat != ASN_OK) return stat; + + /* encode h263VideoCoupledModes */ + + stat = asn1PE_H245H263VideoModeCombos_h263VideoCoupledModes (pctxt, &pvalue->h263VideoCoupledModes); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263Options_modeCombos */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263Options_modeCombos (OOCTXT* pctxt, H245H263Options_modeCombos* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245H263VideoModeCombos (pctxt, ((H245H263VideoModeCombos*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263Options */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263Options (OOCTXT* pctxt, H245H263Options* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.videoBadMBsCapPresent || + pvalue->m.h263Version3OptionsPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.transparencyParametersPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.refPictureSelectionPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.customPictureClockFrequencyPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.customPictureFormatPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.modeCombosPresent); + + /* encode advancedIntraCodingMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedIntraCodingMode); + if (stat != ASN_OK) return stat; + + /* encode deblockingFilterMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->deblockingFilterMode); + if (stat != ASN_OK) return stat; + + /* encode improvedPBFramesMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->improvedPBFramesMode); + if (stat != ASN_OK) return stat; + + /* encode unlimitedMotionVectors */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unlimitedMotionVectors); + if (stat != ASN_OK) return stat; + + /* encode fullPictureFreeze */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fullPictureFreeze); + if (stat != ASN_OK) return stat; + + /* encode partialPictureFreezeAndRelease */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partialPictureFreezeAndRelease); + if (stat != ASN_OK) return stat; + + /* encode resizingPartPicFreezeAndRelease */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->resizingPartPicFreezeAndRelease); + if (stat != ASN_OK) return stat; + + /* encode fullPictureSnapshot */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fullPictureSnapshot); + if (stat != ASN_OK) return stat; + + /* encode partialPictureSnapshot */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partialPictureSnapshot); + if (stat != ASN_OK) return stat; + + /* encode videoSegmentTagging */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->videoSegmentTagging); + if (stat != ASN_OK) return stat; + + /* encode progressiveRefinement */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->progressiveRefinement); + if (stat != ASN_OK) return stat; + + /* encode dynamicPictureResizingByFour */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicPictureResizingByFour); + if (stat != ASN_OK) return stat; + + /* encode dynamicPictureResizingSixteenthPel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicPictureResizingSixteenthPel); + if (stat != ASN_OK) return stat; + + /* encode dynamicWarpingHalfPel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicWarpingHalfPel); + if (stat != ASN_OK) return stat; + + /* encode dynamicWarpingSixteenthPel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->dynamicWarpingSixteenthPel); + if (stat != ASN_OK) return stat; + + /* encode independentSegmentDecoding */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->independentSegmentDecoding); + if (stat != ASN_OK) return stat; + + /* encode slicesInOrder_NonRect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesInOrder_NonRect); + if (stat != ASN_OK) return stat; + + /* encode slicesInOrder_Rect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesInOrder_Rect); + if (stat != ASN_OK) return stat; + + /* encode slicesNoOrder_NonRect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesNoOrder_NonRect); + if (stat != ASN_OK) return stat; + + /* encode slicesNoOrder_Rect */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->slicesNoOrder_Rect); + if (stat != ASN_OK) return stat; + + /* encode alternateInterVLCMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alternateInterVLCMode); + if (stat != ASN_OK) return stat; + + /* encode modifiedQuantizationMode */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->modifiedQuantizationMode); + if (stat != ASN_OK) return stat; + + /* encode reducedResolutionUpdate */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->reducedResolutionUpdate); + if (stat != ASN_OK) return stat; + + /* encode transparencyParameters */ + + if (pvalue->m.transparencyParametersPresent) { + stat = asn1PE_H245TransparencyParameters (pctxt, &pvalue->transparencyParameters); + if (stat != ASN_OK) return stat; + } + + /* encode separateVideoBackChannel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->separateVideoBackChannel); + if (stat != ASN_OK) return stat; + + /* encode refPictureSelection */ + + if (pvalue->m.refPictureSelectionPresent) { + stat = asn1PE_H245RefPictureSelection (pctxt, &pvalue->refPictureSelection); + if (stat != ASN_OK) return stat; + } + + /* encode customPictureClockFrequency */ + + if (pvalue->m.customPictureClockFrequencyPresent) { + stat = asn1PE_H245H263Options_customPictureClockFrequency (pctxt, &pvalue->customPictureClockFrequency); + if (stat != ASN_OK) return stat; + } + + /* encode customPictureFormat */ + + if (pvalue->m.customPictureFormatPresent) { + stat = asn1PE_H245H263Options_customPictureFormat (pctxt, &pvalue->customPictureFormat); + if (stat != ASN_OK) return stat; + } + + /* encode modeCombos */ + + if (pvalue->m.modeCombosPresent) { + stat = asn1PE_H245H263Options_modeCombos (pctxt, &pvalue->modeCombos); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBadMBsCapPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263Version3OptionsPresent); + /* encode extension elements */ + + if (pvalue->m.videoBadMBsCapPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoBadMBsCap); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h263Version3OptionsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H263Version3Options (&lctxt, &pvalue->h263Version3Options); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnhancementOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EnhancementOptions (OOCTXT* pctxt, H245EnhancementOptions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sqcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif4MPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif16MPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowSqcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowQcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCif4MPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCif16MPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263OptionsPresent); + + /* encode sqcifMPI */ + + if (pvalue->m.sqcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->sqcifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode qcifMPI */ + + if (pvalue->m.qcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->qcifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode cifMPI */ + + if (pvalue->m.cifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode cif4MPI */ + + if (pvalue->m.cif4MPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cif4MPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode cif16MPI */ + + if (pvalue->m.cif16MPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cif16MPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode maxBitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 1U, 192400U); + if (stat != ASN_OK) return stat; + + /* encode unrestrictedVector */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unrestrictedVector); + if (stat != ASN_OK) return stat; + + /* encode arithmeticCoding */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->arithmeticCoding); + if (stat != ASN_OK) return stat; + + /* encode temporalSpatialTradeOffCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->temporalSpatialTradeOffCapability); + if (stat != ASN_OK) return stat; + + /* encode slowSqcifMPI */ + + if (pvalue->m.slowSqcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->slowSqcifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + + } + + /* encode slowQcifMPI */ + + if (pvalue->m.slowQcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->slowQcifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + + } + + /* encode slowCifMPI */ + + if (pvalue->m.slowCifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->slowCifMPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + + } + + /* encode slowCif4MPI */ + + if (pvalue->m.slowCif4MPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->slowCif4MPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + + } + + /* encode slowCif16MPI */ + + if (pvalue->m.slowCif16MPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->slowCif16MPI, 1U, 3600U); + if (stat != ASN_OK) return stat; + + } + + /* encode errorCompensation */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->errorCompensation); + if (stat != ASN_OK) return stat; + + /* encode h263Options */ + + if (pvalue->m.h263OptionsPresent) { + stat = asn1PE_H245H263Options (pctxt, &pvalue->h263Options); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_snrEnhancement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EnhancementLayerInfo_snrEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_snrEnhancement* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245EnhancementOptions (pctxt, ((H245EnhancementOptions*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_spatialEnhancement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EnhancementLayerInfo_spatialEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_spatialEnhancement* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245EnhancementOptions (pctxt, ((H245EnhancementOptions*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* BEnhancementParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245BEnhancementParameters (OOCTXT* pctxt, H245BEnhancementParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode enhancementOptions */ + + stat = asn1PE_H245EnhancementOptions (pctxt, &pvalue->enhancementOptions); + if (stat != ASN_OK) return stat; + + /* encode numberOfBPictures */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfBPictures, 1U, 64U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo_bPictureEnhancement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EnhancementLayerInfo_bPictureEnhancement (OOCTXT* pctxt, H245EnhancementLayerInfo_bPictureEnhancement* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 14, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245BEnhancementParameters (pctxt, ((H245BEnhancementParameters*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EnhancementLayerInfo */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EnhancementLayerInfo (OOCTXT* pctxt, H245EnhancementLayerInfo* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.snrEnhancementPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.spatialEnhancementPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bPictureEnhancementPresent); + + /* encode baseBitRateConstrained */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->baseBitRateConstrained); + if (stat != ASN_OK) return stat; + + /* encode snrEnhancement */ + + if (pvalue->m.snrEnhancementPresent) { + stat = asn1PE_H245EnhancementLayerInfo_snrEnhancement (pctxt, &pvalue->snrEnhancement); + if (stat != ASN_OK) return stat; + } + + /* encode spatialEnhancement */ + + if (pvalue->m.spatialEnhancementPresent) { + stat = asn1PE_H245EnhancementLayerInfo_spatialEnhancement (pctxt, &pvalue->spatialEnhancement); + if (stat != ASN_OK) return stat; + } + + /* encode bPictureEnhancement */ + + if (pvalue->m.bPictureEnhancementPresent) { + stat = asn1PE_H245EnhancementLayerInfo_bPictureEnhancement (pctxt, &pvalue->bPictureEnhancement); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263VideoCapability (OOCTXT* pctxt, H245H263VideoCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.slowSqcifMPIPresent || + pvalue->m.slowQcifMPIPresent || + pvalue->m.slowCifMPIPresent || + pvalue->m.slowCif4MPIPresent || + pvalue->m.slowCif16MPIPresent || + pvalue->m.errorCompensationPresent || + pvalue->m.enhancementLayerInfoPresent || + pvalue->m.h263OptionsPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sqcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qcifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cifMPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif4MPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.cif16MPIPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.hrd_BPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.bppMaxKbPresent); + + /* encode sqcifMPI */ + + if (pvalue->m.sqcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->sqcifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode qcifMPI */ + + if (pvalue->m.qcifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->qcifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode cifMPI */ + + if (pvalue->m.cifMPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cifMPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode cif4MPI */ + + if (pvalue->m.cif4MPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cif4MPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode cif16MPI */ + + if (pvalue->m.cif16MPIPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->cif16MPI, 1U, 32U); + if (stat != ASN_OK) return stat; + + } + + /* encode maxBitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxBitRate, 1U, 192400U); + if (stat != ASN_OK) return stat; + + /* encode unrestrictedVector */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unrestrictedVector); + if (stat != ASN_OK) return stat; + + /* encode arithmeticCoding */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->arithmeticCoding); + if (stat != ASN_OK) return stat; + + /* encode advancedPrediction */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedPrediction); + if (stat != ASN_OK) return stat; + + /* encode pbFrames */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->pbFrames); + if (stat != ASN_OK) return stat; + + /* encode temporalSpatialTradeOffCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->temporalSpatialTradeOffCapability); + if (stat != ASN_OK) return stat; + + /* encode hrd_B */ + + if (pvalue->m.hrd_BPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->hrd_B, 0U, 524287U); + if (stat != ASN_OK) return stat; + + } + + /* encode bppMaxKb */ + + if (pvalue->m.bppMaxKbPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->bppMaxKb, 0U, 65535U); + if (stat != ASN_OK) return stat; + + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 7); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowSqcifMPIPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowQcifMPIPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCifMPIPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCif4MPIPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.slowCif16MPIPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.errorCompensationPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.enhancementLayerInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263OptionsPresent); + /* encode extension elements */ + + if (pvalue->m.slowSqcifMPIPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->slowSqcifMPI, 1U, 3600U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.slowQcifMPIPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->slowQcifMPI, 1U, 3600U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.slowCifMPIPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->slowCifMPI, 1U, 3600U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.slowCif4MPIPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->slowCif4MPI, 1U, 3600U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.slowCif16MPIPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->slowCif16MPI, 1U, 3600U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.errorCompensationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->errorCompensation); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.enhancementLayerInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245EnhancementLayerInfo (&lctxt, &pvalue->enhancementLayerInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h263OptionsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H263Options (&lctxt, &pvalue->h263Options); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS11172VideoCapability (OOCTXT* pctxt, H245IS11172VideoCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.videoBadMBsCapPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBitRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.vbvBufferSizePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.samplesPerLinePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.linesPerFramePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.pictureRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.luminanceSampleRatePresent); + + /* encode constrainedBitstream */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->constrainedBitstream); + if (stat != ASN_OK) return stat; + + /* encode videoBitRate */ + + if (pvalue->m.videoBitRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->videoBitRate, 0U, 1073741823U); + if (stat != ASN_OK) return stat; + + } + + /* encode vbvBufferSize */ + + if (pvalue->m.vbvBufferSizePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->vbvBufferSize, 0U, 262143U); + if (stat != ASN_OK) return stat; + + } + + /* encode samplesPerLine */ + + if (pvalue->m.samplesPerLinePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->samplesPerLine, 0U, 16383U); + if (stat != ASN_OK) return stat; + + } + + /* encode linesPerFrame */ + + if (pvalue->m.linesPerFramePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->linesPerFrame, 0U, 16383U); + if (stat != ASN_OK) return stat; + + } + + /* encode pictureRate */ + + if (pvalue->m.pictureRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->pictureRate, 0U, 15U); + if (stat != ASN_OK) return stat; + + } + + /* encode luminanceSampleRate */ + + if (pvalue->m.luminanceSampleRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBadMBsCapPresent); + /* encode extension elements */ + + if (pvalue->m.videoBadMBsCapPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoBadMBsCap); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VideoCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VideoCapability (OOCTXT* pctxt, H245VideoCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* h261VideoCapability */ + case 2: + stat = asn1PE_H245H261VideoCapability (pctxt, pvalue->u.h261VideoCapability); + if (stat != ASN_OK) return stat; + break; + + /* h262VideoCapability */ + case 3: + stat = asn1PE_H245H262VideoCapability (pctxt, pvalue->u.h262VideoCapability); + if (stat != ASN_OK) return stat; + break; + + /* h263VideoCapability */ + case 4: + stat = asn1PE_H245H263VideoCapability (pctxt, pvalue->u.h263VideoCapability); + if (stat != ASN_OK) return stat; + break; + + /* is11172VideoCapability */ + case 5: + stat = asn1PE_H245IS11172VideoCapability (pctxt, pvalue->u.is11172VideoCapability); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* genericVideoCapability */ + case 6: + stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericVideoCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AudioCapability_g7231 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245AudioCapability_g7231 (OOCTXT* pctxt, H245AudioCapability_g7231* pvalue) +{ + int stat = ASN_OK; + + /* encode maxAl_sduAudioFrames */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxAl_sduAudioFrames, 1U, 256U); + if (stat != ASN_OK) return stat; + + /* encode silenceSuppression */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->silenceSuppression); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS11172AudioCapability (OOCTXT* pctxt, H245IS11172AudioCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode audioLayer1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer1); + if (stat != ASN_OK) return stat; + + /* encode audioLayer2 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer2); + if (stat != ASN_OK) return stat; + + /* encode audioLayer3 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer3); + if (stat != ASN_OK) return stat; + + /* encode audioSampling32k */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling32k); + if (stat != ASN_OK) return stat; + + /* encode audioSampling44k1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling44k1); + if (stat != ASN_OK) return stat; + + /* encode audioSampling48k */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling48k); + if (stat != ASN_OK) return stat; + + /* encode singleChannel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->singleChannel); + if (stat != ASN_OK) return stat; + + /* encode twoChannels */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->twoChannels); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 448U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS13818AudioCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS13818AudioCapability (OOCTXT* pctxt, H245IS13818AudioCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode audioLayer1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer1); + if (stat != ASN_OK) return stat; + + /* encode audioLayer2 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer2); + if (stat != ASN_OK) return stat; + + /* encode audioLayer3 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioLayer3); + if (stat != ASN_OK) return stat; + + /* encode audioSampling16k */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling16k); + if (stat != ASN_OK) return stat; + + /* encode audioSampling22k05 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling22k05); + if (stat != ASN_OK) return stat; + + /* encode audioSampling24k */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling24k); + if (stat != ASN_OK) return stat; + + /* encode audioSampling32k */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling32k); + if (stat != ASN_OK) return stat; + + /* encode audioSampling44k1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling44k1); + if (stat != ASN_OK) return stat; + + /* encode audioSampling48k */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioSampling48k); + if (stat != ASN_OK) return stat; + + /* encode singleChannel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->singleChannel); + if (stat != ASN_OK) return stat; + + /* encode twoChannels */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->twoChannels); + if (stat != ASN_OK) return stat; + + /* encode threeChannels2_1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->threeChannels2_1); + if (stat != ASN_OK) return stat; + + /* encode threeChannels3_0 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->threeChannels3_0); + if (stat != ASN_OK) return stat; + + /* encode fourChannels2_0_2_0 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fourChannels2_0_2_0); + if (stat != ASN_OK) return stat; + + /* encode fourChannels2_2 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fourChannels2_2); + if (stat != ASN_OK) return stat; + + /* encode fourChannels3_1 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fourChannels3_1); + if (stat != ASN_OK) return stat; + + /* encode fiveChannels3_0_2_0 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fiveChannels3_0_2_0); + if (stat != ASN_OK) return stat; + + /* encode fiveChannels3_2 */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->fiveChannels3_2); + if (stat != ASN_OK) return stat; + + /* encode lowFrequencyEnhancement */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->lowFrequencyEnhancement); + if (stat != ASN_OK) return stat; + + /* encode multilingual */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multilingual); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 1130U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* G7231AnnexCCapability_g723AnnexCAudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245G7231AnnexCCapability_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCCapability_g723AnnexCAudioMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode highRateMode0 */ + + stat = encodeConsUnsigned (pctxt, pvalue->highRateMode0, 27U, 78U); + if (stat != ASN_OK) return stat; + + /* encode highRateMode1 */ + + stat = encodeConsUnsigned (pctxt, pvalue->highRateMode1, 27U, 78U); + if (stat != ASN_OK) return stat; + + /* encode lowRateMode0 */ + + stat = encodeConsUnsigned (pctxt, pvalue->lowRateMode0, 23U, 66U); + if (stat != ASN_OK) return stat; + + /* encode lowRateMode1 */ + + stat = encodeConsUnsigned (pctxt, pvalue->lowRateMode1, 23U, 66U); + if (stat != ASN_OK) return stat; + + /* encode sidMode0 */ + + stat = encodeConsUnsigned (pctxt, pvalue->sidMode0, 6U, 17U); + if (stat != ASN_OK) return stat; + + /* encode sidMode1 */ + + stat = encodeConsUnsigned (pctxt, pvalue->sidMode1, 6U, 17U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* G7231AnnexCCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245G7231AnnexCCapability (OOCTXT* pctxt, H245G7231AnnexCCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.g723AnnexCAudioModePresent); + + /* encode maxAl_sduAudioFrames */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxAl_sduAudioFrames, 1U, 256U); + if (stat != ASN_OK) return stat; + + /* encode silenceSuppression */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->silenceSuppression); + if (stat != ASN_OK) return stat; + + /* encode g723AnnexCAudioMode */ + + if (pvalue->m.g723AnnexCAudioModePresent) { + stat = asn1PE_H245G7231AnnexCCapability_g723AnnexCAudioMode (pctxt, &pvalue->g723AnnexCAudioMode); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* GSMAudioCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245GSMAudioCapability (OOCTXT* pctxt, H245GSMAudioCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode audioUnitSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->audioUnitSize, 1U, 256U); + if (stat != ASN_OK) return stat; + + /* encode comfortNoise */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->comfortNoise); + if (stat != ASN_OK) return stat; + + /* encode scrambled */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->scrambled); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* G729Extensions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245G729Extensions (OOCTXT* pctxt, H245G729Extensions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.audioUnitPresent); + + /* encode audioUnit */ + + if (pvalue->m.audioUnitPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->audioUnit, 1U, 256U); + if (stat != ASN_OK) return stat; + + } + + /* encode annexA */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexA); + if (stat != ASN_OK) return stat; + + /* encode annexB */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexB); + if (stat != ASN_OK) return stat; + + /* encode annexD */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexD); + if (stat != ASN_OK) return stat; + + /* encode annexE */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexE); + if (stat != ASN_OK) return stat; + + /* encode annexF */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexF); + if (stat != ASN_OK) return stat; + + /* encode annexG */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexG); + if (stat != ASN_OK) return stat; + + /* encode annexH */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->annexH); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VBDCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VBDCapability (OOCTXT* pctxt, H245VBDCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = asn1PE_H245AudioCapability (pctxt, (H245AudioCapability*)pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NoPTAudioTelephonyEventCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NoPTAudioTelephonyEventCapability (OOCTXT* pctxt, H245NoPTAudioTelephonyEventCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode audioTelephoneEvent */ + + stat = encodeVarWidthCharString (pctxt, pvalue->audioTelephoneEvent); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NoPTAudioToneCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NoPTAudioToneCapability (OOCTXT* pctxt, H245NoPTAudioToneCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + return (stat); +} + +/**************************************************************/ +/* */ +/* AudioCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245AudioCapability (OOCTXT* pctxt, H245AudioCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 14); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 13); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* g711Alaw64k */ + case 2: + stat = encodeConsUnsigned (pctxt, pvalue->u.g711Alaw64k, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g711Alaw56k */ + case 3: + stat = encodeConsUnsigned (pctxt, pvalue->u.g711Alaw56k, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g711Ulaw64k */ + case 4: + stat = encodeConsUnsigned (pctxt, pvalue->u.g711Ulaw64k, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g711Ulaw56k */ + case 5: + stat = encodeConsUnsigned (pctxt, pvalue->u.g711Ulaw56k, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g722_64k */ + case 6: + stat = encodeConsUnsigned (pctxt, pvalue->u.g722_64k, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g722_56k */ + case 7: + stat = encodeConsUnsigned (pctxt, pvalue->u.g722_56k, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g722_48k */ + case 8: + stat = encodeConsUnsigned (pctxt, pvalue->u.g722_48k, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g7231 */ + case 9: + stat = asn1PE_H245AudioCapability_g7231 (pctxt, pvalue->u.g7231); + if (stat != ASN_OK) return stat; + break; + + /* g728 */ + case 10: + stat = encodeConsUnsigned (pctxt, pvalue->u.g728, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g729 */ + case 11: + stat = encodeConsUnsigned (pctxt, pvalue->u.g729, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* g729AnnexA */ + case 12: + stat = encodeConsUnsigned (pctxt, pvalue->u.g729AnnexA, 1U, 256U); + if (stat != ASN_OK) return stat; + + break; + + /* is11172AudioCapability */ + case 13: + stat = asn1PE_H245IS11172AudioCapability (pctxt, pvalue->u.is11172AudioCapability); + if (stat != ASN_OK) return stat; + break; + + /* is13818AudioCapability */ + case 14: + stat = asn1PE_H245IS13818AudioCapability (pctxt, pvalue->u.is13818AudioCapability); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 15); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* g729wAnnexB */ + case 15: + stat = encodeConsUnsigned (&lctxt, pvalue->u.g729wAnnexB, 1U, 256U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* g729AnnexAwAnnexB */ + case 16: + stat = encodeConsUnsigned (&lctxt, pvalue->u.g729AnnexAwAnnexB, 1U, 256U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* g7231AnnexCCapability */ + case 17: + stat = asn1PE_H245G7231AnnexCCapability (&lctxt, pvalue->u.g7231AnnexCCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* gsmFullRate */ + case 18: + stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmFullRate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* gsmHalfRate */ + case 19: + stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmHalfRate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* gsmEnhancedFullRate */ + case 20: + stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmEnhancedFullRate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericAudioCapability */ + case 21: + stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericAudioCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* g729Extensions */ + case 22: + stat = asn1PE_H245G729Extensions (&lctxt, pvalue->u.g729Extensions); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* vbd */ + case 23: + stat = asn1PE_H245VBDCapability (&lctxt, pvalue->u.vbd); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* audioTelephonyEvent */ + case 24: + stat = asn1PE_H245NoPTAudioTelephonyEventCapability (&lctxt, pvalue->u.audioTelephonyEvent); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* audioTone */ + case 25: + stat = asn1PE_H245NoPTAudioToneCapability (&lctxt, pvalue->u.audioTone); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* Capability_h233EncryptionReceiveCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245Capability_h233EncryptionReceiveCapability (OOCTXT* pctxt, H245Capability_h233EncryptionReceiveCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode h233IVResponseTime */ + + stat = encodeConsUnsigned (pctxt, pvalue->h233IVResponseTime, 0U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245NonStandardParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245NonStandardParameter (OOCTXT* pctxt, H245_SeqOfH245NonStandardParameter* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245NonStandardParameter (pctxt, ((H245NonStandardParameter*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceCapability (OOCTXT* pctxt, H245ConferenceCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.videoIndicateMixingCapabilityPresent || + pvalue->m.multipointVisualizationCapabilityPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardDataPresent); + + /* encode nonStandardData */ + + if (pvalue->m.nonStandardDataPresent) { + stat = asn1PE_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandardData); + if (stat != ASN_OK) return stat; + } + + /* encode chairControlCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->chairControlCapability); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoIndicateMixingCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multipointVisualizationCapabilityPresent); + /* encode extension elements */ + + if (pvalue->m.videoIndicateMixingCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->videoIndicateMixingCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multipointVisualizationCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->multipointVisualizationCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MediaEncryptionAlgorithm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MediaEncryptionAlgorithm (OOCTXT* pctxt, H245MediaEncryptionAlgorithm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* algorithm */ + case 2: + stat = encodeObjectIdentifier (pctxt, pvalue->u.algorithm); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EncryptionCapability (OOCTXT* pctxt, H245EncryptionCapability* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245MediaEncryptionAlgorithm (pctxt, ((H245MediaEncryptionAlgorithm*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AuthenticationCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245AuthenticationCapability (OOCTXT* pctxt, H245AuthenticationCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.antiSpamAlgorithmPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.antiSpamAlgorithmPresent); + /* encode extension elements */ + + if (pvalue->m.antiSpamAlgorithmPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeObjectIdentifier (&lctxt, &pvalue->antiSpamAlgorithm); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IntegrityCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IntegrityCapability (OOCTXT* pctxt, H245IntegrityCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionAuthenticationAndIntegrity */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EncryptionAuthenticationAndIntegrity (OOCTXT* pctxt, H245EncryptionAuthenticationAndIntegrity* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.encryptionCapabilityPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.authenticationCapabilityPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.integrityCapabilityPresent); + + /* encode encryptionCapability */ + + if (pvalue->m.encryptionCapabilityPresent) { + stat = asn1PE_H245EncryptionCapability (pctxt, &pvalue->encryptionCapability); + if (stat != ASN_OK) return stat; + } + + /* encode authenticationCapability */ + + if (pvalue->m.authenticationCapabilityPresent) { + stat = asn1PE_H245AuthenticationCapability (pctxt, &pvalue->authenticationCapability); + if (stat != ASN_OK) return stat; + } + + /* encode integrityCapability */ + + if (pvalue->m.integrityCapabilityPresent) { + stat = asn1PE_H245IntegrityCapability (pctxt, &pvalue->integrityCapability); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H235SecurityCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H235SecurityCapability (OOCTXT* pctxt, H245H235SecurityCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode encryptionAuthenticationAndIntegrity */ + + stat = asn1PE_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity); + if (stat != ASN_OK) return stat; + + /* encode mediaCapability */ + + stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->mediaCapability); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputCapability_nonStandard */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UserInputCapability_nonStandard (OOCTXT* pctxt, H245UserInputCapability_nonStandard* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245NonStandardParameter (pctxt, ((H245NonStandardParameter*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UserInputCapability (OOCTXT* pctxt, H245UserInputCapability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245UserInputCapability_nonStandard (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* basicString */ + case 2: + /* NULL */ + break; + + /* iA5String */ + case 3: + /* NULL */ + break; + + /* generalString */ + case 4: + /* NULL */ + break; + + /* dtmf */ + case 5: + /* NULL */ + break; + + /* hookflash */ + case 6: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* extendedAlphanumeric */ + case 7: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexFormat */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexFormat (OOCTXT* pctxt, H245MultiplexFormat* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* h222Capability */ + case 2: + stat = asn1PE_H245H222Capability (pctxt, pvalue->u.h222Capability); + if (stat != ASN_OK) return stat; + break; + + /* h223Capability */ + case 3: + stat = asn1PE_H245H223Capability (pctxt, pvalue->u.h223Capability); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AlternativeCapabilitySet */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245AlternativeCapabilitySet (OOCTXT* pctxt, H245AlternativeCapabilitySet* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexedStreamCapability_capabilityOnMuxStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexedStreamCapability_capabilityOnMuxStream (OOCTXT* pctxt, H245MultiplexedStreamCapability_capabilityOnMuxStream* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245AlternativeCapabilitySet (pctxt, ((H245AlternativeCapabilitySet*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexedStreamCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexedStreamCapability (OOCTXT* pctxt, H245MultiplexedStreamCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityOnMuxStreamPresent); + + /* encode multiplexFormat */ + + stat = asn1PE_H245MultiplexFormat (pctxt, &pvalue->multiplexFormat); + if (stat != ASN_OK) return stat; + + /* encode controlOnMuxStream */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->controlOnMuxStream); + if (stat != ASN_OK) return stat; + + /* encode capabilityOnMuxStream */ + + if (pvalue->m.capabilityOnMuxStreamPresent) { + stat = asn1PE_H245MultiplexedStreamCapability_capabilityOnMuxStream (pctxt, &pvalue->capabilityOnMuxStream); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AudioTelephonyEventCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245AudioTelephonyEventCapability (OOCTXT* pctxt, H245AudioTelephonyEventCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode dynamicRTPPayloadType */ + + stat = encodeConsUnsigned (pctxt, pvalue->dynamicRTPPayloadType, 96U, 127U); + if (stat != ASN_OK) return stat; + + /* encode audioTelephoneEvent */ + + stat = encodeVarWidthCharString (pctxt, pvalue->audioTelephoneEvent); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* AudioToneCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245AudioToneCapability (OOCTXT* pctxt, H245AudioToneCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode dynamicRTPPayloadType */ + + stat = encodeConsUnsigned (pctxt, pvalue->dynamicRTPPayloadType, 96U, 127U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECCapability_rfc2733_separateStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECCapability_rfc2733_separateStream (OOCTXT* pctxt, H245FECCapability_rfc2733_separateStream* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode separatePort */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->separatePort); + if (stat != ASN_OK) return stat; + + /* encode samePort */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->samePort); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECCapability_rfc2733 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECCapability_rfc2733 (OOCTXT* pctxt, H245FECCapability_rfc2733* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode redundancyEncoding */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->redundancyEncoding); + if (stat != ASN_OK) return stat; + + /* encode separateStream */ + + stat = asn1PE_H245FECCapability_rfc2733_separateStream (pctxt, &pvalue->separateStream); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECCapability (OOCTXT* pctxt, H245FECCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* rfc2733 */ + case 1: + stat = asn1PE_H245FECCapability_rfc2733 (pctxt, pvalue->u.rfc2733); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamCapability_capabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplePayloadStreamCapability_capabilities (OOCTXT* pctxt, H245MultiplePayloadStreamCapability_capabilities* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245AlternativeCapabilitySet (pctxt, ((H245AlternativeCapabilitySet*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamCapability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplePayloadStreamCapability (OOCTXT* pctxt, H245MultiplePayloadStreamCapability* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode capabilities */ + + stat = asn1PE_H245MultiplePayloadStreamCapability_capabilities (pctxt, &pvalue->capabilities); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Capability */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245Capability (OOCTXT* pctxt, H245Capability* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 12); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 11); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* receiveVideoCapability */ + case 2: + stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.receiveVideoCapability); + if (stat != ASN_OK) return stat; + break; + + /* transmitVideoCapability */ + case 3: + stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.transmitVideoCapability); + if (stat != ASN_OK) return stat; + break; + + /* receiveAndTransmitVideoCapability */ + case 4: + stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.receiveAndTransmitVideoCapability); + if (stat != ASN_OK) return stat; + break; + + /* receiveAudioCapability */ + case 5: + stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.receiveAudioCapability); + if (stat != ASN_OK) return stat; + break; + + /* transmitAudioCapability */ + case 6: + stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.transmitAudioCapability); + if (stat != ASN_OK) return stat; + break; + + /* receiveAndTransmitAudioCapability */ + case 7: + stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.receiveAndTransmitAudioCapability); + if (stat != ASN_OK) return stat; + break; + + /* receiveDataApplicationCapability */ + case 8: + stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.receiveDataApplicationCapability); + if (stat != ASN_OK) return stat; + break; + + /* transmitDataApplicationCapability */ + case 9: + stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.transmitDataApplicationCapability); + if (stat != ASN_OK) return stat; + break; + + /* receiveAndTransmitDataApplicationCapability */ + case 10: + stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.receiveAndTransmitDataApplicationCapability); + if (stat != ASN_OK) return stat; + break; + + /* h233EncryptionTransmitCapability */ + case 11: + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->u.h233EncryptionTransmitCapability); + if (stat != ASN_OK) return stat; + break; + + /* h233EncryptionReceiveCapability */ + case 12: + stat = asn1PE_H245Capability_h233EncryptionReceiveCapability (pctxt, pvalue->u.h233EncryptionReceiveCapability); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 13); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* conferenceCapability */ + case 13: + stat = asn1PE_H245ConferenceCapability (&lctxt, pvalue->u.conferenceCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* h235SecurityCapability */ + case 14: + stat = asn1PE_H245H235SecurityCapability (&lctxt, pvalue->u.h235SecurityCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* maxPendingReplacementFor */ + case 15: + stat = encodeConsUnsigned (&lctxt, pvalue->u.maxPendingReplacementFor, 0U, 255U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* receiveUserInputCapability */ + case 16: + stat = asn1PE_H245UserInputCapability (&lctxt, pvalue->u.receiveUserInputCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* transmitUserInputCapability */ + case 17: + stat = asn1PE_H245UserInputCapability (&lctxt, pvalue->u.transmitUserInputCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* receiveAndTransmitUserInputCapability */ + case 18: + stat = asn1PE_H245UserInputCapability (&lctxt, pvalue->u.receiveAndTransmitUserInputCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericControlCapability */ + case 19: + stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericControlCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* receiveMultiplexedStreamCapability */ + case 20: + stat = asn1PE_H245MultiplexedStreamCapability (&lctxt, pvalue->u.receiveMultiplexedStreamCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* transmitMultiplexedStreamCapability */ + case 21: + stat = asn1PE_H245MultiplexedStreamCapability (&lctxt, pvalue->u.transmitMultiplexedStreamCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* receiveAndTransmitMultiplexedStreamCapability */ + case 22: + stat = asn1PE_H245MultiplexedStreamCapability (&lctxt, pvalue->u.receiveAndTransmitMultiplexedStreamCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* receiveRTPAudioTelephonyEventCapability */ + case 23: + stat = asn1PE_H245AudioTelephonyEventCapability (&lctxt, pvalue->u.receiveRTPAudioTelephonyEventCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* receiveRTPAudioToneCapability */ + case 24: + stat = asn1PE_H245AudioToneCapability (&lctxt, pvalue->u.receiveRTPAudioToneCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* fecCapability */ + case 25: + stat = asn1PE_H245FECCapability (&lctxt, pvalue->u.fecCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multiplePayloadStreamCapability */ + case 26: + stat = asn1PE_H245MultiplePayloadStreamCapability (&lctxt, pvalue->u.multiplePayloadStreamCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityTableEntry */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CapabilityTableEntry (OOCTXT* pctxt, H245CapabilityTableEntry* pvalue) +{ + int stat = ASN_OK; + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityPresent); + + /* encode capabilityTableEntryNumber */ + + stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->capabilityTableEntryNumber); + if (stat != ASN_OK) return stat; + + /* encode capability */ + + if (pvalue->m.capabilityPresent) { + stat = asn1PE_H245Capability (pctxt, &pvalue->capability); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet_capabilityTable */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalCapabilitySet_capabilityTable (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityTable* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245CapabilityTableEntry (pctxt, ((H245CapabilityTableEntry*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityDescriptorNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CapabilityDescriptorNumber (OOCTXT* pctxt, H245CapabilityDescriptorNumber value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 0U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityDescriptor_simultaneousCapabilities */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CapabilityDescriptor_simultaneousCapabilities (OOCTXT* pctxt, H245CapabilityDescriptor_simultaneousCapabilities* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245AlternativeCapabilitySet (pctxt, ((H245AlternativeCapabilitySet*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CapabilityDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CapabilityDescriptor (OOCTXT* pctxt, H245CapabilityDescriptor* pvalue) +{ + int stat = ASN_OK; + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.simultaneousCapabilitiesPresent); + + /* encode capabilityDescriptorNumber */ + + stat = asn1PE_H245CapabilityDescriptorNumber (pctxt, pvalue->capabilityDescriptorNumber); + if (stat != ASN_OK) return stat; + + /* encode simultaneousCapabilities */ + + if (pvalue->m.simultaneousCapabilitiesPresent) { + stat = asn1PE_H245CapabilityDescriptor_simultaneousCapabilities (pctxt, &pvalue->simultaneousCapabilities); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet_capabilityDescriptors */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalCapabilitySet_capabilityDescriptors (OOCTXT* pctxt, H245TerminalCapabilitySet_capabilityDescriptors* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245CapabilityDescriptor (pctxt, ((H245CapabilityDescriptor*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySet */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalCapabilitySet (OOCTXT* pctxt, H245TerminalCapabilitySet* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multiplexCapabilityPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityTablePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityDescriptorsPresent); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode protocolIdentifier */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->protocolIdentifier); + if (stat != ASN_OK) return stat; + + /* encode multiplexCapability */ + + if (pvalue->m.multiplexCapabilityPresent) { + stat = asn1PE_H245MultiplexCapability (pctxt, &pvalue->multiplexCapability); + if (stat != ASN_OK) return stat; + } + + /* encode capabilityTable */ + + if (pvalue->m.capabilityTablePresent) { + stat = asn1PE_H245TerminalCapabilitySet_capabilityTable (pctxt, &pvalue->capabilityTable); + if (stat != ASN_OK) return stat; + } + + /* encode capabilityDescriptors */ + + if (pvalue->m.capabilityDescriptorsPresent) { + stat = asn1PE_H245TerminalCapabilitySet_capabilityDescriptors (pctxt, &pvalue->capabilityDescriptors); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* LogicalChannelNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245LogicalChannelNumber (OOCTXT* pctxt, H245LogicalChannelNumber value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 1U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EncryptionMode (OOCTXT* pctxt, H245EncryptionMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* h233Encryption */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingElement (OOCTXT* pctxt, H245RedundancyEncodingElement* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.payloadTypePresent); + + /* encode dataType */ + + stat = asn1PE_H245DataType (pctxt, (H245DataType*)pvalue->dataType); + if (stat != ASN_OK) return stat; + + /* encode payloadType */ + + if (pvalue->m.payloadTypePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->payloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245RedundancyEncodingElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245RedundancyEncodingElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingElement* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245RedundancyEncodingElement (pctxt, ((H245RedundancyEncodingElement*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncoding_rtpRedundancyEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncoding_rtpRedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding_rtpRedundancyEncoding* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.primaryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.secondaryPresent); + + /* encode primary */ + + if (pvalue->m.primaryPresent) { + stat = asn1PE_H245RedundancyEncodingElement (pctxt, &pvalue->primary); + if (stat != ASN_OK) return stat; + } + + /* encode secondary */ + + if (pvalue->m.secondaryPresent) { + stat = asn1PE_H245_SeqOfH245RedundancyEncodingElement (pctxt, &pvalue->secondary); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncoding (OOCTXT* pctxt, H245RedundancyEncoding* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.rtpRedundancyEncodingPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.secondaryEncodingPresent); + + /* encode redundancyEncodingMethod */ + + stat = asn1PE_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod); + if (stat != ASN_OK) return stat; + + /* encode secondaryEncoding */ + + if (pvalue->m.secondaryEncodingPresent) { + stat = asn1PE_H245DataType (pctxt, (H245DataType*)pvalue->secondaryEncoding); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpRedundancyEncodingPresent); + /* encode extension elements */ + + if (pvalue->m.rtpRedundancyEncodingPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245RedundancyEncoding_rtpRedundancyEncoding (&lctxt, &pvalue->rtpRedundancyEncoding); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplePayloadStreamElement (OOCTXT* pctxt, H245MultiplePayloadStreamElement* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.payloadTypePresent); + + /* encode dataType */ + + stat = asn1PE_H245DataType (pctxt, (H245DataType*)pvalue->dataType); + if (stat != ASN_OK) return stat; + + /* encode payloadType */ + + if (pvalue->m.payloadTypePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->payloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245MultiplePayloadStreamElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245MultiplePayloadStreamElement (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElement* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245MultiplePayloadStreamElement (pctxt, ((H245MultiplePayloadStreamElement*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplePayloadStream (OOCTXT* pctxt, H245MultiplePayloadStream* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode elements */ + + stat = asn1PE_H245_SeqOfH245MultiplePayloadStreamElement (pctxt, &pvalue->elements); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream_differentPort */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_differentPort* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.protectedPayloadTypePresent); + + /* encode protectedSessionID */ + + stat = encodeConsUnsigned (pctxt, pvalue->protectedSessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode protectedPayloadType */ + + if (pvalue->m.protectedPayloadTypePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->protectedPayloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream_samePort */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream_samePort (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream_samePort* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode protectedPayloadType */ + + stat = encodeConsUnsigned (pctxt, pvalue->protectedPayloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode_separateStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECData_rfc2733_mode_separateStream (OOCTXT* pctxt, H245FECData_rfc2733_mode_separateStream* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* differentPort */ + case 1: + stat = asn1PE_H245FECData_rfc2733_mode_separateStream_differentPort (pctxt, pvalue->u.differentPort); + if (stat != ASN_OK) return stat; + break; + + /* samePort */ + case 2: + stat = asn1PE_H245FECData_rfc2733_mode_separateStream_samePort (pctxt, pvalue->u.samePort); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733_mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECData_rfc2733_mode (OOCTXT* pctxt, H245FECData_rfc2733_mode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* redundancyEncoding */ + case 1: + /* NULL */ + break; + + /* separateStream */ + case 2: + stat = asn1PE_H245FECData_rfc2733_mode_separateStream (pctxt, pvalue->u.separateStream); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECData_rfc2733 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECData_rfc2733 (OOCTXT* pctxt, H245FECData_rfc2733* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode mode */ + + stat = asn1PE_H245FECData_rfc2733_mode (pctxt, &pvalue->mode); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECData */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECData (OOCTXT* pctxt, H245FECData* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* rfc2733 */ + case 1: + stat = asn1PE_H245FECData_rfc2733 (pctxt, pvalue->u.rfc2733); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H235Media_mediaType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H235Media_mediaType (OOCTXT* pctxt, H245H235Media_mediaType* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* videoData */ + case 2: + stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.videoData); + if (stat != ASN_OK) return stat; + break; + + /* audioData */ + case 3: + stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.audioData); + if (stat != ASN_OK) return stat; + break; + + /* data */ + case 4: + stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.data); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* redundancyEncoding */ + case 5: + stat = asn1PE_H245RedundancyEncoding (&lctxt, pvalue->u.redundancyEncoding); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multiplePayloadStream */ + case 6: + stat = asn1PE_H245MultiplePayloadStream (&lctxt, pvalue->u.multiplePayloadStream); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* fec */ + case 7: + stat = asn1PE_H245FECData (&lctxt, pvalue->u.fec); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H235Media */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H235Media (OOCTXT* pctxt, H245H235Media* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode encryptionAuthenticationAndIntegrity */ + + stat = asn1PE_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity); + if (stat != ASN_OK) return stat; + + /* encode mediaType */ + + stat = asn1PE_H245H235Media_mediaType (pctxt, &pvalue->mediaType); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexedStreamParameter */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexedStreamParameter (OOCTXT* pctxt, H245MultiplexedStreamParameter* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode multiplexFormat */ + + stat = asn1PE_H245MultiplexFormat (pctxt, &pvalue->multiplexFormat); + if (stat != ASN_OK) return stat; + + /* encode controlOnMuxStream */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->controlOnMuxStream); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataType (OOCTXT* pctxt, H245DataType* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* nullData */ + case 2: + /* NULL */ + break; + + /* videoData */ + case 3: + stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.videoData); + if (stat != ASN_OK) return stat; + break; + + /* audioData */ + case 4: + stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.audioData); + if (stat != ASN_OK) return stat; + break; + + /* data */ + case 5: + stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.data); + if (stat != ASN_OK) return stat; + break; + + /* encryptionData */ + case 6: + stat = asn1PE_H245EncryptionMode (pctxt, pvalue->u.encryptionData); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* h235Control */ + case 7: + stat = asn1PE_H245NonStandardParameter (&lctxt, pvalue->u.h235Control); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* h235Media */ + case 8: + stat = asn1PE_H245H235Media (&lctxt, pvalue->u.h235Media); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multiplexedStream */ + case 9: + stat = asn1PE_H245MultiplexedStreamParameter (&lctxt, pvalue->u.multiplexedStream); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* redundancyEncoding */ + case 10: + stat = asn1PE_H245RedundancyEncoding (&lctxt, pvalue->u.redundancyEncoding); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multiplePayloadStream */ + case 11: + stat = asn1PE_H245MultiplePayloadStream (&lctxt, pvalue->u.multiplePayloadStream); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* fec */ + case 12: + stat = asn1PE_H245FECData (&lctxt, pvalue->u.fec); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H222LogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H222LogicalChannelParameters (OOCTXT* pctxt, H245H222LogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.pcr_pidPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.programDescriptorsPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.streamDescriptorsPresent); + + /* encode resourceID */ + + stat = encodeConsUnsigned (pctxt, pvalue->resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode subChannelID */ + + stat = encodeConsUnsigned (pctxt, pvalue->subChannelID, 0U, 8191U); + if (stat != ASN_OK) return stat; + + /* encode pcr_pid */ + + if (pvalue->m.pcr_pidPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->pcr_pid, 0U, 8191U); + if (stat != ASN_OK) return stat; + + } + + /* encode programDescriptors */ + + if (pvalue->m.programDescriptorsPresent) { + stat = encodeOctetString (pctxt, pvalue->programDescriptors.numocts, pvalue->programDescriptors.data); + if (stat != ASN_OK) return stat; + } + + /* encode streamDescriptors */ + + if (pvalue->m.streamDescriptorsPresent) { + stat = encodeOctetString (pctxt, pvalue->streamDescriptors.numocts, pvalue->streamDescriptors.data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters_adaptationLayerType_al3 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223LogicalChannelParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType_al3* pvalue) +{ + int stat = ASN_OK; + + /* encode controlFieldOctets */ + + stat = encodeConsUnsigned (pctxt, pvalue->controlFieldOctets, 0U, 2U); + if (stat != ASN_OK) return stat; + + /* encode sendBufferSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->sendBufferSize, 0U, 16777215U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters_transferMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL1MParameters_transferMode (OOCTXT* pctxt, H245H223AL1MParameters_transferMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* framed */ + case 1: + /* NULL */ + break; + + /* unframed */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters_headerFEC */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL1MParameters_headerFEC (OOCTXT* pctxt, H245H223AL1MParameters_headerFEC* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* sebch16_7 */ + case 1: + /* NULL */ + break; + + /* golay24_12 */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters_crcLength */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL1MParameters_crcLength (OOCTXT* pctxt, H245H223AL1MParameters_crcLength* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* crc4bit */ + case 1: + /* NULL */ + break; + + /* crc12bit */ + case 2: + /* NULL */ + break; + + /* crc20bit */ + case 3: + /* NULL */ + break; + + /* crc28bit */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* crc8bit */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* crc16bit */ + case 6: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* crc32bit */ + case 7: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* crcNotUsed */ + case 8: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AnnexCArqParameters_numberOfRetransmissions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AnnexCArqParameters_numberOfRetransmissions (OOCTXT* pctxt, H245H223AnnexCArqParameters_numberOfRetransmissions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* finite */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.finite, 0U, 16U); + if (stat != ASN_OK) return stat; + + break; + + /* infinite */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AnnexCArqParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AnnexCArqParameters (OOCTXT* pctxt, H245H223AnnexCArqParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode numberOfRetransmissions */ + + stat = asn1PE_H245H223AnnexCArqParameters_numberOfRetransmissions (pctxt, &pvalue->numberOfRetransmissions); + if (stat != ASN_OK) return stat; + + /* encode sendBufferSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->sendBufferSize, 0U, 16777215U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters_arqType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL1MParameters_arqType (OOCTXT* pctxt, H245H223AL1MParameters_arqType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noArq */ + case 1: + /* NULL */ + break; + + /* typeIArq */ + case 2: + stat = asn1PE_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIArq); + if (stat != ASN_OK) return stat; + break; + + /* typeIIArq */ + case 3: + stat = asn1PE_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIIArq); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL1MParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL1MParameters (OOCTXT* pctxt, H245H223AL1MParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.rsCodeCorrectionPresent); + + encodeBit (pctxt, extbit); + + /* encode transferMode */ + + stat = asn1PE_H245H223AL1MParameters_transferMode (pctxt, &pvalue->transferMode); + if (stat != ASN_OK) return stat; + + /* encode headerFEC */ + + stat = asn1PE_H245H223AL1MParameters_headerFEC (pctxt, &pvalue->headerFEC); + if (stat != ASN_OK) return stat; + + /* encode crcLength */ + + stat = asn1PE_H245H223AL1MParameters_crcLength (pctxt, &pvalue->crcLength); + if (stat != ASN_OK) return stat; + + /* encode rcpcCodeRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->rcpcCodeRate, 8U, 32U); + if (stat != ASN_OK) return stat; + + /* encode arqType */ + + stat = asn1PE_H245H223AL1MParameters_arqType (pctxt, &pvalue->arqType); + if (stat != ASN_OK) return stat; + + /* encode alpduInterleaving */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alpduInterleaving); + if (stat != ASN_OK) return stat; + + /* encode alsduSplitting */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alsduSplitting); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rsCodeCorrectionPresent); + /* encode extension elements */ + + if (pvalue->m.rsCodeCorrectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->rsCodeCorrection, 0U, 127U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL2MParameters_headerFEC */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL2MParameters_headerFEC (OOCTXT* pctxt, H245H223AL2MParameters_headerFEC* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* sebch16_5 */ + case 1: + /* NULL */ + break; + + /* golay24_12 */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL2MParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL2MParameters (OOCTXT* pctxt, H245H223AL2MParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode headerFEC */ + + stat = asn1PE_H245H223AL2MParameters_headerFEC (pctxt, &pvalue->headerFEC); + if (stat != ASN_OK) return stat; + + /* encode alpduInterleaving */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alpduInterleaving); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL3MParameters_headerFormat */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL3MParameters_headerFormat (OOCTXT* pctxt, H245H223AL3MParameters_headerFormat* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* sebch16_7 */ + case 1: + /* NULL */ + break; + + /* golay24_12 */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL3MParameters_crcLength */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL3MParameters_crcLength (OOCTXT* pctxt, H245H223AL3MParameters_crcLength* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* crc4bit */ + case 1: + /* NULL */ + break; + + /* crc12bit */ + case 2: + /* NULL */ + break; + + /* crc20bit */ + case 3: + /* NULL */ + break; + + /* crc28bit */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* crc8bit */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* crc16bit */ + case 6: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* crc32bit */ + case 7: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* crcNotUsed */ + case 8: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL3MParameters_arqType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL3MParameters_arqType (OOCTXT* pctxt, H245H223AL3MParameters_arqType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noArq */ + case 1: + /* NULL */ + break; + + /* typeIArq */ + case 2: + stat = asn1PE_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIArq); + if (stat != ASN_OK) return stat; + break; + + /* typeIIArq */ + case 3: + stat = asn1PE_H245H223AnnexCArqParameters (pctxt, pvalue->u.typeIIArq); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223AL3MParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223AL3MParameters (OOCTXT* pctxt, H245H223AL3MParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.rsCodeCorrectionPresent); + + encodeBit (pctxt, extbit); + + /* encode headerFormat */ + + stat = asn1PE_H245H223AL3MParameters_headerFormat (pctxt, &pvalue->headerFormat); + if (stat != ASN_OK) return stat; + + /* encode crcLength */ + + stat = asn1PE_H245H223AL3MParameters_crcLength (pctxt, &pvalue->crcLength); + if (stat != ASN_OK) return stat; + + /* encode rcpcCodeRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->rcpcCodeRate, 8U, 32U); + if (stat != ASN_OK) return stat; + + /* encode arqType */ + + stat = asn1PE_H245H223AL3MParameters_arqType (pctxt, &pvalue->arqType); + if (stat != ASN_OK) return stat; + + /* encode alpduInterleaving */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->alpduInterleaving); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rsCodeCorrectionPresent); + /* encode extension elements */ + + if (pvalue->m.rsCodeCorrectionPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->rsCodeCorrection, 0U, 127U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters_adaptationLayerType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223LogicalChannelParameters_adaptationLayerType (OOCTXT* pctxt, H245H223LogicalChannelParameters_adaptationLayerType* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* al1Framed */ + case 2: + /* NULL */ + break; + + /* al1NotFramed */ + case 3: + /* NULL */ + break; + + /* al2WithoutSequenceNumbers */ + case 4: + /* NULL */ + break; + + /* al2WithSequenceNumbers */ + case 5: + /* NULL */ + break; + + /* al3 */ + case 6: + stat = asn1PE_H245H223LogicalChannelParameters_adaptationLayerType_al3 (pctxt, pvalue->u.al3); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* al1M */ + case 7: + stat = asn1PE_H245H223AL1MParameters (&lctxt, pvalue->u.al1M); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* al2M */ + case 8: + stat = asn1PE_H245H223AL2MParameters (&lctxt, pvalue->u.al2M); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* al3M */ + case 9: + stat = asn1PE_H245H223AL3MParameters (&lctxt, pvalue->u.al3M); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223LogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223LogicalChannelParameters (OOCTXT* pctxt, H245H223LogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode adaptationLayerType */ + + stat = asn1PE_H245H223LogicalChannelParameters_adaptationLayerType (pctxt, &pvalue->adaptationLayerType); + if (stat != ASN_OK) return stat; + + /* encode segmentableFlag */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->segmentableFlag); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CRCLength */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CRCLength (OOCTXT* pctxt, H245CRCLength* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* crc8bit */ + case 1: + /* NULL */ + break; + + /* crc16bit */ + case 2: + /* NULL */ + break; + + /* crc32bit */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* V76HDLCParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V76HDLCParameters (OOCTXT* pctxt, H245V76HDLCParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode crcLength */ + + stat = asn1PE_H245CRCLength (pctxt, &pvalue->crcLength); + if (stat != ASN_OK) return stat; + + /* encode n401 */ + + stat = encodeConsUnsigned (pctxt, pvalue->n401, 1U, 4095U); + if (stat != ASN_OK) return stat; + + /* encode loopbackTestProcedure */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->loopbackTestProcedure); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_suspendResume */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V76LogicalChannelParameters_suspendResume (OOCTXT* pctxt, H245V76LogicalChannelParameters_suspendResume* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noSuspendResume */ + case 1: + /* NULL */ + break; + + /* suspendResumewAddress */ + case 2: + /* NULL */ + break; + + /* suspendResumewoAddress */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode_eRM_recovery */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V76LogicalChannelParameters_mode_eRM_recovery (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM_recovery* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* rej */ + case 1: + /* NULL */ + break; + + /* sREJ */ + case 2: + /* NULL */ + break; + + /* mSREJ */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode_eRM */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V76LogicalChannelParameters_mode_eRM (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode_eRM* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode windowSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->windowSize, 1U, 127U); + if (stat != ASN_OK) return stat; + + /* encode recovery */ + + stat = asn1PE_H245V76LogicalChannelParameters_mode_eRM_recovery (pctxt, &pvalue->recovery); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters_mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V76LogicalChannelParameters_mode (OOCTXT* pctxt, H245V76LogicalChannelParameters_mode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* eRM */ + case 1: + stat = asn1PE_H245V76LogicalChannelParameters_mode_eRM (pctxt, pvalue->u.eRM); + if (stat != ASN_OK) return stat; + break; + + /* uNERM */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* V75Parameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V75Parameters (OOCTXT* pctxt, H245V75Parameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode audioHeaderPresent */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->audioHeaderPresent); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* V76LogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V76LogicalChannelParameters (OOCTXT* pctxt, H245V76LogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode hdlcParameters */ + + stat = asn1PE_H245V76HDLCParameters (pctxt, &pvalue->hdlcParameters); + if (stat != ASN_OK) return stat; + + /* encode suspendResume */ + + stat = asn1PE_H245V76LogicalChannelParameters_suspendResume (pctxt, &pvalue->suspendResume); + if (stat != ASN_OK) return stat; + + /* encode uIH */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->uIH); + if (stat != ASN_OK) return stat; + + /* encode mode */ + + stat = asn1PE_H245V76LogicalChannelParameters_mode (pctxt, &pvalue->mode); + if (stat != ASN_OK) return stat; + + /* encode v75Parameters */ + + stat = asn1PE_H245V75Parameters (pctxt, &pvalue->v75Parameters); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPAddress_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPAddress_network* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPAddress (OOCTXT* pctxt, H245UnicastAddress_iPAddress* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode network */ + + stat = asn1PE_H245UnicastAddress_iPAddress_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + /* encode tsapIdentifier */ + + stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_node */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPXAddress_node (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_node* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 6, 6, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_netnum */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPXAddress_netnum (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_netnum* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress_tsapIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPXAddress_tsapIdentifier (OOCTXT* pctxt, H245UnicastAddress_iPXAddress_tsapIdentifier* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 2, 2, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPXAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPXAddress (OOCTXT* pctxt, H245UnicastAddress_iPXAddress* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode node */ + + stat = asn1PE_H245UnicastAddress_iPXAddress_node (pctxt, &pvalue->node); + if (stat != ASN_OK) return stat; + + /* encode netnum */ + + stat = asn1PE_H245UnicastAddress_iPXAddress_netnum (pctxt, &pvalue->netnum); + if (stat != ASN_OK) return stat; + + /* encode tsapIdentifier */ + + stat = asn1PE_H245UnicastAddress_iPXAddress_tsapIdentifier (pctxt, &pvalue->tsapIdentifier); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iP6Address_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iP6Address_network (OOCTXT* pctxt, H245UnicastAddress_iP6Address_network* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iP6Address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iP6Address (OOCTXT* pctxt, H245UnicastAddress_iP6Address* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode network */ + + stat = asn1PE_H245UnicastAddress_iP6Address_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + /* encode tsapIdentifier */ + + stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_netBios */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_netBios (OOCTXT* pctxt, H245UnicastAddress_netBios* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_routing */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_routing (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_routing* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* strict */ + case 1: + /* NULL */ + break; + + /* loose */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_network (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_network* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress_route_element */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress_route_element* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245UnicastAddress_iPSourceRouteAddress_route_elem */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (OOCTXT* pctxt, H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element* pvalue) +{ + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245UnicastAddress_iPSourceRouteAddress_route_element (pctxt, &pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_iPSourceRouteAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_iPSourceRouteAddress (OOCTXT* pctxt, H245UnicastAddress_iPSourceRouteAddress* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode routing */ + + stat = asn1PE_H245UnicastAddress_iPSourceRouteAddress_routing (pctxt, &pvalue->routing); + if (stat != ASN_OK) return stat; + + /* encode network */ + + stat = asn1PE_H245UnicastAddress_iPSourceRouteAddress_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + /* encode tsapIdentifier */ + + stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode route */ + + stat = asn1PE_H245_SeqOfH245UnicastAddress_iPSourceRouteAddress_route_element (pctxt, &pvalue->route); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress_nsap */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress_nsap (OOCTXT* pctxt, H245UnicastAddress_nsap* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UnicastAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UnicastAddress (OOCTXT* pctxt, H245UnicastAddress* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* iPAddress */ + case 1: + stat = asn1PE_H245UnicastAddress_iPAddress (pctxt, pvalue->u.iPAddress); + if (stat != ASN_OK) return stat; + break; + + /* iPXAddress */ + case 2: + stat = asn1PE_H245UnicastAddress_iPXAddress (pctxt, pvalue->u.iPXAddress); + if (stat != ASN_OK) return stat; + break; + + /* iP6Address */ + case 3: + stat = asn1PE_H245UnicastAddress_iP6Address (pctxt, pvalue->u.iP6Address); + if (stat != ASN_OK) return stat; + break; + + /* netBios */ + case 4: + stat = asn1PE_H245UnicastAddress_netBios (pctxt, pvalue->u.netBios); + if (stat != ASN_OK) return stat; + break; + + /* iPSourceRouteAddress */ + case 5: + stat = asn1PE_H245UnicastAddress_iPSourceRouteAddress (pctxt, pvalue->u.iPSourceRouteAddress); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* nsap */ + case 6: + stat = asn1PE_H245UnicastAddress_nsap (&lctxt, pvalue->u.nsap); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* nonStandardAddress */ + case 7: + stat = asn1PE_H245NonStandardParameter (&lctxt, pvalue->u.nonStandardAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_iPAddress_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MulticastAddress_iPAddress_network (OOCTXT* pctxt, H245MulticastAddress_iPAddress_network* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 4, 4, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_iPAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MulticastAddress_iPAddress (OOCTXT* pctxt, H245MulticastAddress_iPAddress* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode network */ + + stat = asn1PE_H245MulticastAddress_iPAddress_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + /* encode tsapIdentifier */ + + stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_iP6Address_network */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MulticastAddress_iP6Address_network (OOCTXT* pctxt, H245MulticastAddress_iP6Address_network* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_iP6Address */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MulticastAddress_iP6Address (OOCTXT* pctxt, H245MulticastAddress_iP6Address* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode network */ + + stat = asn1PE_H245MulticastAddress_iP6Address_network (pctxt, &pvalue->network); + if (stat != ASN_OK) return stat; + + /* encode tsapIdentifier */ + + stat = encodeConsUnsigned (pctxt, pvalue->tsapIdentifier, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MulticastAddress_nsap */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MulticastAddress_nsap (OOCTXT* pctxt, H245MulticastAddress_nsap* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 20, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MulticastAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MulticastAddress (OOCTXT* pctxt, H245MulticastAddress* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* iPAddress */ + case 1: + stat = asn1PE_H245MulticastAddress_iPAddress (pctxt, pvalue->u.iPAddress); + if (stat != ASN_OK) return stat; + break; + + /* iP6Address */ + case 2: + stat = asn1PE_H245MulticastAddress_iP6Address (pctxt, pvalue->u.iP6Address); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* nsap */ + case 3: + stat = asn1PE_H245MulticastAddress_nsap (&lctxt, pvalue->u.nsap); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* nonStandardAddress */ + case 4: + stat = asn1PE_H245NonStandardParameter (&lctxt, pvalue->u.nonStandardAddress); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TransportAddress */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TransportAddress (OOCTXT* pctxt, H245TransportAddress* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unicastAddress */ + case 1: + stat = asn1PE_H245UnicastAddress (pctxt, pvalue->u.unicastAddress); + if (stat != ASN_OK) return stat; + break; + + /* multicastAddress */ + case 2: + stat = asn1PE_H245MulticastAddress (pctxt, pvalue->u.multicastAddress); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* McuNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245McuNumber (OOCTXT* pctxt, H245McuNumber value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 0U, 192U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalNumber (OOCTXT* pctxt, H245TerminalNumber value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 0U, 192U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalLabel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalLabel (OOCTXT* pctxt, H245TerminalLabel* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode mcuNumber */ + + stat = asn1PE_H245McuNumber (pctxt, pvalue->mcuNumber); + if (stat != ASN_OK) return stat; + + /* encode terminalNumber */ + + stat = asn1PE_H245TerminalNumber (pctxt, pvalue->terminalNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250LogicalChannelParameters_mediaPacketization */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H2250LogicalChannelParameters_mediaPacketization (OOCTXT* pctxt, H245H2250LogicalChannelParameters_mediaPacketization* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* h261aVideoPacketization */ + case 1: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* rtpPayloadType */ + case 2: + stat = asn1PE_H245RTPPayloadType (&lctxt, pvalue->u.rtpPayloadType); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250LogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H2250LogicalChannelParameters (OOCTXT* pctxt, H245H2250LogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.transportCapabilityPresent || + pvalue->m.redundancyEncodingPresent || + pvalue->m.sourcePresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.associatedSessionIDPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaChannelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaGuaranteedDeliveryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlChannelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlGuaranteedDeliveryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.silenceSuppressionPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dynamicRTPPayloadTypePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaPacketizationPresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + /* encode sessionID */ + + stat = encodeConsUnsigned (pctxt, pvalue->sessionID, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode associatedSessionID */ + + if (pvalue->m.associatedSessionIDPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->associatedSessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + + } + + /* encode mediaChannel */ + + if (pvalue->m.mediaChannelPresent) { + stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaChannel); + if (stat != ASN_OK) return stat; + } + + /* encode mediaGuaranteedDelivery */ + + if (pvalue->m.mediaGuaranteedDeliveryPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mediaGuaranteedDelivery); + if (stat != ASN_OK) return stat; + } + + /* encode mediaControlChannel */ + + if (pvalue->m.mediaControlChannelPresent) { + stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaControlChannel); + if (stat != ASN_OK) return stat; + } + + /* encode mediaControlGuaranteedDelivery */ + + if (pvalue->m.mediaControlGuaranteedDeliveryPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mediaControlGuaranteedDelivery); + if (stat != ASN_OK) return stat; + } + + /* encode silenceSuppression */ + + if (pvalue->m.silenceSuppressionPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->silenceSuppression); + if (stat != ASN_OK) return stat; + } + + /* encode destination */ + + if (pvalue->m.destinationPresent) { + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->destination); + if (stat != ASN_OK) return stat; + } + + /* encode dynamicRTPPayloadType */ + + if (pvalue->m.dynamicRTPPayloadTypePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->dynamicRTPPayloadType, 96U, 127U); + if (stat != ASN_OK) return stat; + + } + + /* encode mediaPacketization */ + + if (pvalue->m.mediaPacketizationPresent) { + stat = asn1PE_H245H2250LogicalChannelParameters_mediaPacketization (pctxt, &pvalue->mediaPacketization); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 2); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.transportCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.redundancyEncodingPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sourcePresent); + /* encode extension elements */ + + if (pvalue->m.transportCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245TransportCapability (&lctxt, &pvalue->transportCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.redundancyEncodingPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245RedundancyEncoding (&lctxt, &pvalue->redundancyEncoding); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.sourcePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245TerminalLabel (&lctxt, &pvalue->source); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_forwardLogicalChannelParameters_multi */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* h222LogicalChannelParameters */ + case 1: + stat = asn1PE_H245H222LogicalChannelParameters (pctxt, pvalue->u.h222LogicalChannelParameters); + if (stat != ASN_OK) return stat; + break; + + /* h223LogicalChannelParameters */ + case 2: + stat = asn1PE_H245H223LogicalChannelParameters (pctxt, pvalue->u.h223LogicalChannelParameters); + if (stat != ASN_OK) return stat; + break; + + /* v76LogicalChannelParameters */ + case 3: + stat = asn1PE_H245V76LogicalChannelParameters (pctxt, pvalue->u.v76LogicalChannelParameters); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* h2250LogicalChannelParameters */ + case 4: + stat = asn1PE_H245H2250LogicalChannelParameters (&lctxt, pvalue->u.h2250LogicalChannelParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* none */ + case 5: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_forwardLogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_forwardLogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.forwardLogicalChannelDependencyPresent || + pvalue->m.replacementForPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.portNumberPresent); + + /* encode portNumber */ + + if (pvalue->m.portNumberPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->portNumber, 0U, 65535U); + if (stat != ASN_OK) return stat; + + } + + /* encode dataType */ + + stat = asn1PE_H245DataType (pctxt, &pvalue->dataType); + if (stat != ASN_OK) return stat; + + /* encode multiplexParameters */ + + stat = asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.forwardLogicalChannelDependencyPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.replacementForPresent); + /* encode extension elements */ + + if (pvalue->m.forwardLogicalChannelDependencyPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->forwardLogicalChannelDependency); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.replacementForPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->replacementFor); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_reverseLogicalChannelParameters_multi */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* h223LogicalChannelParameters */ + case 1: + stat = asn1PE_H245H223LogicalChannelParameters (pctxt, pvalue->u.h223LogicalChannelParameters); + if (stat != ASN_OK) return stat; + break; + + /* v76LogicalChannelParameters */ + case 2: + stat = asn1PE_H245V76LogicalChannelParameters (pctxt, pvalue->u.v76LogicalChannelParameters); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* h2250LogicalChannelParameters */ + case 3: + stat = asn1PE_H245H2250LogicalChannelParameters (&lctxt, pvalue->u.h2250LogicalChannelParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel_reverseLogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannel_reverseLogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.reverseLogicalChannelDependencyPresent || + pvalue->m.replacementForPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multiplexParametersPresent); + + /* encode dataType */ + + stat = asn1PE_H245DataType (pctxt, &pvalue->dataType); + if (stat != ASN_OK) return stat; + + /* encode multiplexParameters */ + + if (pvalue->m.multiplexParametersPresent) { + stat = asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.reverseLogicalChannelDependencyPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.replacementForPresent); + /* encode extension elements */ + + if (pvalue->m.reverseLogicalChannelDependencyPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->reverseLogicalChannelDependency); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.replacementForPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->replacementFor); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_distribution */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NetworkAccessParameters_distribution (OOCTXT* pctxt, H245NetworkAccessParameters_distribution* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unicast */ + case 1: + /* NULL */ + break; + + /* multicast */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_networkAddress */ +/* */ +/**************************************************************/ + +extern EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet; + +EXTERN int asn1PE_H245NetworkAccessParameters_networkAddress (OOCTXT* pctxt, H245NetworkAccessParameters_networkAddress* pvalue) +{ + static Asn1SizeCnst e164Address_lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* q2931Address */ + case 1: + stat = asn1PE_H245Q2931Address (pctxt, pvalue->u.q2931Address); + if (stat != ASN_OK) return stat; + break; + + /* e164Address */ + case 2: + addSizeConstraint (pctxt, &e164Address_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->u.e164Address, gs_MULTIMEDIA_SYSTEM_CONTROL_NetworkAccessParameters_networkAddress_e164Address_CharSet, 4, 4, 7); + if (stat != ASN_OK) return stat; + break; + + /* localAreaAddress */ + case 3: + stat = asn1PE_H245TransportAddress (pctxt, pvalue->u.localAreaAddress); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_externalReference */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NetworkAccessParameters_externalReference (OOCTXT* pctxt, H245NetworkAccessParameters_externalReference* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 255, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters_t120SetupProcedure */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NetworkAccessParameters_t120SetupProcedure (OOCTXT* pctxt, H245NetworkAccessParameters_t120SetupProcedure* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* originateCall */ + case 1: + /* NULL */ + break; + + /* waitForCall */ + case 2: + /* NULL */ + break; + + /* issueQuery */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NetworkAccessParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NetworkAccessParameters (OOCTXT* pctxt, H245NetworkAccessParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.t120SetupProcedurePresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.distributionPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.externalReferencePresent); + + /* encode distribution */ + + if (pvalue->m.distributionPresent) { + stat = asn1PE_H245NetworkAccessParameters_distribution (pctxt, &pvalue->distribution); + if (stat != ASN_OK) return stat; + } + + /* encode networkAddress */ + + stat = asn1PE_H245NetworkAccessParameters_networkAddress (pctxt, &pvalue->networkAddress); + if (stat != ASN_OK) return stat; + + /* encode associateConference */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->associateConference); + if (stat != ASN_OK) return stat; + + /* encode externalReference */ + + if (pvalue->m.externalReferencePresent) { + stat = asn1PE_H245NetworkAccessParameters_externalReference (pctxt, &pvalue->externalReference); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.t120SetupProcedurePresent); + /* encode extension elements */ + + if (pvalue->m.t120SetupProcedurePresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245NetworkAccessParameters_t120SetupProcedure (&lctxt, &pvalue->t120SetupProcedure); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EscrowData_escrowValue */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EscrowData_escrowValue (OOCTXT* pctxt, H245EscrowData_escrowValue* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeBitString (pctxt, pvalue->numbits, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EscrowData */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EscrowData (OOCTXT* pctxt, H245EscrowData* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode escrowID */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->escrowID); + if (stat != ASN_OK) return stat; + + /* encode escrowValue */ + + stat = asn1PE_H245EscrowData_escrowValue (pctxt, &pvalue->escrowValue); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionSync_escrowentry */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EncryptionSync_escrowentry (OOCTXT* pctxt, H245EncryptionSync_escrowentry* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245EscrowData (pctxt, ((H245EscrowData*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionSync */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EncryptionSync (OOCTXT* pctxt, H245EncryptionSync* pvalue) +{ + static Asn1SizeCnst h235Key_lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.escrowentryPresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + /* encode synchFlag */ + + stat = encodeConsUnsigned (pctxt, pvalue->synchFlag, 0U, 255U); + if (stat != ASN_OK) return stat; + + /* encode h235Key */ + + addSizeConstraint (pctxt, &h235Key_lsize1); + + stat = encodeOctetString (pctxt, pvalue->h235Key.numocts, pvalue->h235Key.data); + if (stat != ASN_OK) return stat; + + /* encode escrowentry */ + + if (pvalue->m.escrowentryPresent) { + stat = asn1PE_H245EncryptionSync_escrowentry (pctxt, &pvalue->escrowentry); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannel (OOCTXT* pctxt, H245OpenLogicalChannel* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.separateStackPresent || + pvalue->m.encryptionSyncPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.reverseLogicalChannelParametersPresent); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode forwardLogicalChannelParameters */ + + stat = asn1PE_H245OpenLogicalChannel_forwardLogicalChannelParameters (pctxt, &pvalue->forwardLogicalChannelParameters); + if (stat != ASN_OK) return stat; + + /* encode reverseLogicalChannelParameters */ + + if (pvalue->m.reverseLogicalChannelParametersPresent) { + stat = asn1PE_H245OpenLogicalChannel_reverseLogicalChannelParameters (pctxt, &pvalue->reverseLogicalChannelParameters); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.separateStackPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.encryptionSyncPresent); + /* encode extension elements */ + + if (pvalue->m.separateStackPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245NetworkAccessParameters (&lctxt, &pvalue->separateStack); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.encryptionSyncPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245EncryptionSync (&lctxt, &pvalue->encryptionSync); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CloseLogicalChannel_source */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CloseLogicalChannel_source (OOCTXT* pctxt, H245CloseLogicalChannel_source* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* user */ + case 1: + /* NULL */ + break; + + /* lcse */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CloseLogicalChannel_reason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CloseLogicalChannel_reason (OOCTXT* pctxt, H245CloseLogicalChannel_reason* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unknown */ + case 1: + /* NULL */ + break; + + /* reopen */ + case 2: + /* NULL */ + break; + + /* reservationFailure */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CloseLogicalChannel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CloseLogicalChannel (OOCTXT* pctxt, H245CloseLogicalChannel* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.reasonPresent); + + encodeBit (pctxt, extbit); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode source */ + + stat = asn1PE_H245CloseLogicalChannel_source (pctxt, &pvalue->source); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.reasonPresent); + /* encode extension elements */ + + if (pvalue->m.reasonPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245CloseLogicalChannel_reason (&lctxt, &pvalue->reason); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestChannelClose_reason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestChannelClose_reason (OOCTXT* pctxt, H245RequestChannelClose_reason* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unknown */ + case 1: + /* NULL */ + break; + + /* normal */ + case 2: + /* NULL */ + break; + + /* reopen */ + case 3: + /* NULL */ + break; + + /* reservationFailure */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestChannelClose */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestChannelClose (OOCTXT* pctxt, H245RequestChannelClose* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.qosCapabilityPresent || + pvalue->m.reasonPresent); + + encodeBit (pctxt, extbit); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.qosCapabilityPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.reasonPresent); + /* encode extension elements */ + + if (pvalue->m.qosCapabilityPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245QOSCapability (&lctxt, &pvalue->qosCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.reasonPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245RequestChannelClose_reason (&lctxt, &pvalue->reason); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexTableEntryNumber value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 1U, 15U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexElement_type_subElementList */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexElement_type_subElementList (OOCTXT* pctxt, H245MultiplexElement_type_subElementList* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 2, 255, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245MultiplexElement (pctxt, (H245MultiplexElement*)((H245MultiplexElement*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexElement_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexElement_type (OOCTXT* pctxt, H245MultiplexElement_type* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* logicalChannelNumber */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.logicalChannelNumber, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* subElementList */ + case 2: + stat = asn1PE_H245MultiplexElement_type_subElementList (pctxt, pvalue->u.subElementList); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexElement_repeatCount */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexElement_repeatCount (OOCTXT* pctxt, H245MultiplexElement_repeatCount* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* finite */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.finite, 1U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* untilClosingFlag */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexElement (OOCTXT* pctxt, H245MultiplexElement* pvalue) +{ + int stat = ASN_OK; + + /* encode type */ + + stat = asn1PE_H245MultiplexElement_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + /* encode repeatCount */ + + stat = asn1PE_H245MultiplexElement_repeatCount (pctxt, &pvalue->repeatCount); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntryDescriptor_elementList */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntryDescriptor_elementList (OOCTXT* pctxt, H245MultiplexEntryDescriptor_elementList* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245MultiplexElement (pctxt, ((H245MultiplexElement*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntryDescriptor */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntryDescriptor (OOCTXT* pctxt, H245MultiplexEntryDescriptor* pvalue) +{ + int stat = ASN_OK; + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.elementListPresent); + + /* encode multiplexTableEntryNumber */ + + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + /* encode elementList */ + + if (pvalue->m.elementListPresent) { + stat = asn1PE_H245MultiplexEntryDescriptor_elementList (pctxt, &pvalue->elementList); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySend_multiplexEntryDescriptors */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntrySend_multiplexEntryDescriptors (OOCTXT* pctxt, H245MultiplexEntrySend_multiplexEntryDescriptors* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245MultiplexEntryDescriptor (pctxt, ((H245MultiplexEntryDescriptor*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySend */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntrySend (OOCTXT* pctxt, H245MultiplexEntrySend* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode multiplexEntryDescriptors */ + + stat = asn1PE_H245MultiplexEntrySend_multiplexEntryDescriptors (pctxt, &pvalue->multiplexEntryDescriptors); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntry_entryNumbers */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntry_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntry_entryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntry */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntry (OOCTXT* pctxt, H245RequestMultiplexEntry* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode entryNumbers */ + + stat = asn1PE_H245RequestMultiplexEntry_entryNumbers (pctxt, &pvalue->entryNumbers); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H261VideoMode_resolution */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H261VideoMode_resolution (OOCTXT* pctxt, H245H261VideoMode_resolution* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* qcif */ + case 1: + /* NULL */ + break; + + /* cif */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H261VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H261VideoMode (OOCTXT* pctxt, H245H261VideoMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode resolution */ + + stat = asn1PE_H245H261VideoMode_resolution (pctxt, &pvalue->resolution); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 19200U); + if (stat != ASN_OK) return stat; + + /* encode stillImageTransmission */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->stillImageTransmission); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H262VideoMode_profileAndLevel */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H262VideoMode_profileAndLevel (OOCTXT* pctxt, H245H262VideoMode_profileAndLevel* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 11); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 10); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* profileAndLevel_SPatML */ + case 1: + /* NULL */ + break; + + /* profileAndLevel_MPatLL */ + case 2: + /* NULL */ + break; + + /* profileAndLevel_MPatML */ + case 3: + /* NULL */ + break; + + /* profileAndLevel_MPatH_14 */ + case 4: + /* NULL */ + break; + + /* profileAndLevel_MPatHL */ + case 5: + /* NULL */ + break; + + /* profileAndLevel_SNRatLL */ + case 6: + /* NULL */ + break; + + /* profileAndLevel_SNRatML */ + case 7: + /* NULL */ + break; + + /* profileAndLevel_SpatialatH_14 */ + case 8: + /* NULL */ + break; + + /* profileAndLevel_HPatML */ + case 9: + /* NULL */ + break; + + /* profileAndLevel_HPatH_14 */ + case 10: + /* NULL */ + break; + + /* profileAndLevel_HPatHL */ + case 11: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 12); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H262VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H262VideoMode (OOCTXT* pctxt, H245H262VideoMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBitRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.vbvBufferSizePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.samplesPerLinePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.linesPerFramePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.framesPerSecondPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.luminanceSampleRatePresent); + + /* encode profileAndLevel */ + + stat = asn1PE_H245H262VideoMode_profileAndLevel (pctxt, &pvalue->profileAndLevel); + if (stat != ASN_OK) return stat; + + /* encode videoBitRate */ + + if (pvalue->m.videoBitRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->videoBitRate, 0U, 1073741823U); + if (stat != ASN_OK) return stat; + + } + + /* encode vbvBufferSize */ + + if (pvalue->m.vbvBufferSizePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->vbvBufferSize, 0U, 262143U); + if (stat != ASN_OK) return stat; + + } + + /* encode samplesPerLine */ + + if (pvalue->m.samplesPerLinePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->samplesPerLine, 0U, 16383U); + if (stat != ASN_OK) return stat; + + } + + /* encode linesPerFrame */ + + if (pvalue->m.linesPerFramePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->linesPerFrame, 0U, 16383U); + if (stat != ASN_OK) return stat; + + } + + /* encode framesPerSecond */ + + if (pvalue->m.framesPerSecondPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->framesPerSecond, 0U, 15U); + if (stat != ASN_OK) return stat; + + } + + /* encode luminanceSampleRate */ + + if (pvalue->m.luminanceSampleRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263VideoMode_resolution */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263VideoMode_resolution (OOCTXT* pctxt, H245H263VideoMode_resolution* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* sqcif */ + case 1: + /* NULL */ + break; + + /* qcif */ + case 2: + /* NULL */ + break; + + /* cif */ + case 3: + /* NULL */ + break; + + /* cif4 */ + case 4: + /* NULL */ + break; + + /* cif16 */ + case 5: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* custom */ + case 6: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H263VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H263VideoMode (OOCTXT* pctxt, H245H263VideoMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.errorCompensationPresent || + pvalue->m.enhancementLayerInfoPresent || + pvalue->m.h263OptionsPresent); + + encodeBit (pctxt, extbit); + + /* encode resolution */ + + stat = asn1PE_H245H263VideoMode_resolution (pctxt, &pvalue->resolution); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 19200U); + if (stat != ASN_OK) return stat; + + /* encode unrestrictedVector */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->unrestrictedVector); + if (stat != ASN_OK) return stat; + + /* encode arithmeticCoding */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->arithmeticCoding); + if (stat != ASN_OK) return stat; + + /* encode advancedPrediction */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->advancedPrediction); + if (stat != ASN_OK) return stat; + + /* encode pbFrames */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->pbFrames); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 2); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.errorCompensationPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.enhancementLayerInfoPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h263OptionsPresent); + /* encode extension elements */ + + if (pvalue->m.errorCompensationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->errorCompensation); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.enhancementLayerInfoPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245EnhancementLayerInfo (&lctxt, &pvalue->enhancementLayerInfo); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h263OptionsPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H263Options (&lctxt, &pvalue->h263Options); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS11172VideoMode (OOCTXT* pctxt, H245IS11172VideoMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.videoBitRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.vbvBufferSizePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.samplesPerLinePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.linesPerFramePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.pictureRatePresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.luminanceSampleRatePresent); + + /* encode constrainedBitstream */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->constrainedBitstream); + if (stat != ASN_OK) return stat; + + /* encode videoBitRate */ + + if (pvalue->m.videoBitRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->videoBitRate, 0U, 1073741823U); + if (stat != ASN_OK) return stat; + + } + + /* encode vbvBufferSize */ + + if (pvalue->m.vbvBufferSizePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->vbvBufferSize, 0U, 262143U); + if (stat != ASN_OK) return stat; + + } + + /* encode samplesPerLine */ + + if (pvalue->m.samplesPerLinePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->samplesPerLine, 0U, 16383U); + if (stat != ASN_OK) return stat; + + } + + /* encode linesPerFrame */ + + if (pvalue->m.linesPerFramePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->linesPerFrame, 0U, 16383U); + if (stat != ASN_OK) return stat; + + } + + /* encode pictureRate */ + + if (pvalue->m.pictureRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->pictureRate, 0U, 15U); + if (stat != ASN_OK) return stat; + + } + + /* encode luminanceSampleRate */ + + if (pvalue->m.luminanceSampleRatePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->luminanceSampleRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VideoMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VideoMode (OOCTXT* pctxt, H245VideoMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* h261VideoMode */ + case 2: + stat = asn1PE_H245H261VideoMode (pctxt, pvalue->u.h261VideoMode); + if (stat != ASN_OK) return stat; + break; + + /* h262VideoMode */ + case 3: + stat = asn1PE_H245H262VideoMode (pctxt, pvalue->u.h262VideoMode); + if (stat != ASN_OK) return stat; + break; + + /* h263VideoMode */ + case 4: + stat = asn1PE_H245H263VideoMode (pctxt, pvalue->u.h263VideoMode); + if (stat != ASN_OK) return stat; + break; + + /* is11172VideoMode */ + case 5: + stat = asn1PE_H245IS11172VideoMode (pctxt, pvalue->u.is11172VideoMode); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* genericVideoMode */ + case 6: + stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericVideoMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* AudioMode_g7231 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245AudioMode_g7231 (OOCTXT* pctxt, H245AudioMode_g7231* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noSilenceSuppressionLowRate */ + case 1: + /* NULL */ + break; + + /* noSilenceSuppressionHighRate */ + case 2: + /* NULL */ + break; + + /* silenceSuppressionLowRate */ + case 3: + /* NULL */ + break; + + /* silenceSuppressionHighRate */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioMode_audioLayer */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS11172AudioMode_audioLayer (OOCTXT* pctxt, H245IS11172AudioMode_audioLayer* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* audioLayer1 */ + case 1: + /* NULL */ + break; + + /* audioLayer2 */ + case 2: + /* NULL */ + break; + + /* audioLayer3 */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioMode_audioSampling */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS11172AudioMode_audioSampling (OOCTXT* pctxt, H245IS11172AudioMode_audioSampling* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* audioSampling32k */ + case 1: + /* NULL */ + break; + + /* audioSampling44k1 */ + case 2: + /* NULL */ + break; + + /* audioSampling48k */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioMode_multichannelType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS11172AudioMode_multichannelType (OOCTXT* pctxt, H245IS11172AudioMode_multichannelType* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* singleChannel */ + case 1: + /* NULL */ + break; + + /* twoChannelStereo */ + case 2: + /* NULL */ + break; + + /* twoChannelDual */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS11172AudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS11172AudioMode (OOCTXT* pctxt, H245IS11172AudioMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode audioLayer */ + + stat = asn1PE_H245IS11172AudioMode_audioLayer (pctxt, &pvalue->audioLayer); + if (stat != ASN_OK) return stat; + + /* encode audioSampling */ + + stat = asn1PE_H245IS11172AudioMode_audioSampling (pctxt, &pvalue->audioSampling); + if (stat != ASN_OK) return stat; + + /* encode multichannelType */ + + stat = asn1PE_H245IS11172AudioMode_multichannelType (pctxt, &pvalue->multichannelType); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 448U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS13818AudioMode_audioLayer */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS13818AudioMode_audioLayer (OOCTXT* pctxt, H245IS13818AudioMode_audioLayer* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* audioLayer1 */ + case 1: + /* NULL */ + break; + + /* audioLayer2 */ + case 2: + /* NULL */ + break; + + /* audioLayer3 */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS13818AudioMode_audioSampling */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS13818AudioMode_audioSampling (OOCTXT* pctxt, H245IS13818AudioMode_audioSampling* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* audioSampling16k */ + case 1: + /* NULL */ + break; + + /* audioSampling22k05 */ + case 2: + /* NULL */ + break; + + /* audioSampling24k */ + case 3: + /* NULL */ + break; + + /* audioSampling32k */ + case 4: + /* NULL */ + break; + + /* audioSampling44k1 */ + case 5: + /* NULL */ + break; + + /* audioSampling48k */ + case 6: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS13818AudioMode_multichannelType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS13818AudioMode_multichannelType (OOCTXT* pctxt, H245IS13818AudioMode_multichannelType* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* singleChannel */ + case 1: + /* NULL */ + break; + + /* twoChannelStereo */ + case 2: + /* NULL */ + break; + + /* twoChannelDual */ + case 3: + /* NULL */ + break; + + /* threeChannels2_1 */ + case 4: + /* NULL */ + break; + + /* threeChannels3_0 */ + case 5: + /* NULL */ + break; + + /* fourChannels2_0_2_0 */ + case 6: + /* NULL */ + break; + + /* fourChannels2_2 */ + case 7: + /* NULL */ + break; + + /* fourChannels3_1 */ + case 8: + /* NULL */ + break; + + /* fiveChannels3_0_2_0 */ + case 9: + /* NULL */ + break; + + /* fiveChannels3_2 */ + case 10: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* IS13818AudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IS13818AudioMode (OOCTXT* pctxt, H245IS13818AudioMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode audioLayer */ + + stat = asn1PE_H245IS13818AudioMode_audioLayer (pctxt, &pvalue->audioLayer); + if (stat != ASN_OK) return stat; + + /* encode audioSampling */ + + stat = asn1PE_H245IS13818AudioMode_audioSampling (pctxt, &pvalue->audioSampling); + if (stat != ASN_OK) return stat; + + /* encode multichannelType */ + + stat = asn1PE_H245IS13818AudioMode_multichannelType (pctxt, &pvalue->multichannelType); + if (stat != ASN_OK) return stat; + + /* encode lowFrequencyEnhancement */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->lowFrequencyEnhancement); + if (stat != ASN_OK) return stat; + + /* encode multilingual */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multilingual); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 1130U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* G7231AnnexCMode_g723AnnexCAudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245G7231AnnexCMode_g723AnnexCAudioMode (OOCTXT* pctxt, H245G7231AnnexCMode_g723AnnexCAudioMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode highRateMode0 */ + + stat = encodeConsUnsigned (pctxt, pvalue->highRateMode0, 27U, 78U); + if (stat != ASN_OK) return stat; + + /* encode highRateMode1 */ + + stat = encodeConsUnsigned (pctxt, pvalue->highRateMode1, 27U, 78U); + if (stat != ASN_OK) return stat; + + /* encode lowRateMode0 */ + + stat = encodeConsUnsigned (pctxt, pvalue->lowRateMode0, 23U, 66U); + if (stat != ASN_OK) return stat; + + /* encode lowRateMode1 */ + + stat = encodeConsUnsigned (pctxt, pvalue->lowRateMode1, 23U, 66U); + if (stat != ASN_OK) return stat; + + /* encode sidMode0 */ + + stat = encodeConsUnsigned (pctxt, pvalue->sidMode0, 6U, 17U); + if (stat != ASN_OK) return stat; + + /* encode sidMode1 */ + + stat = encodeConsUnsigned (pctxt, pvalue->sidMode1, 6U, 17U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* G7231AnnexCMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245G7231AnnexCMode (OOCTXT* pctxt, H245G7231AnnexCMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode maxAl_sduAudioFrames */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxAl_sduAudioFrames, 1U, 256U); + if (stat != ASN_OK) return stat; + + /* encode silenceSuppression */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->silenceSuppression); + if (stat != ASN_OK) return stat; + + /* encode g723AnnexCAudioMode */ + + stat = asn1PE_H245G7231AnnexCMode_g723AnnexCAudioMode (pctxt, &pvalue->g723AnnexCAudioMode); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VBDMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VBDMode (OOCTXT* pctxt, H245VBDMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = asn1PE_H245AudioMode (pctxt, (H245AudioMode*)pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* AudioMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245AudioMode (OOCTXT* pctxt, H245AudioMode* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 14); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 13); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* g711Alaw64k */ + case 2: + /* NULL */ + break; + + /* g711Alaw56k */ + case 3: + /* NULL */ + break; + + /* g711Ulaw64k */ + case 4: + /* NULL */ + break; + + /* g711Ulaw56k */ + case 5: + /* NULL */ + break; + + /* g722_64k */ + case 6: + /* NULL */ + break; + + /* g722_56k */ + case 7: + /* NULL */ + break; + + /* g722_48k */ + case 8: + /* NULL */ + break; + + /* g728 */ + case 9: + /* NULL */ + break; + + /* g729 */ + case 10: + /* NULL */ + break; + + /* g729AnnexA */ + case 11: + /* NULL */ + break; + + /* g7231 */ + case 12: + stat = asn1PE_H245AudioMode_g7231 (pctxt, pvalue->u.g7231); + if (stat != ASN_OK) return stat; + break; + + /* is11172AudioMode */ + case 13: + stat = asn1PE_H245IS11172AudioMode (pctxt, pvalue->u.is11172AudioMode); + if (stat != ASN_OK) return stat; + break; + + /* is13818AudioMode */ + case 14: + stat = asn1PE_H245IS13818AudioMode (pctxt, pvalue->u.is13818AudioMode); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 15); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* g729wAnnexB */ + case 15: + stat = encodeConsUnsigned (&lctxt, pvalue->u.g729wAnnexB, 1U, 256U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* g729AnnexAwAnnexB */ + case 16: + stat = encodeConsUnsigned (&lctxt, pvalue->u.g729AnnexAwAnnexB, 1U, 256U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* g7231AnnexCMode */ + case 17: + stat = asn1PE_H245G7231AnnexCMode (&lctxt, pvalue->u.g7231AnnexCMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* gsmFullRate */ + case 18: + stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmFullRate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* gsmHalfRate */ + case 19: + stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmHalfRate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* gsmEnhancedFullRate */ + case 20: + stat = asn1PE_H245GSMAudioCapability (&lctxt, pvalue->u.gsmEnhancedFullRate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericAudioMode */ + case 21: + stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericAudioMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* g729Extensions */ + case 22: + stat = asn1PE_H245G729Extensions (&lctxt, pvalue->u.g729Extensions); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* vbd */ + case 23: + stat = asn1PE_H245VBDMode (&lctxt, pvalue->u.vbd); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataMode_application_nlpid */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataMode_application_nlpid (OOCTXT* pctxt, H245DataMode_application_nlpid* pvalue) +{ + int stat = ASN_OK; + + /* encode nlpidProtocol */ + + stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->nlpidProtocol); + if (stat != ASN_OK) return stat; + + /* encode nlpidData */ + + stat = encodeOctetString (pctxt, pvalue->nlpidData.numocts, pvalue->nlpidData.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataMode_application_t38fax */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataMode_application_t38fax (OOCTXT* pctxt, H245DataMode_application_t38fax* pvalue) +{ + int stat = ASN_OK; + + /* encode t38FaxProtocol */ + + stat = asn1PE_H245DataProtocolCapability (pctxt, &pvalue->t38FaxProtocol); + if (stat != ASN_OK) return stat; + + /* encode t38FaxProfile */ + + stat = asn1PE_H245T38FaxProfile (pctxt, &pvalue->t38FaxProfile); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataMode_application */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataMode_application (OOCTXT* pctxt, H245DataMode_application* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 10); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* t120 */ + case 2: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t120); + if (stat != ASN_OK) return stat; + break; + + /* dsm_cc */ + case 3: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.dsm_cc); + if (stat != ASN_OK) return stat; + break; + + /* userData */ + case 4: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.userData); + if (stat != ASN_OK) return stat; + break; + + /* t84 */ + case 5: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t84); + if (stat != ASN_OK) return stat; + break; + + /* t434 */ + case 6: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.t434); + if (stat != ASN_OK) return stat; + break; + + /* h224 */ + case 7: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.h224); + if (stat != ASN_OK) return stat; + break; + + /* nlpid */ + case 8: + stat = asn1PE_H245DataMode_application_nlpid (pctxt, pvalue->u.nlpid); + if (stat != ASN_OK) return stat; + break; + + /* dsvdControl */ + case 9: + /* NULL */ + break; + + /* h222DataPartitioning */ + case 10: + stat = asn1PE_H245DataProtocolCapability (pctxt, pvalue->u.h222DataPartitioning); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* t30fax */ + case 11: + stat = asn1PE_H245DataProtocolCapability (&lctxt, pvalue->u.t30fax); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* t140 */ + case 12: + stat = asn1PE_H245DataProtocolCapability (&lctxt, pvalue->u.t140); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* t38fax */ + case 13: + stat = asn1PE_H245DataMode_application_t38fax (&lctxt, pvalue->u.t38fax); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* genericDataMode */ + case 14: + stat = asn1PE_H245GenericCapability (&lctxt, pvalue->u.genericDataMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DataMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DataMode (OOCTXT* pctxt, H245DataMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode application */ + + stat = asn1PE_H245DataMode_application (pctxt, &pvalue->application); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H235Mode_mediaMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H235Mode_mediaMode (OOCTXT* pctxt, H245H235Mode_mediaMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* videoMode */ + case 2: + stat = asn1PE_H245VideoMode (pctxt, pvalue->u.videoMode); + if (stat != ASN_OK) return stat; + break; + + /* audioMode */ + case 3: + stat = asn1PE_H245AudioMode (pctxt, pvalue->u.audioMode); + if (stat != ASN_OK) return stat; + break; + + /* dataMode */ + case 4: + stat = asn1PE_H245DataMode (pctxt, pvalue->u.dataMode); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H235Mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H235Mode (OOCTXT* pctxt, H245H235Mode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode encryptionAuthenticationAndIntegrity */ + + stat = asn1PE_H245EncryptionAuthenticationAndIntegrity (pctxt, &pvalue->encryptionAuthenticationAndIntegrity); + if (stat != ASN_OK) return stat; + + /* encode mediaMode */ + + stat = asn1PE_H245H235Mode_mediaMode (pctxt, &pvalue->mediaMode); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTModeElement_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingDTModeElement_type (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement_type* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* videoMode */ + case 2: + stat = asn1PE_H245VideoMode (pctxt, pvalue->u.videoMode); + if (stat != ASN_OK) return stat; + break; + + /* audioMode */ + case 3: + stat = asn1PE_H245AudioMode (pctxt, pvalue->u.audioMode); + if (stat != ASN_OK) return stat; + break; + + /* dataMode */ + case 4: + stat = asn1PE_H245DataMode (pctxt, pvalue->u.dataMode); + if (stat != ASN_OK) return stat; + break; + + /* encryptionMode */ + case 5: + stat = asn1PE_H245EncryptionMode (pctxt, pvalue->u.encryptionMode); + if (stat != ASN_OK) return stat; + break; + + /* h235Mode */ + case 6: + stat = asn1PE_H245H235Mode (pctxt, pvalue->u.h235Mode); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTModeElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245RedundancyEncodingDTModeElement* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = asn1PE_H245RedundancyEncodingDTModeElement_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245RedundancyEncodingDTModeElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245RedundancyEncodingDTModeElement (OOCTXT* pctxt, H245_SeqOfH245RedundancyEncodingDTModeElement* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245RedundancyEncodingDTModeElement (pctxt, ((H245RedundancyEncodingDTModeElement*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingDTMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingDTMode (OOCTXT* pctxt, H245RedundancyEncodingDTMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode redundancyEncodingMethod */ + + stat = asn1PE_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod); + if (stat != ASN_OK) return stat; + + /* encode primary */ + + stat = asn1PE_H245RedundancyEncodingDTModeElement (pctxt, &pvalue->primary); + if (stat != ASN_OK) return stat; + + /* encode secondary */ + + stat = asn1PE_H245_SeqOfH245RedundancyEncodingDTModeElement (pctxt, &pvalue->secondary); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamElementMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245MultiplePayloadStreamElementMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = asn1PE_H245ModeElementType (pctxt, (H245ModeElementType*)pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245MultiplePayloadStreamElementMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245MultiplePayloadStreamElementMode (OOCTXT* pctxt, H245_SeqOfH245MultiplePayloadStreamElementMode* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245MultiplePayloadStreamElementMode (pctxt, ((H245MultiplePayloadStreamElementMode*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplePayloadStreamMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplePayloadStreamMode (OOCTXT* pctxt, H245MultiplePayloadStreamMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode elements */ + + stat = asn1PE_H245_SeqOfH245MultiplePayloadStreamElementMode (pctxt, &pvalue->elements); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream_differentPort */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_differentPort* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.protectedPayloadTypePresent); + + /* encode protectedSessionID */ + + stat = encodeConsUnsigned (pctxt, pvalue->protectedSessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode protectedPayloadType */ + + if (pvalue->m.protectedPayloadTypePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->protectedPayloadType, 0U, 127U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream_samePort */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_samePort (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream_samePort* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode protectedType */ + + stat = asn1PE_H245ModeElementType (pctxt, (H245ModeElementType*)pvalue->protectedType); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode_separateStream */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode_separateStream (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode_separateStream* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* differentPort */ + case 1: + stat = asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_differentPort (pctxt, pvalue->u.differentPort); + if (stat != ASN_OK) return stat; + break; + + /* samePort */ + case 2: + stat = asn1PE_H245FECMode_rfc2733Mode_mode_separateStream_samePort (pctxt, pvalue->u.samePort); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode_mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECMode_rfc2733Mode_mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode_mode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* redundancyEncoding */ + case 1: + /* NULL */ + break; + + /* separateStream */ + case 2: + stat = asn1PE_H245FECMode_rfc2733Mode_mode_separateStream (pctxt, pvalue->u.separateStream); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECMode_rfc2733Mode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECMode_rfc2733Mode (OOCTXT* pctxt, H245FECMode_rfc2733Mode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode mode */ + + stat = asn1PE_H245FECMode_rfc2733Mode_mode (pctxt, &pvalue->mode); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* FECMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FECMode (OOCTXT* pctxt, H245FECMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* rfc2733Mode */ + case 1: + stat = asn1PE_H245FECMode_rfc2733Mode (pctxt, pvalue->u.rfc2733Mode); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ModeElementType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ModeElementType (OOCTXT* pctxt, H245ModeElementType* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* videoMode */ + case 2: + stat = asn1PE_H245VideoMode (pctxt, pvalue->u.videoMode); + if (stat != ASN_OK) return stat; + break; + + /* audioMode */ + case 3: + stat = asn1PE_H245AudioMode (pctxt, pvalue->u.audioMode); + if (stat != ASN_OK) return stat; + break; + + /* dataMode */ + case 4: + stat = asn1PE_H245DataMode (pctxt, pvalue->u.dataMode); + if (stat != ASN_OK) return stat; + break; + + /* encryptionMode */ + case 5: + stat = asn1PE_H245EncryptionMode (pctxt, pvalue->u.encryptionMode); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* h235Mode */ + case 6: + stat = asn1PE_H245H235Mode (&lctxt, pvalue->u.h235Mode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multiplexedStreamMode */ + case 7: + stat = asn1PE_H245MultiplexedStreamParameter (&lctxt, pvalue->u.multiplexedStreamMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* redundancyEncodingDTMode */ + case 8: + stat = asn1PE_H245RedundancyEncodingDTMode (&lctxt, pvalue->u.redundancyEncodingDTMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multiplePayloadStreamMode */ + case 9: + stat = asn1PE_H245MultiplePayloadStreamMode (&lctxt, pvalue->u.multiplePayloadStreamMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* fecMode */ + case 10: + stat = asn1PE_H245FECMode (&lctxt, pvalue->u.fecMode); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223ModeParameters_adaptationLayerType_al3 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223ModeParameters_adaptationLayerType_al3 (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType_al3* pvalue) +{ + int stat = ASN_OK; + + /* encode controlFieldOctets */ + + stat = encodeConsUnsigned (pctxt, pvalue->controlFieldOctets, 0U, 2U); + if (stat != ASN_OK) return stat; + + /* encode sendBufferSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->sendBufferSize, 0U, 16777215U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223ModeParameters_adaptationLayerType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223ModeParameters_adaptationLayerType (OOCTXT* pctxt, H245H223ModeParameters_adaptationLayerType* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* al1Framed */ + case 2: + /* NULL */ + break; + + /* al1NotFramed */ + case 3: + /* NULL */ + break; + + /* al2WithoutSequenceNumbers */ + case 4: + /* NULL */ + break; + + /* al2WithSequenceNumbers */ + case 5: + /* NULL */ + break; + + /* al3 */ + case 6: + stat = asn1PE_H245H223ModeParameters_adaptationLayerType_al3 (pctxt, pvalue->u.al3); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* al1M */ + case 7: + stat = asn1PE_H245H223AL1MParameters (&lctxt, pvalue->u.al1M); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* al2M */ + case 8: + stat = asn1PE_H245H223AL2MParameters (&lctxt, pvalue->u.al2M); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* al3M */ + case 9: + stat = asn1PE_H245H223AL3MParameters (&lctxt, pvalue->u.al3M); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223ModeParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223ModeParameters (OOCTXT* pctxt, H245H223ModeParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode adaptationLayerType */ + + stat = asn1PE_H245H223ModeParameters_adaptationLayerType (pctxt, &pvalue->adaptationLayerType); + if (stat != ASN_OK) return stat; + + /* encode segmentableFlag */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->segmentableFlag); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* V76ModeParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245V76ModeParameters (OOCTXT* pctxt, H245V76ModeParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* suspendResumewAddress */ + case 1: + /* NULL */ + break; + + /* suspendResumewoAddress */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingMode_secondaryEncoding */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingMode_secondaryEncoding (OOCTXT* pctxt, H245RedundancyEncodingMode_secondaryEncoding* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* audioData */ + case 2: + stat = asn1PE_H245AudioMode (pctxt, pvalue->u.audioData); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RedundancyEncodingMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RedundancyEncodingMode (OOCTXT* pctxt, H245RedundancyEncodingMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.secondaryEncodingPresent); + + /* encode redundancyEncodingMethod */ + + stat = asn1PE_H245RedundancyEncodingMethod (pctxt, &pvalue->redundancyEncodingMethod); + if (stat != ASN_OK) return stat; + + /* encode secondaryEncoding */ + + if (pvalue->m.secondaryEncodingPresent) { + stat = asn1PE_H245RedundancyEncodingMode_secondaryEncoding (pctxt, &pvalue->secondaryEncoding); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250ModeParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H2250ModeParameters (OOCTXT* pctxt, H245H2250ModeParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.redundancyEncodingModePresent); + + /* encode redundancyEncodingMode */ + + if (pvalue->m.redundancyEncodingModePresent) { + stat = asn1PE_H245RedundancyEncodingMode (pctxt, &pvalue->redundancyEncodingMode); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexedStreamModeParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexedStreamModeParameters (OOCTXT* pctxt, H245MultiplexedStreamModeParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode logicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ModeElement */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ModeElement (OOCTXT* pctxt, H245ModeElement* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.v76ModeParametersPresent || + pvalue->m.h2250ModeParametersPresent || + pvalue->m.genericModeParametersPresent || + pvalue->m.multiplexedStreamModeParametersPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h223ModeParametersPresent); + + /* encode type */ + + stat = asn1PE_H245ModeElementType (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + /* encode h223ModeParameters */ + + if (pvalue->m.h223ModeParametersPresent) { + stat = asn1PE_H245H223ModeParameters (pctxt, &pvalue->h223ModeParameters); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 3); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.v76ModeParametersPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.h2250ModeParametersPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.genericModeParametersPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multiplexedStreamModeParametersPresent); + /* encode extension elements */ + + if (pvalue->m.v76ModeParametersPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245V76ModeParameters (&lctxt, &pvalue->v76ModeParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.h2250ModeParametersPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245H2250ModeParameters (&lctxt, &pvalue->h2250ModeParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.genericModeParametersPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245GenericCapability (&lctxt, &pvalue->genericModeParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.multiplexedStreamModeParametersPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245MultiplexedStreamModeParameters (&lctxt, &pvalue->multiplexedStreamModeParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ModeDescription */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ModeDescription (OOCTXT* pctxt, H245ModeDescription* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245ModeElement (pctxt, ((H245ModeElement*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMode_requestedModes */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMode_requestedModes (OOCTXT* pctxt, H245RequestMode_requestedModes* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245ModeDescription (pctxt, ((H245ModeDescription*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMode (OOCTXT* pctxt, H245RequestMode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode requestedModes */ + + stat = asn1PE_H245RequestMode_requestedModes (pctxt, &pvalue->requestedModes); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RoundTripDelayRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RoundTripDelayRequest (OOCTXT* pctxt, H245RoundTripDelayRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopRequest_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaintenanceLoopRequest_type (OOCTXT* pctxt, H245MaintenanceLoopRequest_type* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* systemLoop */ + case 1: + /* NULL */ + break; + + /* mediaLoop */ + case 2: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.mediaLoop); + if (stat != ASN_OK) return stat; + break; + + /* logicalChannelLoop */ + case 3: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelLoop); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaintenanceLoopRequest (OOCTXT* pctxt, H245MaintenanceLoopRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = asn1PE_H245MaintenanceLoopRequest_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CommunicationModeRequest (OOCTXT* pctxt, H245CommunicationModeRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + return (stat); +} + +/**************************************************************/ +/* */ +/* Criteria */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245Criteria (OOCTXT* pctxt, H245Criteria* pvalue) +{ + static Asn1SizeCnst value_lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode field */ + + stat = encodeObjectIdentifier (pctxt, &pvalue->field); + if (stat != ASN_OK) return stat; + + /* encode value */ + + addSizeConstraint (pctxt, &value_lsize1); + + stat = encodeOctetString (pctxt, pvalue->value.numocts, pvalue->value.data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CertSelectionCriteria */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CertSelectionCriteria (OOCTXT* pctxt, H245CertSelectionCriteria* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 16, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245Criteria (pctxt, ((H245Criteria*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceRequest_requestTerminalCertificate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceRequest_requestTerminalCertificate (OOCTXT* pctxt, H245ConferenceRequest_requestTerminalCertificate* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalLabelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.certSelectionCriteriaPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sRandomPresent); + + /* encode terminalLabel */ + + if (pvalue->m.terminalLabelPresent) { + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + } + + /* encode certSelectionCriteria */ + + if (pvalue->m.certSelectionCriteriaPresent) { + stat = asn1PE_H245CertSelectionCriteria (pctxt, &pvalue->certSelectionCriteria); + if (stat != ASN_OK) return stat; + } + + /* encode sRandom */ + + if (pvalue->m.sRandomPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->sRandom, 1U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RemoteMCRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RemoteMCRequest (OOCTXT* pctxt, H245RemoteMCRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* masterActivate */ + case 1: + /* NULL */ + break; + + /* slaveActivate */ + case 2: + /* NULL */ + break; + + /* deActivate */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceRequest (OOCTXT* pctxt, H245ConferenceRequest* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 8); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* terminalListRequest */ + case 1: + /* NULL */ + break; + + /* makeMeChair */ + case 2: + /* NULL */ + break; + + /* cancelMakeMeChair */ + case 3: + /* NULL */ + break; + + /* dropTerminal */ + case 4: + stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.dropTerminal); + if (stat != ASN_OK) return stat; + break; + + /* requestTerminalID */ + case 5: + stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.requestTerminalID); + if (stat != ASN_OK) return stat; + break; + + /* enterH243Password */ + case 6: + /* NULL */ + break; + + /* enterH243TerminalID */ + case 7: + /* NULL */ + break; + + /* enterH243ConferenceID */ + case 8: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* enterExtensionAddress */ + case 9: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* requestChairTokenOwner */ + case 10: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* requestTerminalCertificate */ + case 11: + stat = asn1PE_H245ConferenceRequest_requestTerminalCertificate (&lctxt, pvalue->u.requestTerminalCertificate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* broadcastMyLogicalChannel */ + case 12: + stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->u.broadcastMyLogicalChannel); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* makeTerminalBroadcaster */ + case 13: + stat = asn1PE_H245TerminalLabel (&lctxt, pvalue->u.makeTerminalBroadcaster); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* sendThisSource */ + case 14: + stat = asn1PE_H245TerminalLabel (&lctxt, pvalue->u.sendThisSource); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* requestAllTerminalIDs */ + case 15: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* remoteMCRequest */ + case 16: + stat = asn1PE_H245RemoteMCRequest (&lctxt, pvalue->u.remoteMCRequest); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_callInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkRequest_callInformation (OOCTXT* pctxt, H245MultilinkRequest_callInformation* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode maxNumberOfAdditionalConnections */ + + stat = encodeConsUnsigned (pctxt, pvalue->maxNumberOfAdditionalConnections, 1U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DialingInformationNetworkType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DialingInformationNetworkType (OOCTXT* pctxt, H245DialingInformationNetworkType* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* n_isdn */ + case 2: + /* NULL */ + break; + + /* gstn */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* mobile */ + case 4: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DialingInformationNumber_networkType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DialingInformationNumber_networkType (OOCTXT* pctxt, H245DialingInformationNumber_networkType* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 255, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245DialingInformationNetworkType (pctxt, ((H245DialingInformationNetworkType*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DialingInformationNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DialingInformationNumber (OOCTXT* pctxt, H245DialingInformationNumber* pvalue) +{ + static Asn1SizeCnst networkAddress_lsize1 = { 0, 0, 40, 0 }; + static Asn1SizeCnst subAddress_lsize1 = { 0, 1, 40, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.subAddressPresent); + + /* encode networkAddress */ + + addSizeConstraint (pctxt, &networkAddress_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->networkAddress, NUM_CANSET, 4, 4, 4); + if (stat != ASN_OK) return stat; + + /* encode subAddress */ + + if (pvalue->m.subAddressPresent) { + addSizeConstraint (pctxt, &subAddress_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->subAddress, 0, 8, 7, 7); + if (stat != ASN_OK) return stat; + } + + /* encode networkType */ + + stat = asn1PE_H245DialingInformationNumber_networkType (pctxt, &pvalue->networkType); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* DialingInformation_differential */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DialingInformation_differential (OOCTXT* pctxt, H245DialingInformation_differential* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245DialingInformationNumber (pctxt, ((H245DialingInformationNumber*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* DialingInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245DialingInformation (OOCTXT* pctxt, H245DialingInformation* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* differential */ + case 2: + stat = asn1PE_H245DialingInformation_differential (pctxt, pvalue->u.differential); + if (stat != ASN_OK) return stat; + break; + + /* infoNotAvailable */ + case 3: + stat = encodeConsUnsigned (pctxt, pvalue->u.infoNotAvailable, 1U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_addConnection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkRequest_addConnection (OOCTXT* pctxt, H245MultilinkRequest_addConnection* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode dialingInformation */ + + stat = asn1PE_H245DialingInformation (pctxt, &pvalue->dialingInformation); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConnectionIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConnectionIdentifier (OOCTXT* pctxt, H245ConnectionIdentifier* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode channelTag */ + + stat = encodeConsUnsigned (pctxt, pvalue->channelTag, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + /* encode sequenceNumber */ + + stat = encodeConsUnsigned (pctxt, pvalue->sequenceNumber, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_removeConnection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkRequest_removeConnection (OOCTXT* pctxt, H245MultilinkRequest_removeConnection* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode connectionIdentifier */ + + stat = asn1PE_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_maximumHeaderInterval_requestType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkRequest_maximumHeaderInterval_requestType (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval_requestType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* currentIntervalInformation */ + case 1: + /* NULL */ + break; + + /* requestedInterval */ + case 2: + stat = encodeConsUnsigned (pctxt, pvalue->u.requestedInterval, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest_maximumHeaderInterval */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkRequest_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkRequest_maximumHeaderInterval* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode requestType */ + + stat = asn1PE_H245MultilinkRequest_maximumHeaderInterval_requestType (pctxt, &pvalue->requestType); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkRequest (OOCTXT* pctxt, H245MultilinkRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* callInformation */ + case 2: + stat = asn1PE_H245MultilinkRequest_callInformation (pctxt, pvalue->u.callInformation); + if (stat != ASN_OK) return stat; + break; + + /* addConnection */ + case 3: + stat = asn1PE_H245MultilinkRequest_addConnection (pctxt, pvalue->u.addConnection); + if (stat != ASN_OK) return stat; + break; + + /* removeConnection */ + case 4: + stat = asn1PE_H245MultilinkRequest_removeConnection (pctxt, pvalue->u.removeConnection); + if (stat != ASN_OK) return stat; + break; + + /* maximumHeaderInterval */ + case 5: + stat = asn1PE_H245MultilinkRequest_maximumHeaderInterval (pctxt, pvalue->u.maximumHeaderInterval); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaximumBitRate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaximumBitRate (OOCTXT* pctxt, H245MaximumBitRate value) +{ + int stat = ASN_OK; + + stat = encodeConsUnsigned (pctxt, value, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245LogicalChannelRateRequest (OOCTXT* pctxt, H245LogicalChannelRateRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode logicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode maximumBitRate */ + + stat = asn1PE_H245MaximumBitRate (pctxt, pvalue->maximumBitRate); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMessage (OOCTXT* pctxt, H245RequestMessage* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 11); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 10); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* masterSlaveDetermination */ + case 2: + stat = asn1PE_H245MasterSlaveDetermination (pctxt, pvalue->u.masterSlaveDetermination); + if (stat != ASN_OK) return stat; + break; + + /* terminalCapabilitySet */ + case 3: + stat = asn1PE_H245TerminalCapabilitySet (pctxt, pvalue->u.terminalCapabilitySet); + if (stat != ASN_OK) return stat; + break; + + /* openLogicalChannel */ + case 4: + stat = asn1PE_H245OpenLogicalChannel (pctxt, pvalue->u.openLogicalChannel); + if (stat != ASN_OK) return stat; + break; + + /* closeLogicalChannel */ + case 5: + stat = asn1PE_H245CloseLogicalChannel (pctxt, pvalue->u.closeLogicalChannel); + if (stat != ASN_OK) return stat; + break; + + /* requestChannelClose */ + case 6: + stat = asn1PE_H245RequestChannelClose (pctxt, pvalue->u.requestChannelClose); + if (stat != ASN_OK) return stat; + break; + + /* multiplexEntrySend */ + case 7: + stat = asn1PE_H245MultiplexEntrySend (pctxt, pvalue->u.multiplexEntrySend); + if (stat != ASN_OK) return stat; + break; + + /* requestMultiplexEntry */ + case 8: + stat = asn1PE_H245RequestMultiplexEntry (pctxt, pvalue->u.requestMultiplexEntry); + if (stat != ASN_OK) return stat; + break; + + /* requestMode */ + case 9: + stat = asn1PE_H245RequestMode (pctxt, pvalue->u.requestMode); + if (stat != ASN_OK) return stat; + break; + + /* roundTripDelayRequest */ + case 10: + stat = asn1PE_H245RoundTripDelayRequest (pctxt, pvalue->u.roundTripDelayRequest); + if (stat != ASN_OK) return stat; + break; + + /* maintenanceLoopRequest */ + case 11: + stat = asn1PE_H245MaintenanceLoopRequest (pctxt, pvalue->u.maintenanceLoopRequest); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 12); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* communicationModeRequest */ + case 12: + stat = asn1PE_H245CommunicationModeRequest (&lctxt, pvalue->u.communicationModeRequest); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* conferenceRequest */ + case 13: + stat = asn1PE_H245ConferenceRequest (&lctxt, pvalue->u.conferenceRequest); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multilinkRequest */ + case 14: + stat = asn1PE_H245MultilinkRequest (&lctxt, pvalue->u.multilinkRequest); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* logicalChannelRateRequest */ + case 15: + stat = asn1PE_H245LogicalChannelRateRequest (&lctxt, pvalue->u.logicalChannelRateRequest); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationAck_decision */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MasterSlaveDeterminationAck_decision (OOCTXT* pctxt, H245MasterSlaveDeterminationAck_decision* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* master */ + case 1: + /* NULL */ + break; + + /* slave */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MasterSlaveDeterminationAck (OOCTXT* pctxt, H245MasterSlaveDeterminationAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode decision */ + + stat = asn1PE_H245MasterSlaveDeterminationAck_decision (pctxt, &pvalue->decision); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MasterSlaveDeterminationReject_cause (OOCTXT* pctxt, H245MasterSlaveDeterminationReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* identicalNumbers */ + case 1: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MasterSlaveDeterminationReject (OOCTXT* pctxt, H245MasterSlaveDeterminationReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode cause */ + + stat = asn1PE_H245MasterSlaveDeterminationReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalCapabilitySetAck (OOCTXT* pctxt, H245TerminalCapabilitySetAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject_cause_tableEntryCapacityExce */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* highestEntryNumberProcessed */ + case 1: + stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->u.highestEntryNumberProcessed); + if (stat != ASN_OK) return stat; + break; + + /* noneProcessed */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalCapabilitySetReject_cause (OOCTXT* pctxt, H245TerminalCapabilitySetReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unspecified */ + case 1: + /* NULL */ + break; + + /* undefinedTableEntryUsed */ + case 2: + /* NULL */ + break; + + /* descriptorCapacityExceeded */ + case 3: + /* NULL */ + break; + + /* tableEntryCapacityExceeded */ + case 4: + stat = asn1PE_H245TerminalCapabilitySetReject_cause_tableEntryCapacityExceeded (pctxt, pvalue->u.tableEntryCapacityExceeded); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalCapabilitySetReject (OOCTXT* pctxt, H245TerminalCapabilitySetReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode cause */ + + stat = asn1PE_H245TerminalCapabilitySetReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_reverseLogicalChannelParameters_mu */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* h222LogicalChannelParameters */ + case 1: + stat = asn1PE_H245H222LogicalChannelParameters (pctxt, pvalue->u.h222LogicalChannelParameters); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* h2250LogicalChannelParameters */ + case 2: + stat = asn1PE_H245H2250LogicalChannelParameters (&lctxt, pvalue->u.h2250LogicalChannelParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_reverseLogicalChannelParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_reverseLogicalChannelParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.replacementForPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.portNumberPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.multiplexParametersPresent); + + /* encode reverseLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->reverseLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode portNumber */ + + if (pvalue->m.portNumberPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->portNumber, 0U, 65535U); + if (stat != ASN_OK) return stat; + + } + + /* encode multiplexParameters */ + + if (pvalue->m.multiplexParametersPresent) { + stat = asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters_multiplexParameters (pctxt, &pvalue->multiplexParameters); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.replacementForPresent); + /* encode extension elements */ + + if (pvalue->m.replacementForPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245LogicalChannelNumber (&lctxt, pvalue->replacementFor); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250LogicalChannelAckParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H2250LogicalChannelAckParameters (OOCTXT* pctxt, H245H2250LogicalChannelAckParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.flowControlToZeroPresent || + pvalue->m.portNumberPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sessionIDPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaChannelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlChannelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.dynamicRTPPayloadTypePresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + /* encode sessionID */ + + if (pvalue->m.sessionIDPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->sessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + + } + + /* encode mediaChannel */ + + if (pvalue->m.mediaChannelPresent) { + stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaChannel); + if (stat != ASN_OK) return stat; + } + + /* encode mediaControlChannel */ + + if (pvalue->m.mediaControlChannelPresent) { + stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaControlChannel); + if (stat != ASN_OK) return stat; + } + + /* encode dynamicRTPPayloadType */ + + if (pvalue->m.dynamicRTPPayloadTypePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->dynamicRTPPayloadType, 96U, 127U); + if (stat != ASN_OK) return stat; + + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 1); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.flowControlToZeroPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.portNumberPresent); + /* encode extension elements */ + + if (pvalue->m.flowControlToZeroPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeBit (&lctxt, (ASN1BOOL)pvalue->flowControlToZero); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.portNumberPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->portNumber, 0U, 65535U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck_forwardMultiplexAckParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (OOCTXT* pctxt, H245OpenLogicalChannelAck_forwardMultiplexAckParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* h2250LogicalChannelAckParameters */ + case 1: + stat = asn1PE_H245H2250LogicalChannelAckParameters (pctxt, pvalue->u.h2250LogicalChannelAckParameters); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannelAck (OOCTXT* pctxt, H245OpenLogicalChannelAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.separateStackPresent || + pvalue->m.forwardMultiplexAckParametersPresent || + pvalue->m.encryptionSyncPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.reverseLogicalChannelParametersPresent); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode reverseLogicalChannelParameters */ + + if (pvalue->m.reverseLogicalChannelParametersPresent) { + stat = asn1PE_H245OpenLogicalChannelAck_reverseLogicalChannelParameters (pctxt, &pvalue->reverseLogicalChannelParameters); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 2); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.separateStackPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.forwardMultiplexAckParametersPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.encryptionSyncPresent); + /* encode extension elements */ + + if (pvalue->m.separateStackPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245NetworkAccessParameters (&lctxt, &pvalue->separateStack); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.forwardMultiplexAckParametersPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245OpenLogicalChannelAck_forwardMultiplexAckParameters (&lctxt, &pvalue->forwardMultiplexAckParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.encryptionSyncPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245EncryptionSync (&lctxt, &pvalue->encryptionSync); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannelReject_cause (OOCTXT* pctxt, H245OpenLogicalChannelReject_cause* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 6); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 5); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unspecified */ + case 1: + /* NULL */ + break; + + /* unsuitableReverseParameters */ + case 2: + /* NULL */ + break; + + /* dataTypeNotSupported */ + case 3: + /* NULL */ + break; + + /* dataTypeNotAvailable */ + case 4: + /* NULL */ + break; + + /* unknownDataType */ + case 5: + /* NULL */ + break; + + /* dataTypeALCombinationNotSupported */ + case 6: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 7); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* multicastChannelNotAllowed */ + case 7: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* insufficientBandwidth */ + case 8: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* separateStackEstablishmentFailed */ + case 9: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* invalidSessionID */ + case 10: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* masterSlaveConflict */ + case 11: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* waitForCommunicationMode */ + case 12: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* invalidDependentChannel */ + case 13: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* replacementForRejected */ + case 14: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannelReject (OOCTXT* pctxt, H245OpenLogicalChannelReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode cause */ + + stat = asn1PE_H245OpenLogicalChannelReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CloseLogicalChannelAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CloseLogicalChannelAck (OOCTXT* pctxt, H245CloseLogicalChannelAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestChannelCloseAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestChannelCloseAck (OOCTXT* pctxt, H245RequestChannelCloseAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestChannelCloseReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestChannelCloseReject_cause (OOCTXT* pctxt, H245RequestChannelCloseReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unspecified */ + case 1: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestChannelCloseReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestChannelCloseReject (OOCTXT* pctxt, H245RequestChannelCloseReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode cause */ + + stat = asn1PE_H245RequestChannelCloseReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendAck_multiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntrySendAck_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendAck_multiplexTableEntryNumber* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntrySendAck (OOCTXT* pctxt, H245MultiplexEntrySendAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode multiplexTableEntryNumber */ + + stat = asn1PE_H245MultiplexEntrySendAck_multiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntryRejectionDescriptions_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions_cause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unspecifiedCause */ + case 1: + /* NULL */ + break; + + /* descriptorTooComplex */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntryRejectionDescriptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntryRejectionDescriptions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode multiplexTableEntryNumber */ + + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + /* encode cause */ + + stat = asn1PE_H245MultiplexEntryRejectionDescriptions_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendReject_rejectionDescriptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntrySendReject_rejectionDescriptions (OOCTXT* pctxt, H245MultiplexEntrySendReject_rejectionDescriptions* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245MultiplexEntryRejectionDescriptions (pctxt, ((H245MultiplexEntryRejectionDescriptions*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntrySendReject (OOCTXT* pctxt, H245MultiplexEntrySendReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode rejectionDescriptions */ + + stat = asn1PE_H245MultiplexEntrySendReject_rejectionDescriptions (pctxt, &pvalue->rejectionDescriptions); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryAck_entryNumbers */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryAck_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryAck_entryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryAck (OOCTXT* pctxt, H245RequestMultiplexEntryAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode entryNumbers */ + + stat = asn1PE_H245RequestMultiplexEntryAck_entryNumbers (pctxt, &pvalue->entryNumbers); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject_entryNumbers */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryReject_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryReject_entryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRejectionDescriptions_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryRejectionDescriptions_cause (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions_cause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unspecifiedCause */ + case 1: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRejectionDescriptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryRejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryRejectionDescriptions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode multiplexTableEntryNumber */ + + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + /* encode cause */ + + stat = asn1PE_H245RequestMultiplexEntryRejectionDescriptions_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject_rejectionDescriptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryReject_rejectionDescriptions (OOCTXT* pctxt, H245RequestMultiplexEntryReject_rejectionDescriptions* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245RequestMultiplexEntryRejectionDescriptions (pctxt, ((H245RequestMultiplexEntryRejectionDescriptions*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryReject (OOCTXT* pctxt, H245RequestMultiplexEntryReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode entryNumbers */ + + stat = asn1PE_H245RequestMultiplexEntryReject_entryNumbers (pctxt, &pvalue->entryNumbers); + if (stat != ASN_OK) return stat; + + /* encode rejectionDescriptions */ + + stat = asn1PE_H245RequestMultiplexEntryReject_rejectionDescriptions (pctxt, &pvalue->rejectionDescriptions); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestModeAck_response */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestModeAck_response (OOCTXT* pctxt, H245RequestModeAck_response* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* willTransmitMostPreferredMode */ + case 1: + /* NULL */ + break; + + /* willTransmitLessPreferredMode */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestModeAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestModeAck (OOCTXT* pctxt, H245RequestModeAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode response */ + + stat = asn1PE_H245RequestModeAck_response (pctxt, &pvalue->response); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestModeReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestModeReject_cause (OOCTXT* pctxt, H245RequestModeReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* modeUnavailable */ + case 1: + /* NULL */ + break; + + /* multipointConstraint */ + case 2: + /* NULL */ + break; + + /* requestDenied */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestModeReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestModeReject (OOCTXT* pctxt, H245RequestModeReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode cause */ + + stat = asn1PE_H245RequestModeReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RoundTripDelayResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RoundTripDelayResponse (OOCTXT* pctxt, H245RoundTripDelayResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopAck_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaintenanceLoopAck_type (OOCTXT* pctxt, H245MaintenanceLoopAck_type* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* systemLoop */ + case 1: + /* NULL */ + break; + + /* mediaLoop */ + case 2: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.mediaLoop); + if (stat != ASN_OK) return stat; + break; + + /* logicalChannelLoop */ + case 3: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelLoop); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopAck */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaintenanceLoopAck (OOCTXT* pctxt, H245MaintenanceLoopAck* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = asn1PE_H245MaintenanceLoopAck_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaintenanceLoopReject_type (OOCTXT* pctxt, H245MaintenanceLoopReject_type* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* systemLoop */ + case 1: + /* NULL */ + break; + + /* mediaLoop */ + case 2: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.mediaLoop); + if (stat != ASN_OK) return stat; + break; + + /* logicalChannelLoop */ + case 3: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelLoop); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaintenanceLoopReject_cause (OOCTXT* pctxt, H245MaintenanceLoopReject_cause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* canNotPerformLoop */ + case 1: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaintenanceLoopReject (OOCTXT* pctxt, H245MaintenanceLoopReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode type */ + + stat = asn1PE_H245MaintenanceLoopReject_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + /* encode cause */ + + stat = asn1PE_H245MaintenanceLoopReject_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeTableEntry_dataType */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CommunicationModeTableEntry_dataType (OOCTXT* pctxt, H245CommunicationModeTableEntry_dataType* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* videoData */ + case 1: + stat = asn1PE_H245VideoCapability (pctxt, pvalue->u.videoData); + if (stat != ASN_OK) return stat; + break; + + /* audioData */ + case 2: + stat = asn1PE_H245AudioCapability (pctxt, pvalue->u.audioData); + if (stat != ASN_OK) return stat; + break; + + /* data */ + case 3: + stat = asn1PE_H245DataApplicationCapability (pctxt, pvalue->u.data); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeTableEntry */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CommunicationModeTableEntry (OOCTXT* pctxt, H245CommunicationModeTableEntry* pvalue) +{ + static Asn1SizeCnst sessionDescription_lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.redundancyEncodingPresent || + pvalue->m.sessionDependencyPresent || + pvalue->m.destinationPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.nonStandardPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.associatedSessionIDPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalLabelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaChannelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaGuaranteedDeliveryPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlChannelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.mediaControlGuaranteedDeliveryPresent); + + /* encode nonStandard */ + + if (pvalue->m.nonStandardPresent) { + stat = asn1PE_H245_SeqOfH245NonStandardParameter (pctxt, &pvalue->nonStandard); + if (stat != ASN_OK) return stat; + } + + /* encode sessionID */ + + stat = encodeConsUnsigned (pctxt, pvalue->sessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode associatedSessionID */ + + if (pvalue->m.associatedSessionIDPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->associatedSessionID, 1U, 255U); + if (stat != ASN_OK) return stat; + + } + + /* encode terminalLabel */ + + if (pvalue->m.terminalLabelPresent) { + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + } + + /* encode sessionDescription */ + + addSizeConstraint (pctxt, &sessionDescription_lsize1); + + stat = encodeBMPString (pctxt, pvalue->sessionDescription, 0); + if (stat != ASN_OK) return stat; + + /* encode dataType */ + + stat = asn1PE_H245CommunicationModeTableEntry_dataType (pctxt, &pvalue->dataType); + if (stat != ASN_OK) return stat; + + /* encode mediaChannel */ + + if (pvalue->m.mediaChannelPresent) { + stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaChannel); + if (stat != ASN_OK) return stat; + } + + /* encode mediaGuaranteedDelivery */ + + if (pvalue->m.mediaGuaranteedDeliveryPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mediaGuaranteedDelivery); + if (stat != ASN_OK) return stat; + } + + /* encode mediaControlChannel */ + + if (pvalue->m.mediaControlChannelPresent) { + stat = asn1PE_H245TransportAddress (pctxt, &pvalue->mediaControlChannel); + if (stat != ASN_OK) return stat; + } + + /* encode mediaControlGuaranteedDelivery */ + + if (pvalue->m.mediaControlGuaranteedDeliveryPresent) { + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->mediaControlGuaranteedDelivery); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 2); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.redundancyEncodingPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.sessionDependencyPresent); + encodeBit (pctxt, (ASN1BOOL)pvalue->m.destinationPresent); + /* encode extension elements */ + + if (pvalue->m.redundancyEncodingPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245RedundancyEncoding (&lctxt, &pvalue->redundancyEncoding); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.sessionDependencyPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeConsUnsigned (&lctxt, pvalue->sessionDependency, 1U, 255U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + if (pvalue->m.destinationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245TerminalLabel (&lctxt, &pvalue->destination); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeResponse_communicationModeTable */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CommunicationModeResponse_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeResponse_communicationModeTable* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245CommunicationModeTableEntry (pctxt, ((H245CommunicationModeTableEntry*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CommunicationModeResponse (OOCTXT* pctxt, H245CommunicationModeResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 1); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 0); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* communicationModeTable */ + case 1: + stat = asn1PE_H245CommunicationModeResponse_communicationModeTable (pctxt, pvalue->u.communicationModeTable); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 2); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalID */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalID (OOCTXT* pctxt, H245TerminalID* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 128, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_mCTerminalIDResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_mCTerminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_mCTerminalIDResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalLabel */ + + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + /* encode terminalID */ + + stat = asn1PE_H245TerminalID (pctxt, &pvalue->terminalID); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalIDResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_terminalIDResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalIDResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalLabel */ + + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + /* encode terminalID */ + + stat = asn1PE_H245TerminalID (pctxt, &pvalue->terminalID); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceID */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceID (OOCTXT* pctxt, H245ConferenceID* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 32, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_conferenceIDResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_conferenceIDResponse (OOCTXT* pctxt, H245ConferenceResponse_conferenceIDResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalLabel */ + + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + /* encode conferenceID */ + + stat = asn1PE_H245ConferenceID (pctxt, &pvalue->conferenceID); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* Password */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245Password (OOCTXT* pctxt, H245Password* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 32, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_passwordResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_passwordResponse (OOCTXT* pctxt, H245ConferenceResponse_passwordResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalLabel */ + + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + /* encode password */ + + stat = asn1PE_H245Password (pctxt, &pvalue->password); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalListResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_terminalListResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalListResponse* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245TerminalLabel (pctxt, ((H245TerminalLabel*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_makeMeChairResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_makeMeChairResponse (OOCTXT* pctxt, H245ConferenceResponse_makeMeChairResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* grantedChairToken */ + case 1: + /* NULL */ + break; + + /* deniedChairToken */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_extensionAddressResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_extensionAddressResponse (OOCTXT* pctxt, H245ConferenceResponse_extensionAddressResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode extensionAddress */ + + stat = asn1PE_H245TerminalID (pctxt, &pvalue->extensionAddress); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_chairTokenOwnerResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_chairTokenOwnerResponse (OOCTXT* pctxt, H245ConferenceResponse_chairTokenOwnerResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalLabel */ + + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + /* encode terminalID */ + + stat = asn1PE_H245TerminalID (pctxt, &pvalue->terminalID); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_terminalCertificateResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_terminalCertificateResponse (OOCTXT* pctxt, H245ConferenceResponse_terminalCertificateResponse* pvalue) +{ + static Asn1SizeCnst certificateResponse_lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.terminalLabelPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.certificateResponsePresent); + + /* encode terminalLabel */ + + if (pvalue->m.terminalLabelPresent) { + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + } + + /* encode certificateResponse */ + + if (pvalue->m.certificateResponsePresent) { + addSizeConstraint (pctxt, &certificateResponse_lsize1); + + stat = encodeOctetString (pctxt, pvalue->certificateResponse.numocts, pvalue->certificateResponse.data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_broadcastMyLogicalChannelResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_broadcastMyLogicalChannelResponse (OOCTXT* pctxt, H245ConferenceResponse_broadcastMyLogicalChannelResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* grantedBroadcastMyLogicalChannel */ + case 1: + /* NULL */ + break; + + /* deniedBroadcastMyLogicalChannel */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_makeTerminalBroadcasterResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_makeTerminalBroadcasterResponse (OOCTXT* pctxt, H245ConferenceResponse_makeTerminalBroadcasterResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* grantedMakeTerminalBroadcaster */ + case 1: + /* NULL */ + break; + + /* deniedMakeTerminalBroadcaster */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse_sendThisSourceResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse_sendThisSourceResponse (OOCTXT* pctxt, H245ConferenceResponse_sendThisSourceResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* grantedSendThisSource */ + case 1: + /* NULL */ + break; + + /* deniedSendThisSource */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalInformation (OOCTXT* pctxt, H245TerminalInformation* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalLabel */ + + stat = asn1PE_H245TerminalLabel (pctxt, &pvalue->terminalLabel); + if (stat != ASN_OK) return stat; + + /* encode terminalID */ + + stat = asn1PE_H245TerminalID (pctxt, &pvalue->terminalID); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245TerminalInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245TerminalInformation (OOCTXT* pctxt, H245_SeqOfH245TerminalInformation* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245TerminalInformation (pctxt, ((H245TerminalInformation*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestAllTerminalIDsResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestAllTerminalIDsResponse (OOCTXT* pctxt, H245RequestAllTerminalIDsResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalInformation */ + + stat = asn1PE_H245_SeqOfH245TerminalInformation (pctxt, &pvalue->terminalInformation); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RemoteMCResponse_reject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RemoteMCResponse_reject (OOCTXT* pctxt, H245RemoteMCResponse_reject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* unspecified */ + case 1: + /* NULL */ + break; + + /* functionNotSupported */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RemoteMCResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RemoteMCResponse (OOCTXT* pctxt, H245RemoteMCResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* accept */ + case 1: + /* NULL */ + break; + + /* reject */ + case 2: + stat = asn1PE_H245RemoteMCResponse_reject (pctxt, pvalue->u.reject); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceResponse (OOCTXT* pctxt, H245ConferenceResponse* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 8); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 7); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* mCTerminalIDResponse */ + case 1: + stat = asn1PE_H245ConferenceResponse_mCTerminalIDResponse (pctxt, pvalue->u.mCTerminalIDResponse); + if (stat != ASN_OK) return stat; + break; + + /* terminalIDResponse */ + case 2: + stat = asn1PE_H245ConferenceResponse_terminalIDResponse (pctxt, pvalue->u.terminalIDResponse); + if (stat != ASN_OK) return stat; + break; + + /* conferenceIDResponse */ + case 3: + stat = asn1PE_H245ConferenceResponse_conferenceIDResponse (pctxt, pvalue->u.conferenceIDResponse); + if (stat != ASN_OK) return stat; + break; + + /* passwordResponse */ + case 4: + stat = asn1PE_H245ConferenceResponse_passwordResponse (pctxt, pvalue->u.passwordResponse); + if (stat != ASN_OK) return stat; + break; + + /* terminalListResponse */ + case 5: + stat = asn1PE_H245ConferenceResponse_terminalListResponse (pctxt, pvalue->u.terminalListResponse); + if (stat != ASN_OK) return stat; + break; + + /* videoCommandReject */ + case 6: + /* NULL */ + break; + + /* terminalDropReject */ + case 7: + /* NULL */ + break; + + /* makeMeChairResponse */ + case 8: + stat = asn1PE_H245ConferenceResponse_makeMeChairResponse (pctxt, pvalue->u.makeMeChairResponse); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 9); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* extensionAddressResponse */ + case 9: + stat = asn1PE_H245ConferenceResponse_extensionAddressResponse (&lctxt, pvalue->u.extensionAddressResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* chairTokenOwnerResponse */ + case 10: + stat = asn1PE_H245ConferenceResponse_chairTokenOwnerResponse (&lctxt, pvalue->u.chairTokenOwnerResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* terminalCertificateResponse */ + case 11: + stat = asn1PE_H245ConferenceResponse_terminalCertificateResponse (&lctxt, pvalue->u.terminalCertificateResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* broadcastMyLogicalChannelResponse */ + case 12: + stat = asn1PE_H245ConferenceResponse_broadcastMyLogicalChannelResponse (&lctxt, pvalue->u.broadcastMyLogicalChannelResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* makeTerminalBroadcasterResponse */ + case 13: + stat = asn1PE_H245ConferenceResponse_makeTerminalBroadcasterResponse (&lctxt, pvalue->u.makeTerminalBroadcasterResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* sendThisSourceResponse */ + case 14: + stat = asn1PE_H245ConferenceResponse_sendThisSourceResponse (&lctxt, pvalue->u.sendThisSourceResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* requestAllTerminalIDsResponse */ + case 15: + stat = asn1PE_H245RequestAllTerminalIDsResponse (&lctxt, pvalue->u.requestAllTerminalIDsResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* remoteMCResponse */ + case 16: + stat = asn1PE_H245RemoteMCResponse (&lctxt, pvalue->u.remoteMCResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_callInformation */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkResponse_callInformation (OOCTXT* pctxt, H245MultilinkResponse_callInformation* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode dialingInformation */ + + stat = asn1PE_H245DialingInformation (pctxt, &pvalue->dialingInformation); + if (stat != ASN_OK) return stat; + + /* encode callAssociationNumber */ + + stat = encodeConsUnsigned (pctxt, pvalue->callAssociationNumber, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection_responseCode_rejected */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkResponse_addConnection_responseCode_rejected (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode_rejected* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* connectionsNotAvailable */ + case 1: + /* NULL */ + break; + + /* userRejected */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection_responseCode */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkResponse_addConnection_responseCode (OOCTXT* pctxt, H245MultilinkResponse_addConnection_responseCode* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* accepted */ + case 1: + /* NULL */ + break; + + /* rejected */ + case 2: + stat = asn1PE_H245MultilinkResponse_addConnection_responseCode_rejected (pctxt, pvalue->u.rejected); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_addConnection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkResponse_addConnection (OOCTXT* pctxt, H245MultilinkResponse_addConnection* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode responseCode */ + + stat = asn1PE_H245MultilinkResponse_addConnection_responseCode (pctxt, &pvalue->responseCode); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_removeConnection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkResponse_removeConnection (OOCTXT* pctxt, H245MultilinkResponse_removeConnection* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode connectionIdentifier */ + + stat = asn1PE_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse_maximumHeaderInterval */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkResponse_maximumHeaderInterval (OOCTXT* pctxt, H245MultilinkResponse_maximumHeaderInterval* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode currentInterval */ + + stat = encodeConsUnsigned (pctxt, pvalue->currentInterval, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkResponse */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkResponse (OOCTXT* pctxt, H245MultilinkResponse* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* callInformation */ + case 2: + stat = asn1PE_H245MultilinkResponse_callInformation (pctxt, pvalue->u.callInformation); + if (stat != ASN_OK) return stat; + break; + + /* addConnection */ + case 3: + stat = asn1PE_H245MultilinkResponse_addConnection (pctxt, pvalue->u.addConnection); + if (stat != ASN_OK) return stat; + break; + + /* removeConnection */ + case 4: + stat = asn1PE_H245MultilinkResponse_removeConnection (pctxt, pvalue->u.removeConnection); + if (stat != ASN_OK) return stat; + break; + + /* maximumHeaderInterval */ + case 5: + stat = asn1PE_H245MultilinkResponse_maximumHeaderInterval (pctxt, pvalue->u.maximumHeaderInterval); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateAcknowledge */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245LogicalChannelRateAcknowledge (OOCTXT* pctxt, H245LogicalChannelRateAcknowledge* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode logicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode maximumBitRate */ + + stat = asn1PE_H245MaximumBitRate (pctxt, pvalue->maximumBitRate); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateRejectReason */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245LogicalChannelRateRejectReason (OOCTXT* pctxt, H245LogicalChannelRateRejectReason* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* undefinedReason */ + case 1: + /* NULL */ + break; + + /* insufficientResources */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateReject */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245LogicalChannelRateReject (OOCTXT* pctxt, H245LogicalChannelRateReject* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.currentMaximumBitRatePresent); + + /* encode sequenceNumber */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->sequenceNumber); + if (stat != ASN_OK) return stat; + + /* encode logicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode rejectReason */ + + stat = asn1PE_H245LogicalChannelRateRejectReason (pctxt, &pvalue->rejectReason); + if (stat != ASN_OK) return stat; + + /* encode currentMaximumBitRate */ + + if (pvalue->m.currentMaximumBitRatePresent) { + stat = asn1PE_H245MaximumBitRate (pctxt, pvalue->currentMaximumBitRate); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* ResponseMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ResponseMessage (OOCTXT* pctxt, H245ResponseMessage* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 19); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 18); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* masterSlaveDeterminationAck */ + case 2: + stat = asn1PE_H245MasterSlaveDeterminationAck (pctxt, pvalue->u.masterSlaveDeterminationAck); + if (stat != ASN_OK) return stat; + break; + + /* masterSlaveDeterminationReject */ + case 3: + stat = asn1PE_H245MasterSlaveDeterminationReject (pctxt, pvalue->u.masterSlaveDeterminationReject); + if (stat != ASN_OK) return stat; + break; + + /* terminalCapabilitySetAck */ + case 4: + stat = asn1PE_H245TerminalCapabilitySetAck (pctxt, pvalue->u.terminalCapabilitySetAck); + if (stat != ASN_OK) return stat; + break; + + /* terminalCapabilitySetReject */ + case 5: + stat = asn1PE_H245TerminalCapabilitySetReject (pctxt, pvalue->u.terminalCapabilitySetReject); + if (stat != ASN_OK) return stat; + break; + + /* openLogicalChannelAck */ + case 6: + stat = asn1PE_H245OpenLogicalChannelAck (pctxt, pvalue->u.openLogicalChannelAck); + if (stat != ASN_OK) return stat; + break; + + /* openLogicalChannelReject */ + case 7: + stat = asn1PE_H245OpenLogicalChannelReject (pctxt, pvalue->u.openLogicalChannelReject); + if (stat != ASN_OK) return stat; + break; + + /* closeLogicalChannelAck */ + case 8: + stat = asn1PE_H245CloseLogicalChannelAck (pctxt, pvalue->u.closeLogicalChannelAck); + if (stat != ASN_OK) return stat; + break; + + /* requestChannelCloseAck */ + case 9: + stat = asn1PE_H245RequestChannelCloseAck (pctxt, pvalue->u.requestChannelCloseAck); + if (stat != ASN_OK) return stat; + break; + + /* requestChannelCloseReject */ + case 10: + stat = asn1PE_H245RequestChannelCloseReject (pctxt, pvalue->u.requestChannelCloseReject); + if (stat != ASN_OK) return stat; + break; + + /* multiplexEntrySendAck */ + case 11: + stat = asn1PE_H245MultiplexEntrySendAck (pctxt, pvalue->u.multiplexEntrySendAck); + if (stat != ASN_OK) return stat; + break; + + /* multiplexEntrySendReject */ + case 12: + stat = asn1PE_H245MultiplexEntrySendReject (pctxt, pvalue->u.multiplexEntrySendReject); + if (stat != ASN_OK) return stat; + break; + + /* requestMultiplexEntryAck */ + case 13: + stat = asn1PE_H245RequestMultiplexEntryAck (pctxt, pvalue->u.requestMultiplexEntryAck); + if (stat != ASN_OK) return stat; + break; + + /* requestMultiplexEntryReject */ + case 14: + stat = asn1PE_H245RequestMultiplexEntryReject (pctxt, pvalue->u.requestMultiplexEntryReject); + if (stat != ASN_OK) return stat; + break; + + /* requestModeAck */ + case 15: + stat = asn1PE_H245RequestModeAck (pctxt, pvalue->u.requestModeAck); + if (stat != ASN_OK) return stat; + break; + + /* requestModeReject */ + case 16: + stat = asn1PE_H245RequestModeReject (pctxt, pvalue->u.requestModeReject); + if (stat != ASN_OK) return stat; + break; + + /* roundTripDelayResponse */ + case 17: + stat = asn1PE_H245RoundTripDelayResponse (pctxt, pvalue->u.roundTripDelayResponse); + if (stat != ASN_OK) return stat; + break; + + /* maintenanceLoopAck */ + case 18: + stat = asn1PE_H245MaintenanceLoopAck (pctxt, pvalue->u.maintenanceLoopAck); + if (stat != ASN_OK) return stat; + break; + + /* maintenanceLoopReject */ + case 19: + stat = asn1PE_H245MaintenanceLoopReject (pctxt, pvalue->u.maintenanceLoopReject); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 20); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* communicationModeResponse */ + case 20: + stat = asn1PE_H245CommunicationModeResponse (&lctxt, pvalue->u.communicationModeResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* conferenceResponse */ + case 21: + stat = asn1PE_H245ConferenceResponse (&lctxt, pvalue->u.conferenceResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multilinkResponse */ + case 22: + stat = asn1PE_H245MultilinkResponse (&lctxt, pvalue->u.multilinkResponse); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* logicalChannelRateAcknowledge */ + case 23: + stat = asn1PE_H245LogicalChannelRateAcknowledge (&lctxt, pvalue->u.logicalChannelRateAcknowledge); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* logicalChannelRateReject */ + case 24: + stat = asn1PE_H245LogicalChannelRateReject (&lctxt, pvalue->u.logicalChannelRateReject); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MaintenanceLoopOffCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MaintenanceLoopOffCommand (OOCTXT* pctxt, H245MaintenanceLoopOffCommand* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + return (stat); +} + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest_capabilityTabl */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 65535, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245CapabilityTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest_capabilityDesc */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245CapabilityDescriptorNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet_specificRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245SendTerminalCapabilitySet_specificRequest (OOCTXT* pctxt, H245SendTerminalCapabilitySet_specificRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityTableEntryNumbersPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.capabilityDescriptorNumbersPresent); + + /* encode multiplexCapability */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->multiplexCapability); + if (stat != ASN_OK) return stat; + + /* encode capabilityTableEntryNumbers */ + + if (pvalue->m.capabilityTableEntryNumbersPresent) { + stat = asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityTableEntryNumbers (pctxt, &pvalue->capabilityTableEntryNumbers); + if (stat != ASN_OK) return stat; + } + + /* encode capabilityDescriptorNumbers */ + + if (pvalue->m.capabilityDescriptorNumbersPresent) { + stat = asn1PE_H245SendTerminalCapabilitySet_specificRequest_capabilityDescriptorNumbers (pctxt, &pvalue->capabilityDescriptorNumbers); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* SendTerminalCapabilitySet */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245SendTerminalCapabilitySet (OOCTXT* pctxt, H245SendTerminalCapabilitySet* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* specificRequest */ + case 1: + stat = asn1PE_H245SendTerminalCapabilitySet_specificRequest (pctxt, pvalue->u.specificRequest); + if (stat != ASN_OK) return stat; + break; + + /* genericRequest */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionCommand_encryptionAlgorithmID */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EncryptionCommand_encryptionAlgorithmID (OOCTXT* pctxt, H245EncryptionCommand_encryptionAlgorithmID* pvalue) +{ + int stat = ASN_OK; + + /* encode h233AlgorithmIdentifier */ + + stat = asn1PE_H245SequenceNumber (pctxt, pvalue->h233AlgorithmIdentifier); + if (stat != ASN_OK) return stat; + + /* encode associatedAlgorithm */ + + stat = asn1PE_H245NonStandardParameter (pctxt, &pvalue->associatedAlgorithm); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EncryptionCommand (OOCTXT* pctxt, H245EncryptionCommand* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* encryptionSE */ + case 1: + stat = encodeOctetString (pctxt, pvalue->u.encryptionSE->numocts, pvalue->u.encryptionSE->data); + if (stat != ASN_OK) return stat; + break; + + /* encryptionIVRequest */ + case 2: + /* NULL */ + break; + + /* encryptionAlgorithmID */ + case 3: + stat = asn1PE_H245EncryptionCommand_encryptionAlgorithmID (pctxt, pvalue->u.encryptionAlgorithmID); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlCommand_scope */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FlowControlCommand_scope (OOCTXT* pctxt, H245FlowControlCommand_scope* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* logicalChannelNumber */ + case 1: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelNumber); + if (stat != ASN_OK) return stat; + break; + + /* resourceID */ + case 2: + stat = encodeConsUnsigned (pctxt, pvalue->u.resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* wholeMultiplex */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlCommand_restriction */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FlowControlCommand_restriction (OOCTXT* pctxt, H245FlowControlCommand_restriction* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* maximumBitRate */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.maximumBitRate, 0U, 16777215U); + if (stat != ASN_OK) return stat; + + break; + + /* noRestriction */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FlowControlCommand (OOCTXT* pctxt, H245FlowControlCommand* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode scope */ + + stat = asn1PE_H245FlowControlCommand_scope (pctxt, &pvalue->scope); + if (stat != ASN_OK) return stat; + + /* encode restriction */ + + stat = asn1PE_H245FlowControlCommand_restriction (pctxt, &pvalue->restriction); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EndSessionCommand_gstnOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EndSessionCommand_gstnOptions (OOCTXT* pctxt, H245EndSessionCommand_gstnOptions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 5); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 4); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* telephonyMode */ + case 1: + /* NULL */ + break; + + /* v8bis */ + case 2: + /* NULL */ + break; + + /* v34DSVD */ + case 3: + /* NULL */ + break; + + /* v34DuplexFAX */ + case 4: + /* NULL */ + break; + + /* v34H324 */ + case 5: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 6); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EndSessionCommand_isdnOptions */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EndSessionCommand_isdnOptions (OOCTXT* pctxt, H245EndSessionCommand_isdnOptions* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* telephonyMode */ + case 1: + /* NULL */ + break; + + /* v140 */ + case 2: + /* NULL */ + break; + + /* terminalOnHold */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* EndSessionCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EndSessionCommand (OOCTXT* pctxt, H245EndSessionCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* disconnect */ + case 2: + /* NULL */ + break; + + /* gstnOptions */ + case 3: + stat = asn1PE_H245EndSessionCommand_gstnOptions (pctxt, pvalue->u.gstnOptions); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* isdnOptions */ + case 4: + stat = asn1PE_H245EndSessionCommand_isdnOptions (&lctxt, pvalue->u.isdnOptions); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoFastUpdateGOB */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousCommand_type_videoFastUpdateGOB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateGOB* pvalue) +{ + int stat = ASN_OK; + + /* encode firstGOB */ + + stat = encodeConsUnsigned (pctxt, pvalue->firstGOB, 0U, 17U); + if (stat != ASN_OK) return stat; + + /* encode numberOfGOBs */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfGOBs, 1U, 18U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoFastUpdateMB */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousCommand_type_videoFastUpdateMB (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoFastUpdateMB* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.firstGOBPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.firstMBPresent); + + /* encode firstGOB */ + + if (pvalue->m.firstGOBPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->firstGOB, 0U, 255U); + if (stat != ASN_OK) return stat; + + } + + /* encode firstMB */ + + if (pvalue->m.firstMBPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->firstMB, 1U, 8192U); + if (stat != ASN_OK) return stat; + + } + + /* encode numberOfMBs */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfMBs, 1U, 8192U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* KeyProtectionMethod */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245KeyProtectionMethod (OOCTXT* pctxt, H245KeyProtectionMethod* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode secureChannel */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->secureChannel); + if (stat != ASN_OK) return stat; + + /* encode sharedSecret */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->sharedSecret); + if (stat != ASN_OK) return stat; + + /* encode certProtectedKey */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->certProtectedKey); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* EncryptionUpdateRequest */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245EncryptionUpdateRequest (OOCTXT* pctxt, H245EncryptionUpdateRequest* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.keyProtectionMethodPresent); + + /* encode keyProtectionMethod */ + + if (pvalue->m.keyProtectionMethodPresent) { + stat = asn1PE_H245KeyProtectionMethod (pctxt, &pvalue->keyProtectionMethod); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_progressiveRefinementStart_rep */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* doOneProgression */ + case 1: + /* NULL */ + break; + + /* doContinuousProgressions */ + case 2: + /* NULL */ + break; + + /* doOneIndependentProgression */ + case 3: + /* NULL */ + break; + + /* doContinuousIndependentProgressions */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_progressiveRefinementStart */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart (OOCTXT* pctxt, H245MiscellaneousCommand_type_progressiveRefinementStart* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode repeatCount */ + + stat = asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart_repeatCount (pctxt, &pvalue->repeatCount); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_videoBadMBs */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousCommand_type_videoBadMBs (OOCTXT* pctxt, H245MiscellaneousCommand_type_videoBadMBs* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode firstMB */ + + stat = encodeConsUnsigned (pctxt, pvalue->firstMB, 1U, 9216U); + if (stat != ASN_OK) return stat; + + /* encode numberOfMBs */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfMBs, 1U, 9216U); + if (stat != ASN_OK) return stat; + + /* encode temporalReference */ + + stat = encodeConsUnsigned (pctxt, pvalue->temporalReference, 0U, 1023U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* PictureReference */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245PictureReference (OOCTXT* pctxt, H245PictureReference* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* pictureNumber */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.pictureNumber, 0U, 1023U); + if (stat != ASN_OK) return stat; + + break; + + /* longTermPictureIndex */ + case 2: + stat = encodeConsUnsigned (pctxt, pvalue->u.longTermPictureIndex, 0U, 255U); + if (stat != ASN_OK) return stat; + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* _SeqOfH245PictureReference */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245_SeqOfH245PictureReference (OOCTXT* pctxt, H245_SeqOfH245PictureReference* pvalue) +{ + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + ASN1UINT enclen, fraglen; + + enclen = fraglen = xx1 = 0; + pnode = pvalue->head; + for (;;) { + /* encode length determinant */ + + stat = encodeLength (pctxt, (pvalue->count - enclen)); + if (stat < 0) return stat; + + fraglen = stat; + enclen += fraglen; + /* encode elements */ + + for (; xx1 < enclen; xx1++) { + stat = asn1PE_H245PictureReference (pctxt, ((H245PictureReference*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + if ( pvalue->count == enclen && fraglen < 16384) { + break; + } + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type_lostPartialPicture */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousCommand_type_lostPartialPicture (OOCTXT* pctxt, H245MiscellaneousCommand_type_lostPartialPicture* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode pictureReference */ + + stat = asn1PE_H245PictureReference (pctxt, &pvalue->pictureReference); + if (stat != ASN_OK) return stat; + + /* encode firstMB */ + + stat = encodeConsUnsigned (pctxt, pvalue->firstMB, 1U, 9216U); + if (stat != ASN_OK) return stat; + + /* encode numberOfMBs */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfMBs, 1U, 9216U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousCommand_type (OOCTXT* pctxt, H245MiscellaneousCommand_type* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 10); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* equaliseDelay */ + case 1: + /* NULL */ + break; + + /* zeroDelay */ + case 2: + /* NULL */ + break; + + /* multipointModeCommand */ + case 3: + /* NULL */ + break; + + /* cancelMultipointModeCommand */ + case 4: + /* NULL */ + break; + + /* videoFreezePicture */ + case 5: + /* NULL */ + break; + + /* videoFastUpdatePicture */ + case 6: + /* NULL */ + break; + + /* videoFastUpdateGOB */ + case 7: + stat = asn1PE_H245MiscellaneousCommand_type_videoFastUpdateGOB (pctxt, pvalue->u.videoFastUpdateGOB); + if (stat != ASN_OK) return stat; + break; + + /* videoTemporalSpatialTradeOff */ + case 8: + stat = encodeConsUnsigned (pctxt, pvalue->u.videoTemporalSpatialTradeOff, 0U, 31U); + if (stat != ASN_OK) return stat; + + break; + + /* videoSendSyncEveryGOB */ + case 9: + /* NULL */ + break; + + /* videoSendSyncEveryGOBCancel */ + case 10: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* videoFastUpdateMB */ + case 11: + stat = asn1PE_H245MiscellaneousCommand_type_videoFastUpdateMB (&lctxt, pvalue->u.videoFastUpdateMB); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* maxH223MUXPDUsize */ + case 12: + stat = encodeConsUnsigned (&lctxt, pvalue->u.maxH223MUXPDUsize, 1U, 65535U); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* encryptionUpdate */ + case 13: + stat = asn1PE_H245EncryptionSync (&lctxt, pvalue->u.encryptionUpdate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* encryptionUpdateRequest */ + case 14: + stat = asn1PE_H245EncryptionUpdateRequest (&lctxt, pvalue->u.encryptionUpdateRequest); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* switchReceiveMediaOff */ + case 15: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* switchReceiveMediaOn */ + case 16: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* progressiveRefinementStart */ + case 17: + stat = asn1PE_H245MiscellaneousCommand_type_progressiveRefinementStart (&lctxt, pvalue->u.progressiveRefinementStart); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* progressiveRefinementAbortOne */ + case 18: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* progressiveRefinementAbortContinuous */ + case 19: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* videoBadMBs */ + case 20: + stat = asn1PE_H245MiscellaneousCommand_type_videoBadMBs (&lctxt, pvalue->u.videoBadMBs); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* lostPicture */ + case 21: + stat = asn1PE_H245_SeqOfH245PictureReference (&lctxt, pvalue->u.lostPicture); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* lostPartialPicture */ + case 22: + stat = asn1PE_H245MiscellaneousCommand_type_lostPartialPicture (&lctxt, pvalue->u.lostPartialPicture); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* recoveryReferencePicture */ + case 23: + stat = asn1PE_H245_SeqOfH245PictureReference (&lctxt, pvalue->u.recoveryReferencePicture); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousCommand (OOCTXT* pctxt, H245MiscellaneousCommand* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode logicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode type */ + + stat = asn1PE_H245MiscellaneousCommand_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeCommand_communicationModeTable */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CommunicationModeCommand_communicationModeTable (OOCTXT* pctxt, H245CommunicationModeCommand_communicationModeTable* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + DListNode* pnode; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->count); + if (stat < 0) return stat; + + /* encode elements */ + pnode = pvalue->head; + + for (xx1 = 0; xx1 < pvalue->count; xx1++) { + stat = asn1PE_H245CommunicationModeTableEntry (pctxt, ((H245CommunicationModeTableEntry*)pnode->data)); + if (stat != ASN_OK) return stat; + pnode = pnode->next; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommunicationModeCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CommunicationModeCommand (OOCTXT* pctxt, H245CommunicationModeCommand* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode communicationModeTable */ + + stat = asn1PE_H245CommunicationModeCommand_communicationModeTable (pctxt, &pvalue->communicationModeTable); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* SubstituteConferenceIDCommand_conferenceIdentifier */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245SubstituteConferenceIDCommand_conferenceIdentifier (OOCTXT* pctxt, H245SubstituteConferenceIDCommand_conferenceIdentifier* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 16, 16, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* SubstituteConferenceIDCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245SubstituteConferenceIDCommand (OOCTXT* pctxt, H245SubstituteConferenceIDCommand* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode conferenceIdentifier */ + + stat = asn1PE_H245SubstituteConferenceIDCommand_conferenceIdentifier (pctxt, &pvalue->conferenceIdentifier); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceCommand (OOCTXT* pctxt, H245ConferenceCommand* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 7); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* broadcastMyLogicalChannel */ + case 1: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.broadcastMyLogicalChannel); + if (stat != ASN_OK) return stat; + break; + + /* cancelBroadcastMyLogicalChannel */ + case 2: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.cancelBroadcastMyLogicalChannel); + if (stat != ASN_OK) return stat; + break; + + /* makeTerminalBroadcaster */ + case 3: + stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.makeTerminalBroadcaster); + if (stat != ASN_OK) return stat; + break; + + /* cancelMakeTerminalBroadcaster */ + case 4: + /* NULL */ + break; + + /* sendThisSource */ + case 5: + stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.sendThisSource); + if (stat != ASN_OK) return stat; + break; + + /* cancelSendThisSource */ + case 6: + /* NULL */ + break; + + /* dropConference */ + case 7: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* substituteConferenceIDCommand */ + case 8: + stat = asn1PE_H245SubstituteConferenceIDCommand (&lctxt, pvalue->u.substituteConferenceIDCommand); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration_h223ModeChange */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223MultiplexReconfiguration_h223ModeChange (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223ModeChange* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* toLevel0 */ + case 1: + /* NULL */ + break; + + /* toLevel1 */ + case 2: + /* NULL */ + break; + + /* toLevel2 */ + case 3: + /* NULL */ + break; + + /* toLevel2withOptionalHeader */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration_h223AnnexADoubleFlag */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (OOCTXT* pctxt, H245H223MultiplexReconfiguration_h223AnnexADoubleFlag* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* start */ + case 1: + /* NULL */ + break; + + /* stop */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223MultiplexReconfiguration */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223MultiplexReconfiguration (OOCTXT* pctxt, H245H223MultiplexReconfiguration* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* h223ModeChange */ + case 1: + stat = asn1PE_H245H223MultiplexReconfiguration_h223ModeChange (pctxt, pvalue->u.h223ModeChange); + if (stat != ASN_OK) return stat; + break; + + /* h223AnnexADoubleFlag */ + case 2: + stat = asn1PE_H245H223MultiplexReconfiguration_h223AnnexADoubleFlag (pctxt, pvalue->u.h223AnnexADoubleFlag); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1_clockRecovery */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_clockRecovery* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nullClockRecovery */ + case 1: + /* NULL */ + break; + + /* srtsClockRecovery */ + case 2: + /* NULL */ + break; + + /* adaptiveClockRecovery */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1_errorCorrection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1_errorCorrection* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nullErrorCorrection */ + case 1: + /* NULL */ + break; + + /* longInterleaver */ + case 2: + /* NULL */ + break; + + /* shortInterleaver */ + case 3: + /* NULL */ + break; + + /* errorCorrectionOnly */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal1 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand_aal_aal1 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal1* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode clockRecovery */ + + stat = asn1PE_H245NewATMVCCommand_aal_aal1_clockRecovery (pctxt, &pvalue->clockRecovery); + if (stat != ASN_OK) return stat; + + /* encode errorCorrection */ + + stat = asn1PE_H245NewATMVCCommand_aal_aal1_errorCorrection (pctxt, &pvalue->errorCorrection); + if (stat != ASN_OK) return stat; + + /* encode structuredDataTransfer */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->structuredDataTransfer); + if (stat != ASN_OK) return stat; + + /* encode partiallyFilledCells */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partiallyFilledCells); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal_aal5 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand_aal_aal5 (OOCTXT* pctxt, H245NewATMVCCommand_aal_aal5* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardMaximumSDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->forwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode backwardMaximumSDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->backwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_aal */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand_aal (OOCTXT* pctxt, H245NewATMVCCommand_aal* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* aal1 */ + case 1: + stat = asn1PE_H245NewATMVCCommand_aal_aal1 (pctxt, pvalue->u.aal1); + if (stat != ASN_OK) return stat; + break; + + /* aal5 */ + case 2: + stat = asn1PE_H245NewATMVCCommand_aal_aal5 (pctxt, pvalue->u.aal5); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_multiplex */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_multiplex* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noMultiplex */ + case 1: + /* NULL */ + break; + + /* transportStream */ + case 2: + /* NULL */ + break; + + /* programStream */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_reverseParameters_multiplex */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters_multiplex* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noMultiplex */ + case 1: + /* NULL */ + break; + + /* transportStream */ + case 2: + /* NULL */ + break; + + /* programStream */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand_reverseParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand_reverseParameters (OOCTXT* pctxt, H245NewATMVCCommand_reverseParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode bitRateLockedToPCRClock */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToPCRClock); + if (stat != ASN_OK) return stat; + + /* encode bitRateLockedToNetworkClock */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToNetworkClock); + if (stat != ASN_OK) return stat; + + /* encode multiplex */ + + stat = asn1PE_H245NewATMVCCommand_reverseParameters_multiplex (pctxt, &pvalue->multiplex); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCCommand (OOCTXT* pctxt, H245NewATMVCCommand* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode resourceID */ + + stat = encodeConsUnsigned (pctxt, pvalue->resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode bitRateLockedToPCRClock */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToPCRClock); + if (stat != ASN_OK) return stat; + + /* encode bitRateLockedToNetworkClock */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToNetworkClock); + if (stat != ASN_OK) return stat; + + /* encode aal */ + + stat = asn1PE_H245NewATMVCCommand_aal (pctxt, &pvalue->aal); + if (stat != ASN_OK) return stat; + + /* encode multiplex */ + + stat = asn1PE_H245NewATMVCCommand_multiplex (pctxt, &pvalue->multiplex); + if (stat != ASN_OK) return stat; + + /* encode reverseParameters */ + + stat = asn1PE_H245NewATMVCCommand_reverseParameters (pctxt, &pvalue->reverseParameters); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationCommand_status */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MobileMultilinkReconfigurationCommand_status (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand_status* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* synchronized_ */ + case 1: + /* NULL */ + break; + + /* reconfiguration */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationCommand */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MobileMultilinkReconfigurationCommand (OOCTXT* pctxt, H245MobileMultilinkReconfigurationCommand* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sampleSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->sampleSize, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode samplesPerFrame */ + + stat = encodeConsUnsigned (pctxt, pvalue->samplesPerFrame, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode status */ + + stat = asn1PE_H245MobileMultilinkReconfigurationCommand_status (pctxt, &pvalue->status); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* CommandMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245CommandMessage (OOCTXT* pctxt, H245CommandMessage* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 7); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 6); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* maintenanceLoopOffCommand */ + case 2: + stat = asn1PE_H245MaintenanceLoopOffCommand (pctxt, pvalue->u.maintenanceLoopOffCommand); + if (stat != ASN_OK) return stat; + break; + + /* sendTerminalCapabilitySet */ + case 3: + stat = asn1PE_H245SendTerminalCapabilitySet (pctxt, pvalue->u.sendTerminalCapabilitySet); + if (stat != ASN_OK) return stat; + break; + + /* encryptionCommand */ + case 4: + stat = asn1PE_H245EncryptionCommand (pctxt, pvalue->u.encryptionCommand); + if (stat != ASN_OK) return stat; + break; + + /* flowControlCommand */ + case 5: + stat = asn1PE_H245FlowControlCommand (pctxt, pvalue->u.flowControlCommand); + if (stat != ASN_OK) return stat; + break; + + /* endSessionCommand */ + case 6: + stat = asn1PE_H245EndSessionCommand (pctxt, pvalue->u.endSessionCommand); + if (stat != ASN_OK) return stat; + break; + + /* miscellaneousCommand */ + case 7: + stat = asn1PE_H245MiscellaneousCommand (pctxt, pvalue->u.miscellaneousCommand); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 8); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* communicationModeCommand */ + case 8: + stat = asn1PE_H245CommunicationModeCommand (&lctxt, pvalue->u.communicationModeCommand); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* conferenceCommand */ + case 9: + stat = asn1PE_H245ConferenceCommand (&lctxt, pvalue->u.conferenceCommand); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* h223MultiplexReconfiguration */ + case 10: + stat = asn1PE_H245H223MultiplexReconfiguration (&lctxt, pvalue->u.h223MultiplexReconfiguration); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* newATMVCCommand */ + case 11: + stat = asn1PE_H245NewATMVCCommand (&lctxt, pvalue->u.newATMVCCommand); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* mobileMultilinkReconfigurationCommand */ + case 12: + stat = asn1PE_H245MobileMultilinkReconfigurationCommand (&lctxt, pvalue->u.mobileMultilinkReconfigurationCommand); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FunctionNotUnderstood */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FunctionNotUnderstood (OOCTXT* pctxt, H245FunctionNotUnderstood* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* request */ + case 1: + stat = asn1PE_H245RequestMessage (pctxt, pvalue->u.request); + if (stat != ASN_OK) return stat; + break; + + /* response */ + case 2: + stat = asn1PE_H245ResponseMessage (pctxt, pvalue->u.response); + if (stat != ASN_OK) return stat; + break; + + /* command */ + case 3: + stat = asn1PE_H245CommandMessage (pctxt, pvalue->u.command); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MasterSlaveDeterminationRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MasterSlaveDeterminationRelease (OOCTXT* pctxt, H245MasterSlaveDeterminationRelease* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalCapabilitySetRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalCapabilitySetRelease (OOCTXT* pctxt, H245TerminalCapabilitySetRelease* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + return (stat); +} + +/**************************************************************/ +/* */ +/* OpenLogicalChannelConfirm */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245OpenLogicalChannelConfirm (OOCTXT* pctxt, H245OpenLogicalChannelConfirm* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestChannelCloseRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestChannelCloseRelease (OOCTXT* pctxt, H245RequestChannelCloseRelease* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardLogicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->forwardLogicalChannelNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendRelease_multiplexTableEntryNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (OOCTXT* pctxt, H245MultiplexEntrySendRelease_multiplexTableEntryNumber* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultiplexEntrySendRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultiplexEntrySendRelease (OOCTXT* pctxt, H245MultiplexEntrySendRelease* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode multiplexTableEntryNumber */ + + stat = asn1PE_H245MultiplexEntrySendRelease_multiplexTableEntryNumber (pctxt, &pvalue->multiplexTableEntryNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRelease_entryNumbers */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryRelease_entryNumbers (OOCTXT* pctxt, H245RequestMultiplexEntryRelease_entryNumbers* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 15, 0 }; + int stat = ASN_OK; + ASN1UINT xx1; + + /* encode length determinant */ + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeLength (pctxt, pvalue->n); + if (stat < 0) return stat; + + /* encode elements */ + + for (xx1 = 0; xx1 < pvalue->n; xx1++) { + stat = asn1PE_H245MultiplexTableEntryNumber (pctxt, pvalue->elem[xx1]); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestMultiplexEntryRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestMultiplexEntryRelease (OOCTXT* pctxt, H245RequestMultiplexEntryRelease* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode entryNumbers */ + + stat = asn1PE_H245RequestMultiplexEntryRelease_entryNumbers (pctxt, &pvalue->entryNumbers); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* RequestModeRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245RequestModeRelease (OOCTXT* pctxt, H245RequestModeRelease* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousIndication_type_videoNotDecodedMBs */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousIndication_type_videoNotDecodedMBs (OOCTXT* pctxt, H245MiscellaneousIndication_type_videoNotDecodedMBs* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode firstMB */ + + stat = encodeConsUnsigned (pctxt, pvalue->firstMB, 1U, 8192U); + if (stat != ASN_OK) return stat; + + /* encode numberOfMBs */ + + stat = encodeConsUnsigned (pctxt, pvalue->numberOfMBs, 1U, 8192U); + if (stat != ASN_OK) return stat; + + /* encode temporalReference */ + + stat = encodeConsUnsigned (pctxt, pvalue->temporalReference, 0U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousIndication_type */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousIndication_type (OOCTXT* pctxt, H245MiscellaneousIndication_type* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 10); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* logicalChannelActive */ + case 1: + /* NULL */ + break; + + /* logicalChannelInactive */ + case 2: + /* NULL */ + break; + + /* multipointConference */ + case 3: + /* NULL */ + break; + + /* cancelMultipointConference */ + case 4: + /* NULL */ + break; + + /* multipointZeroComm */ + case 5: + /* NULL */ + break; + + /* cancelMultipointZeroComm */ + case 6: + /* NULL */ + break; + + /* multipointSecondaryStatus */ + case 7: + /* NULL */ + break; + + /* cancelMultipointSecondaryStatus */ + case 8: + /* NULL */ + break; + + /* videoIndicateReadyToActivate */ + case 9: + /* NULL */ + break; + + /* videoTemporalSpatialTradeOff */ + case 10: + stat = encodeConsUnsigned (pctxt, pvalue->u.videoTemporalSpatialTradeOff, 0U, 31U); + if (stat != ASN_OK) return stat; + + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* videoNotDecodedMBs */ + case 11: + stat = asn1PE_H245MiscellaneousIndication_type_videoNotDecodedMBs (&lctxt, pvalue->u.videoNotDecodedMBs); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* transportCapability */ + case 12: + stat = asn1PE_H245TransportCapability (&lctxt, pvalue->u.transportCapability); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MiscellaneousIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MiscellaneousIndication (OOCTXT* pctxt, H245MiscellaneousIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode logicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + /* encode type */ + + stat = asn1PE_H245MiscellaneousIndication_type (pctxt, &pvalue->type); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* JitterIndication_scope */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245JitterIndication_scope (OOCTXT* pctxt, H245JitterIndication_scope* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* logicalChannelNumber */ + case 1: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelNumber); + if (stat != ASN_OK) return stat; + break; + + /* resourceID */ + case 2: + stat = encodeConsUnsigned (pctxt, pvalue->u.resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* wholeMultiplex */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* JitterIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245JitterIndication (OOCTXT* pctxt, H245JitterIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.skippedFrameCountPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.additionalDecoderBufferPresent); + + /* encode scope */ + + stat = asn1PE_H245JitterIndication_scope (pctxt, &pvalue->scope); + if (stat != ASN_OK) return stat; + + /* encode estimatedReceivedJitterMantissa */ + + stat = encodeConsUnsigned (pctxt, pvalue->estimatedReceivedJitterMantissa, 0U, 3U); + if (stat != ASN_OK) return stat; + + /* encode estimatedReceivedJitterExponent */ + + stat = encodeConsUnsigned (pctxt, pvalue->estimatedReceivedJitterExponent, 0U, 7U); + if (stat != ASN_OK) return stat; + + /* encode skippedFrameCount */ + + if (pvalue->m.skippedFrameCountPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->skippedFrameCount, 0U, 15U); + if (stat != ASN_OK) return stat; + + } + + /* encode additionalDecoderBuffer */ + + if (pvalue->m.additionalDecoderBufferPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->additionalDecoderBuffer, 0U, 262143U); + if (stat != ASN_OK) return stat; + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H223SkewIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H223SkewIndication (OOCTXT* pctxt, H245H223SkewIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode logicalChannelNumber1 */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber1); + if (stat != ASN_OK) return stat; + + /* encode logicalChannelNumber2 */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber2); + if (stat != ASN_OK) return stat; + + /* encode skew */ + + stat = encodeConsUnsigned (pctxt, pvalue->skew, 0U, 4095U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1_clockRecovery */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1_clockRecovery (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_clockRecovery* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nullClockRecovery */ + case 1: + /* NULL */ + break; + + /* srtsClockRecovery */ + case 2: + /* NULL */ + break; + + /* adaptiveClockRecovery */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1_errorCorrection */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1_errorCorrection (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1_errorCorrection* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nullErrorCorrection */ + case 1: + /* NULL */ + break; + + /* longInterleaver */ + case 2: + /* NULL */ + break; + + /* shortInterleaver */ + case 3: + /* NULL */ + break; + + /* errorCorrectionOnly */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal1 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication_aal_aal1 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal1* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode clockRecovery */ + + stat = asn1PE_H245NewATMVCIndication_aal_aal1_clockRecovery (pctxt, &pvalue->clockRecovery); + if (stat != ASN_OK) return stat; + + /* encode errorCorrection */ + + stat = asn1PE_H245NewATMVCIndication_aal_aal1_errorCorrection (pctxt, &pvalue->errorCorrection); + if (stat != ASN_OK) return stat; + + /* encode structuredDataTransfer */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->structuredDataTransfer); + if (stat != ASN_OK) return stat; + + /* encode partiallyFilledCells */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->partiallyFilledCells); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal_aal5 */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication_aal_aal5 (OOCTXT* pctxt, H245NewATMVCIndication_aal_aal5* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode forwardMaximumSDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->forwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode backwardMaximumSDUSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->backwardMaximumSDUSize, 0U, 65535U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_aal */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication_aal (OOCTXT* pctxt, H245NewATMVCIndication_aal* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* aal1 */ + case 1: + stat = asn1PE_H245NewATMVCIndication_aal_aal1 (pctxt, pvalue->u.aal1); + if (stat != ASN_OK) return stat; + break; + + /* aal5 */ + case 2: + stat = asn1PE_H245NewATMVCIndication_aal_aal5 (pctxt, pvalue->u.aal5); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_multiplex */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_multiplex* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noMultiplex */ + case 1: + /* NULL */ + break; + + /* transportStream */ + case 2: + /* NULL */ + break; + + /* programStream */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_reverseParameters_multiplex */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication_reverseParameters_multiplex (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters_multiplex* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* noMultiplex */ + case 1: + /* NULL */ + break; + + /* transportStream */ + case 2: + /* NULL */ + break; + + /* programStream */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication_reverseParameters */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication_reverseParameters (OOCTXT* pctxt, H245NewATMVCIndication_reverseParameters* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode bitRateLockedToPCRClock */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToPCRClock); + if (stat != ASN_OK) return stat; + + /* encode bitRateLockedToNetworkClock */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToNetworkClock); + if (stat != ASN_OK) return stat; + + /* encode multiplex */ + + stat = asn1PE_H245NewATMVCIndication_reverseParameters_multiplex (pctxt, &pvalue->multiplex); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* NewATMVCIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245NewATMVCIndication (OOCTXT* pctxt, H245NewATMVCIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.reverseParametersPresent); + + encodeBit (pctxt, extbit); + + /* encode resourceID */ + + stat = encodeConsUnsigned (pctxt, pvalue->resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode bitRate */ + + stat = encodeConsUnsigned (pctxt, pvalue->bitRate, 1U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode bitRateLockedToPCRClock */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToPCRClock); + if (stat != ASN_OK) return stat; + + /* encode bitRateLockedToNetworkClock */ + + stat = encodeBit (pctxt, (ASN1BOOL)pvalue->bitRateLockedToNetworkClock); + if (stat != ASN_OK) return stat; + + /* encode aal */ + + stat = asn1PE_H245NewATMVCIndication_aal (pctxt, &pvalue->aal); + if (stat != ASN_OK) return stat; + + /* encode multiplex */ + + stat = asn1PE_H245NewATMVCIndication_multiplex (pctxt, &pvalue->multiplex); + if (stat != ASN_OK) return stat; + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.reverseParametersPresent); + /* encode extension elements */ + + if (pvalue->m.reverseParametersPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = asn1PE_H245NewATMVCIndication_reverseParameters (&lctxt, &pvalue->reverseParameters); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_userInputSupportIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UserInputIndication_userInputSupportIndication (OOCTXT* pctxt, H245UserInputIndication_userInputSupportIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* basicString */ + case 2: + /* NULL */ + break; + + /* iA5String */ + case 3: + /* NULL */ + break; + + /* generalString */ + case 4: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_signal_rtp */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UserInputIndication_signal_rtp (OOCTXT* pctxt, H245UserInputIndication_signal_rtp* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.timestampPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.expirationTimePresent); + + /* encode timestamp */ + + if (pvalue->m.timestampPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->timestamp, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + /* encode expirationTime */ + + if (pvalue->m.expirationTimePresent) { + stat = encodeConsUnsigned (pctxt, pvalue->expirationTime, 0U, ASN1UINT_MAX); + if (stat != ASN_OK) return stat; + + } + + /* encode logicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_signal */ +/* */ +/**************************************************************/ + +extern EXTERN const char* gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet; + +EXTERN int asn1PE_H245UserInputIndication_signal (OOCTXT* pctxt, H245UserInputIndication_signal* pvalue) +{ + static Asn1SizeCnst signalType_lsize1 = { 0, 1, 1, 0 }; + int stat = ASN_OK; + ASN1BOOL extbit; + ASN1OpenType openType; + OOCTXT lctxt; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->m.rtpPayloadIndicationPresent); + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.durationPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpPresent); + + /* encode signalType */ + + addSizeConstraint (pctxt, &signalType_lsize1); + + stat = encodeConstrainedStringEx (pctxt, pvalue->signalType, gs_MULTIMEDIA_SYSTEM_CONTROL_UserInputIndication_signal_signalType_CharSet, 8, 5, 7); + if (stat != ASN_OK) return stat; + + /* encode duration */ + + if (pvalue->m.durationPresent) { + stat = encodeConsUnsigned (pctxt, pvalue->duration, 1U, 65535U); + if (stat != ASN_OK) return stat; + + } + + /* encode rtp */ + + if (pvalue->m.rtpPresent) { + stat = asn1PE_H245UserInputIndication_signal_rtp (pctxt, &pvalue->rtp); + if (stat != ASN_OK) return stat; + } + + if (extbit) { + + /* encode extension optional bits length */ + + stat = encodeSmallNonNegWholeNumber (pctxt, 0); + if (stat != ASN_OK) return stat; + + /* encode optional bits */ + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpPayloadIndicationPresent); + /* encode extension elements */ + + if (pvalue->m.rtpPayloadIndicationPresent) { + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + /* NULL */ + + stat = encodeByteAlign (&lctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_signalUpdate_rtp */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UserInputIndication_signalUpdate_rtp (OOCTXT* pctxt, H245UserInputIndication_signalUpdate_rtp* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode logicalChannelNumber */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_signalUpdate */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UserInputIndication_signalUpdate (OOCTXT* pctxt, H245UserInputIndication_signalUpdate* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpPresent); + + /* encode duration */ + + stat = encodeConsUnsigned (pctxt, pvalue->duration, 1U, 65535U); + if (stat != ASN_OK) return stat; + + /* encode rtp */ + + if (pvalue->m.rtpPresent) { + stat = asn1PE_H245UserInputIndication_signalUpdate_rtp (pctxt, &pvalue->rtp); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication_extendedAlphanumeric */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UserInputIndication_extendedAlphanumeric (OOCTXT* pctxt, H245UserInputIndication_extendedAlphanumeric* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.rtpPayloadIndicationPresent); + + /* encode alphanumeric */ + + stat = encodeVarWidthCharString (pctxt, pvalue->alphanumeric); + if (stat != ASN_OK) return stat; + + /* encode rtpPayloadIndication */ + + if (pvalue->m.rtpPayloadIndicationPresent) { + /* NULL */ + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* UserInputIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245UserInputIndication (OOCTXT* pctxt, H245UserInputIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 2); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardParameter (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* alphanumeric */ + case 2: + stat = encodeVarWidthCharString (pctxt, pvalue->u.alphanumeric); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 3); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* userInputSupportIndication */ + case 3: + stat = asn1PE_H245UserInputIndication_userInputSupportIndication (&lctxt, pvalue->u.userInputSupportIndication); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* signal */ + case 4: + stat = asn1PE_H245UserInputIndication_signal (&lctxt, pvalue->u.signal); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* signalUpdate */ + case 5: + stat = asn1PE_H245UserInputIndication_signalUpdate (&lctxt, pvalue->u.signalUpdate); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* extendedAlphanumeric */ + case 6: + stat = asn1PE_H245UserInputIndication_extendedAlphanumeric (&lctxt, pvalue->u.extendedAlphanumeric); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* H2250MaximumSkewIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245H2250MaximumSkewIndication (OOCTXT* pctxt, H245H2250MaximumSkewIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode logicalChannelNumber1 */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber1); + if (stat != ASN_OK) return stat; + + /* encode logicalChannelNumber2 */ + + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->logicalChannelNumber2); + if (stat != ASN_OK) return stat; + + /* encode maximumSkew */ + + stat = encodeConsUnsigned (pctxt, pvalue->maximumSkew, 0U, 4095U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MCLocationIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MCLocationIndication (OOCTXT* pctxt, H245MCLocationIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode signalAddress */ + + stat = asn1PE_H245TransportAddress (pctxt, &pvalue->signalAddress); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* TerminalYouAreSeeingInSubPictureNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245TerminalYouAreSeeingInSubPictureNumber (OOCTXT* pctxt, H245TerminalYouAreSeeingInSubPictureNumber* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode terminalNumber */ + + stat = asn1PE_H245TerminalNumber (pctxt, pvalue->terminalNumber); + if (stat != ASN_OK) return stat; + + /* encode subPictureNumber */ + + stat = encodeConsUnsigned (pctxt, pvalue->subPictureNumber, 0U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VideoIndicateCompose */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VideoIndicateCompose (OOCTXT* pctxt, H245VideoIndicateCompose* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode compositionNumber */ + + stat = encodeConsUnsigned (pctxt, pvalue->compositionNumber, 0U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* ConferenceIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245ConferenceIndication (OOCTXT* pctxt, H245ConferenceIndication* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 10); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 9); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* sbeNumber */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.sbeNumber, 0U, 9U); + if (stat != ASN_OK) return stat; + + break; + + /* terminalNumberAssign */ + case 2: + stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.terminalNumberAssign); + if (stat != ASN_OK) return stat; + break; + + /* terminalJoinedConference */ + case 3: + stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.terminalJoinedConference); + if (stat != ASN_OK) return stat; + break; + + /* terminalLeftConference */ + case 4: + stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.terminalLeftConference); + if (stat != ASN_OK) return stat; + break; + + /* seenByAtLeastOneOther */ + case 5: + /* NULL */ + break; + + /* cancelSeenByAtLeastOneOther */ + case 6: + /* NULL */ + break; + + /* seenByAll */ + case 7: + /* NULL */ + break; + + /* cancelSeenByAll */ + case 8: + /* NULL */ + break; + + /* terminalYouAreSeeing */ + case 9: + stat = asn1PE_H245TerminalLabel (pctxt, pvalue->u.terminalYouAreSeeing); + if (stat != ASN_OK) return stat; + break; + + /* requestForFloor */ + case 10: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 11); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* withdrawChairToken */ + case 11: + /* NULL */ + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* floorRequested */ + case 12: + stat = asn1PE_H245TerminalLabel (&lctxt, pvalue->u.floorRequested); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* terminalYouAreSeeingInSubPictureNumber */ + case 13: + stat = asn1PE_H245TerminalYouAreSeeingInSubPictureNumber (&lctxt, pvalue->u.terminalYouAreSeeingInSubPictureNumber); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* videoIndicateCompose */ + case 14: + stat = asn1PE_H245VideoIndicateCompose (&lctxt, pvalue->u.videoIndicateCompose); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* VendorIdentification_productNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VendorIdentification_productNumber (OOCTXT* pctxt, H245VendorIdentification_productNumber* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VendorIdentification_versionNumber */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VendorIdentification_versionNumber (OOCTXT* pctxt, H245VendorIdentification_versionNumber* pvalue) +{ + static Asn1SizeCnst lsize1 = { 0, 1, 256, 0 }; + int stat = ASN_OK; + + addSizeConstraint (pctxt, &lsize1); + + stat = encodeOctetString (pctxt, pvalue->numocts, pvalue->data); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* VendorIdentification */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245VendorIdentification (OOCTXT* pctxt, H245VendorIdentification* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.productNumberPresent); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.versionNumberPresent); + + /* encode vendor */ + + stat = asn1PE_H245NonStandardIdentifier (pctxt, &pvalue->vendor); + if (stat != ASN_OK) return stat; + + /* encode productNumber */ + + if (pvalue->m.productNumberPresent) { + stat = asn1PE_H245VendorIdentification_productNumber (pctxt, &pvalue->productNumber); + if (stat != ASN_OK) return stat; + } + + /* encode versionNumber */ + + if (pvalue->m.versionNumberPresent) { + stat = asn1PE_H245VendorIdentification_versionNumber (pctxt, &pvalue->versionNumber); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FunctionNotSupported_cause */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FunctionNotSupported_cause (OOCTXT* pctxt, H245FunctionNotSupported_cause* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* syntaxError */ + case 1: + /* NULL */ + break; + + /* semanticError */ + case 2: + /* NULL */ + break; + + /* unknownFunction */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FunctionNotSupported */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FunctionNotSupported (OOCTXT* pctxt, H245FunctionNotSupported* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + encodeBit (pctxt, (ASN1BOOL)pvalue->m.returnedFunctionPresent); + + /* encode cause */ + + stat = asn1PE_H245FunctionNotSupported_cause (pctxt, &pvalue->cause); + if (stat != ASN_OK) return stat; + + /* encode returnedFunction */ + + if (pvalue->m.returnedFunctionPresent) { + stat = encodeOctetString (pctxt, pvalue->returnedFunction.numocts, pvalue->returnedFunction.data); + if (stat != ASN_OK) return stat; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkIndication_crcDesired */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkIndication_crcDesired (OOCTXT* pctxt, H245MultilinkIndication_crcDesired* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkIndication_excessiveError */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkIndication_excessiveError (OOCTXT* pctxt, H245MultilinkIndication_excessiveError* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode connectionIdentifier */ + + stat = asn1PE_H245ConnectionIdentifier (pctxt, &pvalue->connectionIdentifier); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultilinkIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultilinkIndication (OOCTXT* pctxt, H245MultilinkIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 3); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* crcDesired */ + case 2: + stat = asn1PE_H245MultilinkIndication_crcDesired (pctxt, pvalue->u.crcDesired); + if (stat != ASN_OK) return stat; + break; + + /* excessiveError */ + case 3: + stat = asn1PE_H245MultilinkIndication_excessiveError (pctxt, pvalue->u.excessiveError); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 4); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* LogicalChannelRateRelease */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245LogicalChannelRateRelease (OOCTXT* pctxt, H245LogicalChannelRateRelease* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlIndication_scope */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FlowControlIndication_scope (OOCTXT* pctxt, H245FlowControlIndication_scope* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 2); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* logicalChannelNumber */ + case 1: + stat = asn1PE_H245LogicalChannelNumber (pctxt, pvalue->u.logicalChannelNumber); + if (stat != ASN_OK) return stat; + break; + + /* resourceID */ + case 2: + stat = encodeConsUnsigned (pctxt, pvalue->u.resourceID, 0U, 65535U); + if (stat != ASN_OK) return stat; + + break; + + /* wholeMultiplex */ + case 3: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlIndication_restriction */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FlowControlIndication_restriction (OOCTXT* pctxt, H245FlowControlIndication_restriction* pvalue) +{ + int stat = ASN_OK; + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 1); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* maximumBitRate */ + case 1: + stat = encodeConsUnsigned (pctxt, pvalue->u.maximumBitRate, 0U, 16777215U); + if (stat != ASN_OK) return stat; + + break; + + /* noRestriction */ + case 2: + /* NULL */ + break; + + default: + return ASN_E_INVOPT; + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* FlowControlIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245FlowControlIndication (OOCTXT* pctxt, H245FlowControlIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode scope */ + + stat = asn1PE_H245FlowControlIndication_scope (pctxt, &pvalue->scope); + if (stat != ASN_OK) return stat; + + /* encode restriction */ + + stat = asn1PE_H245FlowControlIndication_restriction (pctxt, &pvalue->restriction); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* MobileMultilinkReconfigurationIndication */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MobileMultilinkReconfigurationIndication (OOCTXT* pctxt, H245MobileMultilinkReconfigurationIndication* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = 0; + + encodeBit (pctxt, extbit); + + /* encode sampleSize */ + + stat = encodeConsUnsigned (pctxt, pvalue->sampleSize, 1U, 255U); + if (stat != ASN_OK) return stat; + + /* encode samplesPerFrame */ + + stat = encodeConsUnsigned (pctxt, pvalue->samplesPerFrame, 1U, 255U); + if (stat != ASN_OK) return stat; + + return (stat); +} + +/**************************************************************/ +/* */ +/* IndicationMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245IndicationMessage (OOCTXT* pctxt, H245IndicationMessage* pvalue) +{ + int stat = ASN_OK; + OOCTXT lctxt; + ASN1OpenType openType; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 14); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 13); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* nonStandard */ + case 1: + stat = asn1PE_H245NonStandardMessage (pctxt, pvalue->u.nonStandard); + if (stat != ASN_OK) return stat; + break; + + /* functionNotUnderstood */ + case 2: + stat = asn1PE_H245FunctionNotUnderstood (pctxt, pvalue->u.functionNotUnderstood); + if (stat != ASN_OK) return stat; + break; + + /* masterSlaveDeterminationRelease */ + case 3: + stat = asn1PE_H245MasterSlaveDeterminationRelease (pctxt, pvalue->u.masterSlaveDeterminationRelease); + if (stat != ASN_OK) return stat; + break; + + /* terminalCapabilitySetRelease */ + case 4: + stat = asn1PE_H245TerminalCapabilitySetRelease (pctxt, pvalue->u.terminalCapabilitySetRelease); + if (stat != ASN_OK) return stat; + break; + + /* openLogicalChannelConfirm */ + case 5: + stat = asn1PE_H245OpenLogicalChannelConfirm (pctxt, pvalue->u.openLogicalChannelConfirm); + if (stat != ASN_OK) return stat; + break; + + /* requestChannelCloseRelease */ + case 6: + stat = asn1PE_H245RequestChannelCloseRelease (pctxt, pvalue->u.requestChannelCloseRelease); + if (stat != ASN_OK) return stat; + break; + + /* multiplexEntrySendRelease */ + case 7: + stat = asn1PE_H245MultiplexEntrySendRelease (pctxt, pvalue->u.multiplexEntrySendRelease); + if (stat != ASN_OK) return stat; + break; + + /* requestMultiplexEntryRelease */ + case 8: + stat = asn1PE_H245RequestMultiplexEntryRelease (pctxt, pvalue->u.requestMultiplexEntryRelease); + if (stat != ASN_OK) return stat; + break; + + /* requestModeRelease */ + case 9: + stat = asn1PE_H245RequestModeRelease (pctxt, pvalue->u.requestModeRelease); + if (stat != ASN_OK) return stat; + break; + + /* miscellaneousIndication */ + case 10: + stat = asn1PE_H245MiscellaneousIndication (pctxt, pvalue->u.miscellaneousIndication); + if (stat != ASN_OK) return stat; + break; + + /* jitterIndication */ + case 11: + stat = asn1PE_H245JitterIndication (pctxt, pvalue->u.jitterIndication); + if (stat != ASN_OK) return stat; + break; + + /* h223SkewIndication */ + case 12: + stat = asn1PE_H245H223SkewIndication (pctxt, pvalue->u.h223SkewIndication); + if (stat != ASN_OK) return stat; + break; + + /* newATMVCIndication */ + case 13: + stat = asn1PE_H245NewATMVCIndication (pctxt, pvalue->u.newATMVCIndication); + if (stat != ASN_OK) return stat; + break; + + /* userInput */ + case 14: + stat = asn1PE_H245UserInputIndication (pctxt, pvalue->u.userInput); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 15); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + initContext (&lctxt); + stat = setPERBuffer (&lctxt, 0, 0, TRUE); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + switch (pvalue->t) + { + /* h2250MaximumSkewIndication */ + case 15: + stat = asn1PE_H245H2250MaximumSkewIndication (&lctxt, pvalue->u.h2250MaximumSkewIndication); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* mcLocationIndication */ + case 16: + stat = asn1PE_H245MCLocationIndication (&lctxt, pvalue->u.mcLocationIndication); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* conferenceIndication */ + case 17: + stat = asn1PE_H245ConferenceIndication (&lctxt, pvalue->u.conferenceIndication); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* vendorIdentification */ + case 18: + stat = asn1PE_H245VendorIdentification (&lctxt, pvalue->u.vendorIdentification); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* functionNotSupported */ + case 19: + stat = asn1PE_H245FunctionNotSupported (&lctxt, pvalue->u.functionNotSupported); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* multilinkIndication */ + case 20: + stat = asn1PE_H245MultilinkIndication (&lctxt, pvalue->u.multilinkIndication); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* logicalChannelRateRelease */ + case 21: + stat = asn1PE_H245LogicalChannelRateRelease (&lctxt, pvalue->u.logicalChannelRateRelease); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* flowControlIndication */ + case 22: + stat = asn1PE_H245FlowControlIndication (&lctxt, pvalue->u.flowControlIndication); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + /* mobileMultilinkReconfigurationIndication */ + case 23: + stat = asn1PE_H245MobileMultilinkReconfigurationIndication (&lctxt, pvalue->u.mobileMultilinkReconfigurationIndication); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + openType.data = encodeGetMsgPtr (&lctxt, (int*)&openType.numocts); + break; + + default: + ; + } + + stat = encodeByteAlign (pctxt); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + stat = encodeOpenType (pctxt, openType.numocts, openType.data); + if (stat != ASN_OK) return freeContext (&lctxt), stat; + + freeContext (&lctxt); + } + + return (stat); +} + +/**************************************************************/ +/* */ +/* MultimediaSystemControlMessage */ +/* */ +/**************************************************************/ + +EXTERN int asn1PE_H245MultimediaSystemControlMessage (OOCTXT* pctxt, H245MultimediaSystemControlMessage* pvalue) +{ + int stat = ASN_OK; + ASN1BOOL extbit; + + /* extension bit */ + + extbit = (ASN1BOOL)(pvalue->t > 4); + + encodeBit (pctxt, extbit); + + if (!extbit) { + + /* Encode choice index value */ + + stat = encodeConsUnsigned (pctxt, pvalue->t - 1, 0, 3); + if (stat != ASN_OK) return stat; + + /* Encode root element data value */ + + switch (pvalue->t) + { + /* request */ + case 1: + stat = asn1PE_H245RequestMessage (pctxt, pvalue->u.request); + if (stat != ASN_OK) return stat; + break; + + /* response */ + case 2: + stat = asn1PE_H245ResponseMessage (pctxt, pvalue->u.response); + if (stat != ASN_OK) return stat; + break; + + /* command */ + case 3: + stat = asn1PE_H245CommandMessage (pctxt, pvalue->u.command); + if (stat != ASN_OK) return stat; + break; + + /* indication */ + case 4: + stat = asn1PE_H245IndicationMessage (pctxt, pvalue->u.indication); + if (stat != ASN_OK) return stat; + break; + + default: + return ASN_E_INVOPT; + } + } + else { + /* Encode extension choice index value */ + + stat = encodeSmallNonNegWholeNumber (pctxt, pvalue->t - 5); + if (stat != ASN_OK) return stat; + + /* Encode extension element data value */ + + } + + return (stat); +} + diff --git a/addons/ooh323c/src/memheap.c b/addons/ooh323c/src/memheap.c new file mode 100644 index 000000000..48040a7ef --- /dev/null +++ b/addons/ooh323c/src/memheap.c @@ -0,0 +1,1331 @@ +/* + * Copyright (C) 1997-2004 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 LICENSE.txt 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 +#include "memheap.h" + +ASN1UINT g_defBlkSize = XM_K_MEMBLKSIZ; +OSMallocFunc g_malloc_func = malloc; +#ifndef _NO_REALLOC +OSReallocFunc g_realloc_func = realloc; +#else +OSReallocFunc g_realloc_func = 0; +#endif +OSFreeFunc g_free_func = free; + +static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, + void* pMemBlk, int blockType); + +typedef void OSMemElemDescr; + + +#define pElem_flags(pElem) (*((ASN1OCTET*)pElem)) +#define pElem_nunits(pElem) (*((ASN1USINT*)(((ASN1OCTET*)pElem)+2))) +#define pElem_prevOff(pElem) (*((ASN1USINT*)(((ASN1OCTET*)pElem)+4))) +#define pElem_nextFreeOff(pElem) (*((ASN1USINT*)(((ASN1OCTET*)pElem)+6))) +#define pElem_beginOff(pElem) (*((ASN1USINT*)(((ASN1OCTET*)pElem)+6))) +#define sizeof_OSMemElemDescr 8 +#define pElem_data(pElem) (((ASN1OCTET*)pElem)+sizeof_OSMemElemDescr) + +typedef struct MemBlk { + OSMemLink* plink; + ASN1USINT free_x; /* index of free space at end of block */ + ASN1USINT freeMem; /* size of free space before free_x */ + ASN1USINT nunits; /* size of data */ + ASN1USINT lastElemOff; /* last element offset in block */ + ASN1USINT freeElemOff; /* first free element offset in block */ + ASN1USINT nsaved; /* num of saved elems in the block */ + + ASN1USINT spare[2]; /* forces alignment on 8-bytes boundary, + for 64-bit systems */ + char data[8]; +} OSMemBlk; + +/* Macros for operations with memory blocks */ + +#define QOFFSETOF(pElem, pPrevElem) \ +((ASN1USINT)(((unsigned)((char*)pElem - (char*)pPrevElem)) >> 3u)) + +#define OFFSETOF(pElem, pPrevElem) \ +((ASN1UINT)((char*)pElem - (char*)pPrevElem)) + +#define ISFREE(pElem) (pElem_flags(pElem) & 1) +#define SET_FREE(pElem) (pElem_flags(pElem) |= 1) +#define CLEAR_FREE(pElem) (pElem_flags(pElem) &= (~1)) + +#define ISLAST(pElem) (pElem_flags(pElem) & 2) +#define SET_LAST(pElem) (pElem_flags(pElem) |= 2) +#define CLEAR_LAST(pElem) (pElem_flags(pElem) &= (~2)) + +#define ISSAVED(pElem) (pElem_flags(pElem) & 4) +#define SET_SAVED(pMemBlk,pElem) do { \ +(pElem_flags (pElem) |= 4); pMemBlk->nsaved++; } while (0) +#define CLEAR_SAVED(pMemBlk,pElem) do { \ +(pElem_flags (pElem) &= (~4)); pMemBlk->nsaved--; } while (0) + +#define ISFIRST(pElem) (int)(pElem_prevOff (pElem) == 0) + +#define GETPREV(pElem) \ +((pElem_prevOff (pElem) == 0) ? 0 : \ +((OSMemElemDescr*) (((char*)pElem) - (pElem_prevOff (pElem) * 8u)))) + +#define GETNEXT(pElem) \ +((ISLAST (pElem)) ? 0 : \ +((OSMemElemDescr*)(((char*)pElem) + ((pElem_nunits (pElem) + 1) * 8u)))) + +#define GET_NEXT_FREE(pElem) \ +((pElem_nextFreeOff (pElem) == 0) ? 0 : \ +((OSMemElemDescr*) (((char*)pElem) + (pElem_nextFreeOff (pElem) * 8u)))) + +#define GET_MEMBLK(pElem) \ +((OSMemBlk*) (((char*)pElem) - (pElem_beginOff (pElem) * 8u) - \ +sizeof (OSMemBlk) + sizeof ((OSMemBlk*)0)->data)) + +#define GET_LAST_ELEM(pMemBlk) \ +((pMemBlk->lastElemOff == 0) ? 0 : \ +(OSMemElemDescr*)&pMemBlk->data[(pMemBlk->lastElemOff - 1) * 8u]) + +#define SET_LAST_ELEM(pMemBlk, pElem) \ +pMemBlk->lastElemOff = (ASN1USINT)((pElem == 0) ? 0 : \ +(SET_LAST (pElem), (QOFFSETOF (pElem, pMemBlk->data) + 1))) + +#define GET_FREE_ELEM(pMemBlk) \ +((pMemBlk->freeElemOff == 0) ? 0 : \ +(OSMemElemDescr*)&pMemBlk->data[(pMemBlk->freeElemOff - 1) * 8u]) + +#define FORCE_SET_FREE_ELEM(pMemBlk, pElem) do { \ +if (pElem == 0) { pMemBlk->freeElemOff = 0; break; } \ +SET_FREE (pElem); \ +pMemBlk->freeElemOff = (ASN1USINT)(QOFFSETOF (pElem, pMemBlk->data) + 1); \ +} while (0) + +#define SET_FREE_ELEM(pMemBlk, pElem) setLastElem (pMemBlk, pElem) + +/* Memory debugging macros */ +#define RTMEMDIAG1(msg) +#define RTMEMDIAG2(msg,a) +#define RTMEMDIAG3(msg,a,b) +#define RTMEMDIAG4(msg,a,b,c) +#define FILLFREEMEM(mem,size) +#define FILLNEWMEM(mem,size) + +#define CHECKMEMELEM(memblk,elem) +#define CHECKMEMBLOCK(memheap,memblk) +#define CHECKMEMHEAP(memheap) +#define TRACEMEMELEM(memblk, elem, name) +#define TRACEFREE(memlink,name) + + +static void setLastElem (OSMemBlk* pMemBlk, OSMemElemDescr* pElem) +{ + if (pElem == 0) { + pMemBlk->freeElemOff = 0; + return; + } + else if (ISLAST (pElem)) + return; + else if (pMemBlk->freeElemOff > QOFFSETOF (pElem, pMemBlk->data) + 1) { + pElem_nextFreeOff (pElem) = QOFFSETOF (GET_FREE_ELEM (pMemBlk), pElem); + FORCE_SET_FREE_ELEM (pMemBlk, pElem); + } + else if (pMemBlk->freeElemOff == 0) { + pElem_nextFreeOff (pElem) = 0; + FORCE_SET_FREE_ELEM (pMemBlk, pElem); + } + else { + SET_FREE (pElem); + pElem_nextFreeOff (pElem) = 0; + } +} + +void* memHeapAlloc (void** ppvMemHeap, int nbytes) +{ + OSMemHeap* pMemHeap; + OSMemLink* pMemLink, **ppMemLink; + OSMemBlk* pMemBlk = 0; + void* mem_p = NULL; + unsigned remUnits; + ASN1UINT nunits; + + if (ppvMemHeap == 0) + return 0; + + if (*ppvMemHeap == 0) + if (memHeapCreate (ppvMemHeap) != ASN_OK) + return 0; + + /* Round number of bytes to nearest 8-byte boundary */ + + nunits = (((unsigned)(nbytes + 7)) >> 3); + + pMemHeap = (OSMemHeap*) *ppvMemHeap; + ppMemLink = &pMemHeap->phead; + + /* if size is greater than 2**19, then allocate as RAW block */ + + if (nunits > (1<<16) - 2) { + void *data; + + /* allocate raw block */ + + data = g_malloc_func (nbytes); + if (data == NULL) { + return NULL; + } + pMemLink = memHeapAddBlock (ppMemLink, data, RTMEMMALLOC | RTMEMRAW); + if (pMemLink == 0) { + g_free_func (data); + return NULL; + } + /* save size of the RAW memory block behind the pMemLink */ + *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes; + return data; + } + + RTMEMDIAG2 ("memHeapAlloc: adjusted nbytes = %d\n", nbytes); + + /* Try to allocate a slot from an existing block on the list */ + + for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnext) { + if (pMemLink->blockType & RTMEMRAW) continue; + else pMemBlk = (OSMemBlk*) pMemLink->pMemBlk; + + remUnits = pMemBlk->nunits - pMemBlk->free_x; + + if ((unsigned)(nunits + 1) <= remUnits) { + OSMemElemDescr* pElem = (OSMemElemDescr*) + &pMemBlk->data [((ASN1UINT)pMemBlk->free_x) * 8u]; + OSMemElemDescr* pPrevElem; + + RTMEMDIAG1 ("memHeapAlloc: found existing slot..\n"); + + /* if block is clean, set some vars in heap */ + if (pMemBlk->free_x == 0) { + pMemHeap->freeUnits -= pMemBlk->nunits; + pMemHeap->freeBlocks--; + } + + pElem_flags (pElem) = 0; + if (pMemBlk->lastElemOff != 0) + pElem_prevOff (pElem) = + (ASN1USINT)(pMemBlk->free_x - pMemBlk->lastElemOff + 1); + else + pElem_prevOff (pElem) = 0; + + pPrevElem = GET_LAST_ELEM (pMemBlk); + if (pPrevElem != 0) + CLEAR_LAST (pPrevElem); + + pElem_nunits (pElem) = (ASN1USINT)nunits; + pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data); + pMemBlk->lastElemOff = (ASN1USINT)(pMemBlk->free_x + 1); + + mem_p = (void*) (pElem_data (pElem)); + + /* sizeof (OSMemElemDescr) == 1 unit */ + pMemBlk->free_x += nunits + 1; + + SET_LAST_ELEM (pMemBlk, pElem); + + FILLNEWMEM (mem_p, nunits * 8u); + TRACEMEMELEM(pMemBlk, pElem, "Allocated"); + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK (pMemHeap, pMemBlk); + break; + } + } + + /* If not successful, look for empty elements in existing blocks */ + + if (0 == mem_p) { + for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnext) { + if (pMemLink->blockType & RTMEMRAW) continue; + + pMemBlk = (OSMemBlk*) pMemLink->pMemBlk; + + if (nunits <= (ASN1UINT)pMemBlk->freeMem) { + OSMemElemDescr* pElem = GET_FREE_ELEM(pMemBlk), *pPrevFree = 0; + + RTMEMDIAG2 + ("memHeapAlloc: try to reuse empty elems in pMemBlk = 0x%x...\n", + pMemBlk); + + while (pElem != 0) { + if (ISFREE (pElem)) { + if (nunits <= (ASN1UINT)pElem_nunits (pElem)) { + RTMEMDIAG3 + ("memHeapAlloc: " + "found an exisiting free element 0x%x, size %d\n", + pElem, (pElem_nunits (pElem) * 8u)); + + if (pMemBlk->freeElemOff == + QOFFSETOF (pElem, pMemBlk->data) + 1) + { + + /* modify the pMemBlk->freeElemOff value if necsry */ + + OSMemElemDescr* nextFree = GET_NEXT_FREE (pElem); + FORCE_SET_FREE_ELEM (pMemBlk, nextFree); + } + else if (pPrevFree != 0) { + OSMemElemDescr* pNextFree = GET_NEXT_FREE (pElem); + if (pNextFree != 0) + pElem_nextFreeOff (pPrevFree) = QOFFSETOF (pNextFree, + pPrevFree); + else + pElem_nextFreeOff (pPrevFree) = 0; + } + + CLEAR_FREE (pElem); + + /* set beginOff value */ + + pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data); + + pMemBlk->freeMem -= pElem_nunits (pElem); + + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK (pMemHeap, pMemBlk); + + mem_p = memHeapRealloc + (ppvMemHeap, pElem_data (pElem), nunits * 8u); + if (mem_p != 0) { + FILLNEWMEM (mem_p, nunits * 8u); + TRACEMEMELEM(pMemBlk, pElem, "Allocated"); + } + break; + } + } + pPrevFree = pElem; + pElem = GET_NEXT_FREE (pElem); + } + if (mem_p != 0) break; + } + } + } + + /* If not successful, malloc a new block and alloc from it */ + + if (!mem_p) { + ASN1UINT allocSize, dataUnits; + ASN1OCTET* pmem; + register ASN1UINT defBlkSize = pMemHeap->defBlkSize; + + RTMEMDIAG1 ("memHeapAlloc: alloc block..\n"); + + allocSize = (ASN1UINT) ((((ASN1UINT)nunits) * 8u) + + sizeof (OSMemBlk) + sizeof_OSMemElemDescr); + allocSize = (ASN1UINT) (allocSize < defBlkSize) ? defBlkSize : + ((allocSize + defBlkSize - 1) / defBlkSize * defBlkSize); + dataUnits = (ASN1UINT)((allocSize - sizeof (OSMemBlk)) >> 3u); + if (dataUnits >= (1u<<16)) { + dataUnits = (ASN1UINT)((1u<<16) - 1); + allocSize = (ASN1UINT) + ((((ASN1UINT)dataUnits) * 8u) + sizeof (OSMemBlk)); + } + + pmem = (ASN1OCTET*) g_malloc_func (allocSize + sizeof (OSMemLink)); + if (0 != pmem) { + OSMemElemDescr* pElem; + + pMemBlk = (OSMemBlk*) (pmem + sizeof (OSMemLink)); + pElem = (OSMemElemDescr*)&pMemBlk->data[0]; + + mem_p = (void*) pElem_data (pElem); + pElem_nunits (pElem) = (ASN1USINT)nunits; + pElem_flags (pElem) = 0; + pElem_prevOff (pElem) = 0; + pElem_beginOff (pElem) = QOFFSETOF (pElem, pMemBlk->data); + + /* sizeof (OSMemElemDescr) == 1 unit */ + pMemBlk->free_x = (ASN1USINT)(nunits + 1); + + pMemBlk->freeMem = 0; + pMemBlk->nunits = (ASN1USINT)dataUnits; + SET_LAST_ELEM (pMemBlk, pElem); + pMemBlk->freeElemOff = 0; + pMemBlk->nsaved = 0; + + if (memHeapAddBlock (ppMemLink, pMemBlk, RTMEMSTD | RTMEMLINK) == 0) + { + g_free_func (pmem); + return NULL; + } + + /* set vars in heap */ + pMemHeap->usedUnits += dataUnits; + pMemHeap->usedBlocks++; + + FILLNEWMEM (mem_p, nunits * 8u); + TRACEMEMELEM(pMemBlk, pElem, "Allocated"); + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK (pMemHeap, pMemBlk); + } + else + return NULL; + } + RTMEMDIAG2 ("memHeapAlloc: pMemBlk = 0x%x\n", pMemBlk); + RTMEMDIAG2 ("memHeapAlloc: pMemBlk->free_x = %d\n", pMemBlk->free_x); + RTMEMDIAG2 ("memHeapAlloc: pMemBlk->size = %d\n", + pMemBlk->nunits * 8u); + RTMEMDIAG2 ("memHeapAlloc: mem_p = 0x%x\n", mem_p); + RTMEMDIAG2 ("memHeapAlloc: sizeof (short) = %d\n", sizeof(short)); + + return (mem_p); +} + +void* memHeapAllocZ (void** ppvMemHeap, int nbytes) +{ + void* ptr = memHeapAlloc (ppvMemHeap, nbytes); + if (0 != ptr) memset (ptr, 0, nbytes); + return ptr; +} + +void memHeapFreePtr (void** ppvMemHeap, void* mem_p) +{ + OSMemHeap* pMemHeap; + OSMemLink** ppMemLink; + OSMemElemDescr* pElem; + OSMemBlk* pMemBlk; + OSMemLink* pMemLink, *pPrevMemLink = 0; + + RTMEMDIAG2 ("memHeapFreePtr: freeing mem_p = 0x%x\n", mem_p); + + if (mem_p == 0 || ppvMemHeap == 0 || *ppvMemHeap == 0) return; + + pMemHeap = *(OSMemHeap**)ppvMemHeap; + ppMemLink = &pMemHeap->phead; + + /* look for chain of RAW blocks first */ + + for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnextRaw) { + if ((pMemLink->blockType & RTMEMRAW) && + pMemLink->pMemBlk == mem_p) + { + if(pMemLink->pnext != 0) { + pMemLink->pnext->pprev = pMemLink->pprev; + } + if(pMemLink->pprev != 0) { + pMemLink->pprev->pnext = pMemLink->pnext; + } + else { /* head */ + *ppMemLink = pMemLink->pnext; + } + if (pPrevMemLink != 0) + pPrevMemLink->pnextRaw = pMemLink->pnextRaw; + else if (*ppMemLink != 0 && (*ppMemLink)->pnextRaw == 0 && + *ppMemLink != pMemLink->pnextRaw) + { + (*ppMemLink)->pnextRaw = pMemLink->pnextRaw; + } + if ((pMemLink->blockType & RTMEMLINK) && + (pMemLink->blockType & RTMEMMALLOC)) + { + g_free_func (pMemLink); + } + else { + if (pMemLink->blockType & RTMEMMALLOC) + g_free_func (pMemLink->pMemBlk); + g_free_func (pMemLink); + } + return; + } + pPrevMemLink = pMemLink; + } + + pElem = (OSMemElemDescr*) (((char*)mem_p) - sizeof_OSMemElemDescr); + pMemBlk = GET_MEMBLK (pElem); + + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK(pMemHeap, pMemBlk); + + if (ISFREE (pElem)) { /* already freed! */ + RTMEMDIAG2 ("memHeapFreePtr: " + "the element 0x%x is already freed!\n", pElem); + return; + } + + if (ISSAVED (pElem)) { + CLEAR_SAVED (pMemBlk, pElem); + if (pMemBlk->nsaved == 0) + pMemBlk->plink->blockType &= (~RTMEMSAVED); + } + + TRACEMEMELEM(pMemBlk, pElem, "Freed"); + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK(pMemHeap, pMemBlk); + + RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x\n", pMemBlk); + RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->size = %d\n", + pMemBlk->nunits * 8u); + + if (ISLAST (pElem)) { /* is it the last? */ + OSMemElemDescr* pPrevElem = GETPREV (pElem); + + CHECKMEMELEM (pMemBlk, pPrevElem); + + pMemBlk->free_x -= (pElem_nunits (pElem) + 1); + + FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u], + (pElem_nunits (pElem) + 1) * 8u); + + if (pPrevElem != 0 && ISFREE (pPrevElem)) { + OSMemElemDescr* pFreeElem; + + pMemBlk->free_x -= (pElem_nunits (pPrevElem) + 1); + pMemBlk->freeMem -= pElem_nunits (pPrevElem); + SET_LAST_ELEM (pMemBlk, GETPREV (pPrevElem)); + + /* wasn't it the last elem in block? */ + if (pMemBlk->lastElemOff != 0) { + + /* correct nextFreeOff for previous free element */ + + pFreeElem = GET_FREE_ELEM (pMemBlk); + if (pFreeElem == pPrevElem) { + pMemBlk->freeElemOff = 0; /* it was the last free elem */ + } + else { + OSMemElemDescr* pNextFree = 0; + + while (pFreeElem < pPrevElem) { + pNextFree = pFreeElem; + pFreeElem = GET_NEXT_FREE (pFreeElem); + } + pElem_nextFreeOff (pNextFree) = 0; + } + } + } + else { + SET_LAST_ELEM (pMemBlk, pPrevElem); + } + + RTMEMDIAG2 ("memHeapFreePtr: pMemBlk->free_x = %d\n", + pMemBlk->free_x); + + /* The question is: do we really want to get rid of the */ + /* block or should we keep it around for reuse? */ + if (pMemBlk->lastElemOff == 0) { /* was it the last elem in block? */ + + if ((pMemHeap->flags & RT_MH_DONTKEEPFREE) || + (pMemHeap->keepFreeUnits > 0 && + pMemHeap->freeUnits + pMemBlk->nunits > pMemHeap->keepFreeUnits)) + { + ASN1OCTET blockType = pMemBlk->plink->blockType; + + /* we may free the block */ + + pMemHeap->usedUnits -= pMemBlk->nunits; + pMemHeap->usedBlocks --; + + if(pMemBlk->plink->pnext != 0) { + pMemBlk->plink->pnext->pprev = pMemBlk->plink->pprev; + } + if(pMemBlk->plink->pprev != 0) { + pMemBlk->plink->pprev->pnext = pMemBlk->plink->pnext; + } + else { /* head */ + if (pMemBlk->plink->pnext != 0 && + !(pMemBlk->plink->pnext->blockType & RTMEMRAW)) + { + pMemBlk->plink->pnext->pnextRaw = (*ppMemLink)->pnextRaw; + } + *ppMemLink = pMemBlk->plink->pnext; + } + FILLFREEMEM (pMemBlk->plink, sizeof (*pMemBlk->plink)); + FILLFREEMEM (pMemBlk->data, (pMemBlk->nunits * 8u)); + + g_free_func (pMemBlk->plink); + + if (!(blockType & RTMEMLINK)) { + FILLFREEMEM (pMemBlk, sizeof (*pMemBlk)); + g_free_func (pMemBlk); + } + RTMEMDIAG2 ("memHeapFreePtr: pMemBlk = 0x%x was freed\n", + pMemBlk); + } + else { + /* reset pMemBlk for re-usage */ + pMemBlk->free_x = 0; + pMemBlk->freeElemOff = 0; + pMemBlk->lastElemOff = 0; + pMemBlk->freeMem = 0; + pMemBlk->nsaved = 0; + pMemHeap->freeUnits += pMemBlk->nunits; + pMemHeap->freeBlocks ++; + } + } + else { + SET_LAST (GET_LAST_ELEM (pMemBlk)); + FILLFREEMEM (((char*) &pMemBlk->data[0]) + (pMemBlk->free_x * 8u), + (pMemBlk->nunits - pMemBlk->free_x) * 8u); + CHECKMEMBLOCK (pMemHeap, pMemBlk); + } + } + else { /* mark as free elem inside the block */ + CHECKMEMBLOCK (pMemHeap, pMemBlk); + + SET_FREE_ELEM(pMemBlk, pElem); + + pMemBlk->freeMem += pElem_nunits (pElem); + RTMEMDIAG2 ("memHeapFreePtr: element 0x%x marked as free.\n", + pElem); + + /* try to unite free blocks, if possible */ + if (!ISFIRST (pElem)) { + if (ISFREE (GETPREV (pElem))) { + OSMemElemDescr* prevelem_p = GETPREV (pElem); + + /* +1 because the OSMemElemDescr has size ONE unit (8 bytes) */ + pElem_nunits (prevelem_p) += pElem_nunits (pElem) + 1; + + pElem = prevelem_p; + pMemBlk->freeMem ++; /* sizeof (OSMemElemDescr) == 1 unit */ + } + else { + /* look for nearest previous free block to correct nextFreeOff */ + + OSMemElemDescr* prevelem_p = pElem; + + do { + prevelem_p = GETPREV (prevelem_p); + } + while (prevelem_p && !ISFREE (prevelem_p)); + + if (prevelem_p != 0) { + OSMemElemDescr* pNextFree = GET_NEXT_FREE (prevelem_p); + if (pNextFree != 0) + pElem_nextFreeOff (pElem) = QOFFSETOF (pNextFree, pElem); + else + pElem_nextFreeOff (pElem) = 0; + pElem_nextFreeOff (prevelem_p) = QOFFSETOF (pElem, prevelem_p); + + CHECKMEMELEM (pMemBlk, prevelem_p); + } + } + } + if (!ISLAST (pElem) && ISFREE (GETNEXT (pElem))) { + OSMemElemDescr* nextelem_p = GETNEXT (pElem); + + /* +1 because the OSMemElemDescr has size ONE unit (8 bytes) */ + pElem_nunits (pElem) += pElem_nunits (nextelem_p) + 1; + + if (pElem_nextFreeOff (nextelem_p) == 0) + pElem_nextFreeOff (pElem) = 0; + else + pElem_nextFreeOff (pElem) = + QOFFSETOF (GET_NEXT_FREE (nextelem_p), pElem); + pMemBlk->freeMem ++; + } + + /* correct the prevOff field of next element */ + if (!ISLAST (pElem)) { + OSMemElemDescr* nextelem_p = GETNEXT (pElem); + pElem_prevOff (nextelem_p) = QOFFSETOF (nextelem_p, pElem); + } + + CHECKMEMELEM (pMemBlk, pElem); + FILLFREEMEM (pElem_data (pElem), (pElem_nunits (pElem) * 8u)); + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK (pMemHeap, pMemBlk); + } +} + +static void initNewFreeElement (OSMemBlk* pMemBlk, + OSMemElemDescr* pNewElem, OSMemElemDescr* pElem) +{ + OSMemElemDescr *pNextElem, *pPrevElem = 0; + + /* create new free element on the freed place */ + + pElem_flags (pNewElem) = 0; + SET_FREE (pNewElem); + + pElem_prevOff (pNewElem) = QOFFSETOF (pNewElem, pElem); + + if (pMemBlk->freeElemOff != 0 && + pMemBlk->freeElemOff < QOFFSETOF (pElem, pMemBlk->data) + 1) + { + /* look for nearest previous free block to correct its nextFreeOff */ + + pPrevElem = pElem; + + do { + pPrevElem = GETPREV (pPrevElem); + } + while (pPrevElem && !ISFREE (pPrevElem)); + } + if (pPrevElem != 0) { /* if it is not first free element... */ + + /* correct nextFreeOff for prev free element */ + + pElem_nextFreeOff (pPrevElem) = QOFFSETOF (pNewElem, pPrevElem); + } + else { /* if it is first free element in the block */ + FORCE_SET_FREE_ELEM (pMemBlk, pNewElem); + } + + pNextElem = GETNEXT (pNewElem); + if (ISFREE (pNextElem)) { + + /* if the next elem is free, then unite them together */ + + pElem_nunits (pNewElem) += pElem_nunits (pNextElem) + 1; + if (pElem_nextFreeOff (pNextElem) != 0) + pElem_nextFreeOff (pNewElem) = QOFFSETOF (GET_NEXT_FREE (pNextElem), + pNewElem); + else + pElem_nextFreeOff (pNewElem) = 0; + pMemBlk->freeMem++; /* +1 because space for MemElemDescr is freed now */ + pNextElem = GETNEXT (pNewElem); + } + pElem_prevOff (pNextElem) = QOFFSETOF (pNextElem, pNewElem); + + if (pMemBlk->freeElemOff != 0) { + + /* look for the next nearest free elem */ + + pNextElem = GETNEXT (pNewElem); + while (pNextElem != 0 && !ISFREE (pNextElem)) + pNextElem = GETNEXT (pNextElem); + + /* set nextFreeOff for new element */ + + if (pNextElem != 0) + pElem_nextFreeOff (pNewElem) = QOFFSETOF (pNextElem, pNewElem); + else + pElem_nextFreeOff (pNewElem) = 0; + } + else + pElem_nextFreeOff (pNewElem) = 0; + +} + +void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_) +{ + OSMemHeap* pMemHeap; + OSMemLink** ppMemLink; + OSMemBlk* pMemBlk; + OSMemElemDescr* pElem; + OSMemLink* pMemLink, *pPrevMemLink = 0; + void *newMem_p; + unsigned nbytes, nunits; + + /* if mem_p == NULL - do rtMemAlloc */ + + if (ppvMemHeap == 0 || *ppvMemHeap == 0) return 0; + + if (mem_p == 0) { + return memHeapAlloc (ppvMemHeap, nbytes_); + } + + pMemHeap = *(OSMemHeap**)ppvMemHeap; + ppMemLink = &pMemHeap->phead; + + /* look for chain of RAW blocks first */ + + for (pMemLink = *ppMemLink; pMemLink != 0; pMemLink = pMemLink->pnextRaw) { + if ((pMemLink->blockType & RTMEMRAW) && + pMemLink->pMemBlk == mem_p) + { + if (pMemLink->blockType & RTMEMMALLOC) + if (g_realloc_func != 0) { + void *newMemBlk = g_realloc_func (pMemLink->pMemBlk, nbytes_); + if (newMemBlk == 0) + return 0; + pMemLink->pMemBlk = newMemBlk; + } + else { + /* use malloc/memcpy/free sequence instead of realloc */ + ASN1OCTET* newBuf; + int oldSize = *(int*)(((char*)pMemLink) + sizeof (OSMemLink)); + + if (oldSize == -1) return 0; + newBuf = (ASN1OCTET*)g_malloc_func (nbytes_); + if (newBuf == 0) + return 0; + memcpy (newBuf, pMemLink->pMemBlk, ASN1MIN (oldSize, nbytes_)); + free (pMemLink->pMemBlk); + pMemLink->pMemBlk = newBuf; + } + else + return 0; + *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = nbytes_; + return pMemLink->pMemBlk; + } + pPrevMemLink = pMemLink; + } + + /* Round number of bytes to nearest 8-byte boundary */ + + nbytes = ((unsigned)(nbytes_ + 7)) & (~7); + nunits = nbytes >> 3; + + pElem = (OSMemElemDescr*) (((char*)mem_p) - sizeof_OSMemElemDescr); + + RTMEMDIAG3 ("memHeapRealloc: mem_p = 0x%x, old size = %d,", mem_p, + pElem_nunits (pElem) * 8u); + RTMEMDIAG2 (" new nbytes = %d\n", nbytes); + + if ((unsigned)pElem_nunits (pElem) == nunits) + return mem_p; + + pMemBlk = GET_MEMBLK (pElem); + + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK(pMemHeap, pMemBlk); + + if ((unsigned)pElem_nunits (pElem) < nunits) { /* expanding */ + + if (nunits - pElem_nunits (pElem) <= (unsigned)pMemBlk->nunits) { + + /* Try to expand the existing element in the existing block */ + + if (ISLAST (pElem)) { /* if the last element in the block */ + + /* if the free space in the block is enough */ + + if ((int)(nunits - pElem_nunits (pElem)) <= + (int)(pMemBlk->nunits - pMemBlk->free_x)) + { + pMemBlk->free_x += nunits - pElem_nunits (pElem); + pElem_nunits (pElem) = (ASN1USINT)nunits; + + RTMEMDIAG1 ("memHeapRealloc: " + "memory element is expanded.\n"); + + FILLNEWMEM (&pMemBlk->data [(pMemBlk->free_x - + (nunits - pElem_nunits (pElem))) * 8u], + (nunits - pElem_nunits (pElem)) * 8u); + + TRACEMEMELEM (pMemBlk, pElem, "Reallocated"); + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK (pMemHeap, pMemBlk); + + return (mem_p); + } + } + else { + OSMemElemDescr* pNextElem, *pFreeElem; + unsigned sumSize = pElem_nunits (pElem), freeMem = 0; + + RTMEMDIAG1 ("memHeapRealloc: look for free element after " + "current block.\n"); + + /* look for free element after pElem */ + + pNextElem = GETNEXT (pElem); + if (ISFREE (pNextElem)) { + /* +1 'cos sizeof (OSMemElemDescr) == 1 unit */ + sumSize += pElem_nunits (pNextElem) + 1; + freeMem++; + } + + if (sumSize >= nunits) { + + RTMEMDIAG1 ("memHeapRealloc: reuse free element.\n"); + + if (ISFREE (pNextElem)) { + pFreeElem = GET_FREE_ELEM (pMemBlk); + if (pFreeElem == pNextElem) { + FORCE_SET_FREE_ELEM (pMemBlk, GET_NEXT_FREE (pNextElem)); + } + else if (pFreeElem < pElem) { + + /* look for previous free elem to correct nextFreeOff */ + + for (; pFreeElem != 0 && pFreeElem < pNextElem;) { + OSMemElemDescr* pNextFreeElem = + GET_NEXT_FREE (pFreeElem); + if (pNextFreeElem == pNextElem) { + if (pElem_nextFreeOff (pNextElem) != 0) + pElem_nextFreeOff (pFreeElem) = QOFFSETOF + (GET_NEXT_FREE (pNextElem), pFreeElem); + else + pElem_nextFreeOff (pFreeElem) = 0; + CHECKMEMELEM (pMemBlk, pFreeElem); + break; + } + pFreeElem = pNextFreeElem; + } + } + } + + /* reuse empty elements after the pElem */ + + pMemBlk->freeMem += freeMem; + + if (sumSize - nunits > 1) { + OSMemElemDescr* pNewElem; + + /* if sumSize is too large, then create new empty element */ + + pNewElem = (OSMemElemDescr*) + (pElem_data (pElem) + nbytes); + pElem_nunits (pNewElem) = (ASN1USINT)(sumSize - nunits - 1); + + initNewFreeElement (pMemBlk, pNewElem, pElem); + + pMemBlk->freeMem--; /* sizeof (OSMemElemDescr) == 1 unit */ + pMemBlk->freeMem -= (nunits - pElem_nunits (pElem)); + pElem_nunits (pElem) = (ASN1USINT)nunits; + } + else { + pMemBlk->freeMem -= (sumSize - pElem_nunits (pElem)); + pElem_nunits (pElem) = (ASN1USINT)sumSize; + + /* modify the prevOff of the next elem */ + + pNextElem = GETNEXT (pElem); + if (pNextElem != 0) + pElem_prevOff (pNextElem) = QOFFSETOF (pNextElem, pElem); + } + + TRACEMEMELEM (pMemBlk, pElem, "Reallocated"); + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMELEM (pMemBlk, (!ISLAST (pElem)) ? GETNEXT (pElem) : 0); + CHECKMEMBLOCK (pMemHeap, pMemBlk); + return (mem_p); + } + } + } + + /* If not successful, allocate a new element and move the data into it */ + + RTMEMDIAG1 ("memHeapRealloc: allocate new memory...\n"); + + CHECKMEMHEAP (pMemHeap); + + newMem_p = memHeapAlloc (ppvMemHeap, nbytes); + + if (newMem_p == 0) + return 0; + + /* if the old memory block is marked as saved then mark the new block + as saved as well. */ + + if (ISSAVED (pElem)) + memHeapMarkSaved (ppvMemHeap, newMem_p, TRUE); + + CHECKMEMHEAP (pMemHeap); + + memcpy (newMem_p, mem_p, (((ASN1UINT)pElem_nunits (pElem)) * 8u)); + + /* free old element */ + + RTMEMDIAG1 ("memHeapRealloc: free old pointer...\n"); + + memHeapFreePtr (ppvMemHeap, mem_p); + + CHECKMEMHEAP (pMemHeap); + + return (newMem_p); + } + else { /* shrinking */ + RTMEMDIAG1 ("memHeapRealloc: shrinking ...\n"); + + /* just free the pointer, if nbytes == 0 */ + + if (nbytes == 0) { + RTMEMDIAG1 ("memHeapRealloc: free pointer...\n"); + memHeapFreePtr (ppvMemHeap, mem_p); + return (NULL); + } + + /* do not shrink, if size diff is too small */ + + /* sizeof (OSMemElemDescr) == 1 unit */ + if (pElem_nunits (pElem) - nunits > 1) { + + /* if it is the last element in the block, then just change the size + and free_x. */ + + if (ISLAST (pElem)) { + pMemBlk->free_x -= (pElem_nunits (pElem) - nunits); + + FILLFREEMEM (&pMemBlk->data [pMemBlk->free_x * 8u], + (pElem_nunits (pElem) - nunits) * 8u); + } + else { + OSMemElemDescr* pNewElem; + + /* create new free element on the freed place */ + + pNewElem = (OSMemElemDescr*) (pElem_data (pElem) + nbytes); + + /* sizeof (OSMemElemDescr) == 1 unit */ + pElem_nunits (pNewElem) = (ASN1USINT)(pElem_nunits (pElem) - nunits - 1); + + initNewFreeElement (pMemBlk, pNewElem, pElem); + + pMemBlk->freeMem += (pElem_nunits (pElem) - nunits) - 1; + } + pElem_nunits (pElem) = (ASN1USINT)nunits; + + TRACEMEMELEM (pMemBlk, pElem, "Reallocated"); + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMELEM (pMemBlk, (!ISLAST (pElem)) ? GETNEXT (pElem) : pElem); + CHECKMEMBLOCK (pMemHeap, pMemBlk); + } + return (mem_p); + } +} + +/* Clears heap memory (frees all memory, reset all heap's variables) */ +void memHeapFreeAll (void** ppvMemHeap) +{ + OSMemHeap* pMemHeap; + OSMemLink* pMemLink; + OSMemLink* pMemLink2; + + if (ppvMemHeap == 0 || *ppvMemHeap == 0) return; + pMemHeap = *(OSMemHeap**)ppvMemHeap; + + pMemLink = pMemHeap->phead; + RTMEMDIAG2 ("memHeapFreeAll: pMemHeap = 0x%x\n", pMemHeap); + + TRACEFREE (pMemHeap, "memHeapFreeAll\n\n"); + CHECKMEMHEAP (pMemHeap); + + /* Release any dynamic memory blocks that may have been allocated */ + + while (pMemLink) { + pMemLink2 = pMemLink; + pMemLink = pMemLink2->pnext; + + RTMEMDIAG3 ("memHeapFreeAll: pMemLink2 = 0x%x, pMemLink = 0x%x\n", + pMemLink2, pMemLink); + +#ifdef _MEMDEBUG + if (pMemLink2->blockType & RTMEMSTD) { + OSMemBlk* pMemBlk = (OSMemBlk*) pMemLink2->pMemBlk; + FILLFREEMEM (pMemBlk->data, (pMemBlk->nunits * 8u)); + FILLFREEMEM (pMemBlk, sizeof (*pMemBlk)); + } +#endif + if (!(pMemLink2->blockType & RTMEMSAVED)) { + OSMemBlk* pMemBlk = (OSMemBlk*) pMemLink2->pMemBlk; + + /* unlink block first */ + + if(pMemLink2->pnext != 0) { + pMemLink2->pnext->pprev = pMemLink2->pprev; + } + if(pMemLink2->pprev != 0) { + pMemLink2->pprev->pnext = pMemLink2->pnext; + } + else { /* head */ + pMemHeap->phead = pMemLink2->pnext; + } + + /* correct heap's variables */ + + pMemHeap->usedUnits -= pMemBlk->nunits; + + if (pMemBlk->free_x == 0) + pMemHeap->freeBlocks --; + else + pMemHeap->usedBlocks --; + + /* free link and block */ + + if (((pMemLink2->blockType & RTMEMSTD) || + (pMemLink2->blockType & RTMEMMALLOC)) && + !(pMemLink2->blockType & RTMEMLINK)) + g_free_func (pMemLink2->pMemBlk); + g_free_func (pMemLink2); + } + } +} + +/* increments internal refCnt. use memHeapRelease to decrement and release */ +void memHeapAddRef (void** ppvMemHeap) +{ + OSMemHeap* pMemHeap; + + if (ppvMemHeap == 0 || *ppvMemHeap == 0) return; + pMemHeap = *(OSMemHeap**)ppvMemHeap; + pMemHeap->refCnt++; +} + +/* Frees all memory and heap structure as well (if was allocated) */ +void memHeapRelease (void** ppvMemHeap) +{ + OSMemHeap** ppMemHeap = (OSMemHeap**)ppvMemHeap; + + if (ppMemHeap != 0 && *ppMemHeap != 0 && --(*ppMemHeap)->refCnt == 0) { + OSMemLink* pMemLink, *pMemLink2; + + memHeapFreeAll (ppvMemHeap); + + /* if there are RTMEMSAVED blocks - release memory for links only */ + + pMemLink = (*ppMemHeap)->phead; + while (pMemLink) { + pMemLink2 = pMemLink; + pMemLink = pMemLink2->pnext; + + free (pMemLink2); + } + + if ((*ppMemHeap)->flags & RT_MH_FREEHEAPDESC) + free (*ppMemHeap); + + *ppMemHeap = 0; + } +} + +/* This function is used for marking memory block as "saved". It means + * that the memory block containing the specified memory pointer won't be + * freed after calls to memHeapFreeAll/memHeapReset. User is responsible + * for freeing the marked memory block by call to memFreeBlock */ + +void* memHeapMarkSaved (void** ppvMemHeap, const void* mem_p, + ASN1BOOL saved) +{ + OSMemHeap* pMemHeap; + OSMemLink* pMemLink; + ASN1UINT nsaved = 1; + + RTMEMDIAG2 ("memHeapMarkSaved: for mem_p = 0x%x\n", mem_p); + + if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0) + return 0; + + pMemHeap = *(OSMemHeap**)ppvMemHeap; + pMemLink = pMemHeap->phead; + + /* look for chain of RAW blocks first */ + + for (; pMemLink != 0; pMemLink = pMemLink->pnextRaw) { + if ((pMemLink->blockType & RTMEMRAW) && + pMemLink->pMemBlk == mem_p) + { + break; + } + } + if (pMemLink == 0) { + OSMemElemDescr* pElem; + OSMemBlk* pMemBlk; + + /* gain the MemLink from pointer */ + + pElem = (OSMemElemDescr*) (((char*)mem_p) - sizeof_OSMemElemDescr); + + if (ISFREE (pElem)) { /* already freed! */ + RTMEMDIAG2 ("memHeapMarkSaved: the element 0x%x is " + "already free!\n", pElem); + return 0; + } + + if ((ISSAVED (pElem) && !saved) || (!ISSAVED (pElem) && saved)) { + + pMemBlk = GET_MEMBLK (pElem); + + CHECKMEMELEM (pMemBlk, pElem); + CHECKMEMBLOCK(pMemHeap, pMemBlk); + + pMemLink = pMemBlk->plink; + + if (saved) + SET_SAVED (pMemBlk, pElem); + else + CLEAR_SAVED (pMemBlk, pElem); + nsaved = pMemBlk->nsaved; + } + else + return 0; + } + if (saved && nsaved > 0) + pMemLink->blockType |= RTMEMSAVED; + else if (nsaved == 0) + pMemLink->blockType &= (~RTMEMSAVED); + return pMemLink->pMemBlk; +} + +/* This function will set the free index in all blocks to zero thereby */ +/* allowing the blocks to be reused (ED, 3/17/2002).. */ + +void memHeapReset (void** ppvMemHeap) +{ + OSMemHeap* pMemHeap; + OSMemLink *pMemLink; + + if (ppvMemHeap == 0 || *ppvMemHeap == 0) return; + pMemHeap = *(OSMemHeap**)ppvMemHeap; + + pMemLink = pMemHeap->phead; + TRACEFREE (pMemHeap, "memHeapReset\n\n"); + while (pMemLink) { + if (!(pMemLink->blockType & RTMEMSAVED)) { + if (pMemLink->blockType & RTMEMSTD) { + OSMemBlk* pMemBlk = (OSMemBlk*) pMemLink->pMemBlk; + if (pMemBlk->free_x != 0) { + pMemHeap->freeUnits += pMemBlk->nunits; + pMemHeap->freeBlocks ++; + } + pMemBlk->free_x = 0; + pMemBlk->freeElemOff = 0; + pMemBlk->lastElemOff = 0; + pMemBlk->freeMem = 0; + FILLFREEMEM (pMemBlk->data, pMemBlk->nunits * 8u); + } + else if (pMemLink->blockType & RTMEMRAW) { + /* if RAW block - free it */ + memHeapFreePtr (ppvMemHeap, pMemLink->pMemBlk); + } + } + pMemLink = pMemLink->pnext; + } +} + +/* add memory block to list */ + +static OSMemLink* memHeapAddBlock (OSMemLink** ppMemLink, + void* pMemBlk, int blockType) +{ + OSMemLink* pMemLink; + + /* if pMemBlk has RTMEMLINK flags it means that it is allocated + * cooperatively with OSMemLink, and we don't need to do additional + * allocations for it. Just use pointer's arithemtic. */ + + if (blockType & RTMEMLINK) + pMemLink = (OSMemLink*) (((ASN1OCTET*)pMemBlk) - sizeof (OSMemLink)); + else { + pMemLink = (OSMemLink*) g_malloc_func ( + sizeof(OSMemLink) + sizeof (int)); + if (pMemLink == 0) return 0; + /* An extra integer is necessary to save a size of a RAW memory block + to perform rtMemRealloc through malloc/memcpy/free */ + *(int*)(((char*)pMemLink) + sizeof (OSMemLink)) = (int)-1; + } + if (pMemLink == NULL) + return NULL; + pMemLink->blockType = (ASN1OCTET)blockType; + pMemLink->pMemBlk = pMemBlk; + pMemLink->pprev = 0; + pMemLink->pnext = *ppMemLink; + + if (*ppMemLink != 0) { + if ((*ppMemLink)->blockType & RTMEMRAW) + pMemLink->pnextRaw = *ppMemLink; + else { + pMemLink->pnextRaw = (*ppMemLink)->pnextRaw; + (*ppMemLink)->pnextRaw = 0; + } + } + else { + pMemLink->pnextRaw = 0; + } + + *ppMemLink = pMemLink; + if (pMemLink->pnext != 0) + pMemLink->pnext->pprev = pMemLink; + ((OSMemBlk*)pMemBlk)->plink = pMemLink; /*!AB */ + + RTMEMDIAG2 ("memHeapAddBlock: pMemLink = 0x%x\n", pMemLink); + RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pnext = 0x%x\n", + pMemLink->pnext); + RTMEMDIAG2 ("memHeapAddBlock: pMemLink->pprev = 0x%x\n", + pMemLink->pprev); + + return pMemLink; +} + +int memHeapCheckPtr (void** ppvMemHeap, void* mem_p) +{ + OSMemHeap* pMemHeap; + OSMemLink* pMemLink; + + RTMEMDIAG2 ("memHeapCheckPtr: for mem_p = 0x%x\n", mem_p); + + if (ppvMemHeap == 0 || *ppvMemHeap == 0 || mem_p == 0) + return 0; + pMemHeap = *(OSMemHeap**)ppvMemHeap; + + pMemLink = pMemHeap->phead; + + for (; pMemLink != 0; pMemLink = pMemLink->pnext) { + if (pMemLink->blockType & RTMEMRAW) { + + /* if RAW block, the pointer should be stored in pMemBlk */ + + if (pMemLink->pMemBlk == mem_p) + return 1; + } + else { + OSMemBlk* pMemBlk = (OSMemBlk*)pMemLink->pMemBlk; + + /* Check, is the pointer inside this memory page */ + + if (mem_p > pMemLink->pMemBlk && + mem_p < (void*)(((ASN1OCTET*)pMemLink->pMemBlk) + pMemBlk->nunits * 8u)) + { + /* Check, is the pointer a correct element of the mem page */ + + OSMemElemDescr* pElem = (OSMemElemDescr*) pMemBlk->data; + for (; pElem != 0; pElem = GETNEXT (pElem)) { + + void* curMem_p = (void*) pElem_data (pElem); + if (curMem_p == mem_p && !ISFREE (pElem)) + return 1; + } + } + } + } + return 0; +} + +void memHeapSetProperty (void** ppvMemHeap, ASN1UINT propId, void* pProp) +{ + OSMemHeap* pMemHeap; + + if (ppvMemHeap == 0) + return; + + if (*ppvMemHeap == 0) + memHeapCreate (ppvMemHeap); + + pMemHeap = *(OSMemHeap**)ppvMemHeap; + switch (propId) { + case OSRTMH_PROPID_DEFBLKSIZE: + pMemHeap->defBlkSize = *(ASN1UINT*)pProp; + break; + case OSRTMH_PROPID_SETFLAGS: + pMemHeap->flags |= ((*(ASN1UINT*)pProp) & (~RT_MH_INTERNALMASK)); + break; + case OSRTMH_PROPID_CLEARFLAGS: + pMemHeap->flags &= ((~(*(ASN1UINT*)pProp)) | RT_MH_INTERNALMASK); + break; + } +} + +int memHeapCreate (void** ppvMemHeap) +{ + OSMemHeap* pMemHeap; + if (ppvMemHeap == 0) return ASN_E_INVPARAM; + + pMemHeap = (OSMemHeap*) g_malloc_func (sizeof (OSMemHeap)); + if (pMemHeap == NULL) return ASN_E_NOMEM; + memset (pMemHeap, 0, sizeof (OSMemHeap)); + pMemHeap->defBlkSize = g_defBlkSize; + pMemHeap->refCnt = 1; + pMemHeap->flags = RT_MH_FREEHEAPDESC; + *ppvMemHeap = (void*)pMemHeap; + return ASN_OK; +} + diff --git a/addons/ooh323c/src/memheap.h b/addons/ooh323c/src/memheap.h new file mode 100644 index 000000000..b99f9dbc9 --- /dev/null +++ b/addons/ooh323c/src/memheap.h @@ -0,0 +1,61 @@ +/* + * 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. + * + *****************************************************************************/ + +#ifndef __RTMEMHEAP_HH__ +#define __RTMEMHEAP_HH__ + +#include "ooasn1.h" + +/* internal heap flags */ +#define RT_MH_INTERNALMASK 0xF0000000u +#define RT_MH_FREEHEAPDESC 0x10000000u + +typedef struct OSMemLink { + struct OSMemLink* pnext; + struct OSMemLink* pprev; + struct OSMemLink* pnextRaw; /* next RAW block */ + void* pMemBlk; + ASN1OCTET blockType; /* 1 = standard, 2 = raw (see RTMEM* flags) */ +} OSMemLink; + +/* MemLink blockTypes */ +#define RTMEMSTD 0x0001 +#define RTMEMRAW 0x0002 +#define RTMEMMALLOC 0x0004 +#define RTMEMSAVED 0x0008 +#define RTMEMLINK 0x0010 /* contains MemLink */ + +/* ASN.1 memory allocation structures */ + +typedef struct OSMemHeap { + OSMemLink* phead; + ASN1UINT usedUnits; + ASN1UINT usedBlocks; + ASN1UINT freeUnits; + ASN1UINT freeBlocks; + ASN1UINT keepFreeUnits; + ASN1UINT defBlkSize; + ASN1UINT refCnt; + ASN1UINT flags; +} OSMemHeap; + +/* see rtMemDefs.c file */ +extern ASN1UINT g_defBlkSize; +extern OSMallocFunc g_malloc_func; +extern OSReallocFunc g_realloc_func; +extern OSFreeFunc g_free_func; + +#endif /* __RTMEMHEAP_HH__ */ diff --git a/addons/ooh323c/src/ooCalls.c b/addons/ooh323c/src/ooCalls.c new file mode 100644 index 000000000..33f584c5a --- /dev/null +++ b/addons/ooh323c/src/ooCalls.c @@ -0,0 +1,820 @@ +/* + * 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 "ootrace.h" +#include "ootypes.h" +#include "ooCalls.h" +#include "ooUtils.h" +#include "ooports.h" +#include "oochannels.h" +#include "ooh245.h" +#include "ooCapability.h" +#include "ooGkClient.h" +#include "ooh323ep.h" +#include "ooCalls.h" + +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + +OOH323CallData* ooCreateCall(char* type, char*callToken) +{ + OOH323CallData *call=NULL; + OOCTXT *pctxt=NULL; + + pctxt = newContext(); + if(!pctxt) + { + OOTRACEERR1("ERROR:Failed to create OOCTXT for new call\n"); + return NULL; + } + call = (OOH323CallData*)memAlloc(pctxt, sizeof(OOH323CallData)); + if(!call) + { + OOTRACEERR1("ERROR:Memory - ooCreateCall - call\n"); + return NULL; + } + /* memset(call, 0, sizeof(OOH323CallData));*/ + call->pctxt = pctxt; + call->callMode = gH323ep.callMode; + sprintf(call->callToken, "%s", callToken); + sprintf(call->callType, "%s", type); + call->callReference = 0; + if(gH323ep.callerid) { + strncpy(call->ourCallerId, gH323ep.callerid, sizeof(call->ourCallerId)-1); + call->ourCallerId[sizeof(call->ourCallerId)-1] = '\0'; + } + else { + call->ourCallerId[0] = '\0'; + } + + memset(&call->callIdentifier, 0, sizeof(H225CallIdentifier)); + memset(&call->confIdentifier, 0, sizeof(H225ConferenceIdentifier)); + + call->flags = 0; + if (OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING)) + OO_SETFLAG (call->flags, OO_M_TUNNELING); + + if(gH323ep.gkClient) + { + if(OO_TESTFLAG(gH323ep.flags, OO_M_GKROUTED)) + { + OO_SETFLAG(call->flags, OO_M_GKROUTED); + } + } + + if (OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART)) + OO_SETFLAG (call->flags, OO_M_FASTSTART); + + if (OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN)) + OO_SETFLAG (call->flags, OO_M_MEDIAWAITFORCONN); + + call->callState = OO_CALL_CREATED; + call->callEndReason = OO_REASON_UNKNOWN; + call->pCallFwdData = NULL; + + if(!strcmp(call->callType, "incoming")) + { + call->callingPartyNumber = NULL; + } + else{ + if(ooUtilsIsStrEmpty(gH323ep.callingPartyNumber)) + { + call->callingPartyNumber = NULL; + } + else{ + call->callingPartyNumber = (char*) memAlloc(call->pctxt, + strlen(gH323ep.callingPartyNumber)+1); + if(call->callingPartyNumber) + { + strcpy(call->callingPartyNumber, gH323ep.callingPartyNumber); + } + else{ + OOTRACEERR3("Error:Memory - ooCreateCall - callingPartyNumber" + ".(%s, %s)\n", call->callType, call->callToken); + freeContext(pctxt); + return NULL; + } + } + } + + call->calledPartyNumber = NULL; + call->h245ConnectionAttempts = 0; + call->h245SessionState = OO_H245SESSION_IDLE; + call->dtmfmode = gH323ep.dtmfmode; + call->mediaInfo = NULL; + strcpy(call->localIP, gH323ep.signallingIP); + call->pH225Channel = NULL; + call->pH245Channel = NULL; + call->h245listener = NULL; + call->h245listenport = NULL; + call->remoteIP[0] = '\0'; + call->remotePort = 0; + call->remoteH245Port = 0; + call->remoteDisplayName = NULL; + call->remoteAliases = NULL; + call->ourAliases = NULL; + call->masterSlaveState = OO_MasterSlave_Idle; + call->statusDeterminationNumber = 0; + call->localTermCapState = OO_LocalTermCapExchange_Idle; + call->remoteTermCapState = OO_RemoteTermCapExchange_Idle; + call->ourCaps = NULL; + call->remoteCaps = NULL; + call->jointCaps = NULL; + dListInit(&call->remoteFastStartOLCs); + call->remoteTermCapSeqNo =0; + call->localTermCapSeqNo = 0; + memcpy(&call->capPrefs, &gH323ep.capPrefs, sizeof(OOCapPrefs)); + call->logicalChans = NULL; + call->noOfLogicalChannels = 0; + call->logicalChanNoBase = 1001; + call->logicalChanNoMax = 1100; + call->logicalChanNoCur = 1001; + call->nextSessionID = 4; /* 1,2,3 are reserved for audio, video and data */ + dListInit(&call->timerList); + call->msdRetries = 0; + call->pFastStartRes = NULL; + call->usrData = NULL; + OOTRACEINFO3("Created a new call (%s, %s)\n", call->callType, + call->callToken); + /* Add new call to calllist */ + ooAddCallToList (call); + if(gH323ep.h323Callbacks.onNewCallCreated) + gH323ep.h323Callbacks.onNewCallCreated(call); + return call; +} + +int ooAddCallToList(OOH323CallData *call) +{ + if(!gH323ep.callList) + { + gH323ep.callList = call; + call->next = NULL; + call->prev = NULL; + } + else{ + call->next = gH323ep.callList; + call->prev = NULL; + gH323ep.callList->prev = call; + gH323ep.callList = call; + } + return OO_OK; +} + + +int ooEndCall(OOH323CallData *call) +{ + OOTRACEDBGA4("In ooEndCall call state is - %s (%s, %s)\n", + ooGetCallStateText(call->callState), call->callType, + call->callToken); + + if(call->callState == OO_CALL_CLEARED) + { + ooCleanCall(call); + return OO_OK; + } + + if(call->logicalChans) + { + OOTRACEINFO3("Clearing all logical channels. (%s, %s)\n", call->callType, + call->callToken); + ooClearAllLogicalChannels(call); + } + + if(!OO_TESTFLAG(call->flags, OO_M_ENDSESSION_BUILT)) + { + if(call->h245SessionState == OO_H245SESSION_ACTIVE || + call->h245SessionState == OO_H245SESSION_ENDRECVD) + { + ooSendEndSessionCommand(call); + OO_SETFLAG(call->flags, OO_M_ENDSESSION_BUILT); + } + } + + + if(!call->pH225Channel || call->pH225Channel->sock ==0) + { + call->callState = OO_CALL_CLEARED; + } + else{ + if(!OO_TESTFLAG(call->flags, OO_M_RELEASE_BUILT)) + { + if(call->callState == OO_CALL_CLEAR || + call->callState == OO_CALL_CLEAR_RELEASERECVD) + { + ooSendReleaseComplete(call); + OO_SETFLAG(call->flags, OO_M_RELEASE_BUILT); + } + } + } + + return OO_OK; +} + + + +int ooRemoveCallFromList (OOH323CallData *call) +{ + if(!call) + return OO_OK; + + if(call == gH323ep.callList) + { + if(!call->next) + gH323ep.callList = NULL; + else{ + call->next->prev = NULL; + gH323ep.callList = call->next; + } + } + else{ + call->prev->next = call->next; + if(call->next) + call->next->prev = call->prev; + } + return OO_OK; +} + +int ooCleanCall(OOH323CallData *call) +{ + OOCTXT *pctxt; + + OOTRACEWARN4 ("Cleaning Call (%s, %s)- reason:%s\n", + call->callType, call->callToken, + ooGetReasonCodeText (call->callEndReason)); + + /* First clean all the logical channels, if not already cleaned. */ + if(call->logicalChans) + ooClearAllLogicalChannels(call); + + /* Close H.245 connection, if not already closed */ + if(call->h245SessionState != OO_H245SESSION_CLOSED) + ooCloseH245Connection(call); + else{ + if(call->pH245Channel && call->pH245Channel->outQueue.count > 0) + { + dListFreeAll(call->pctxt, &(call->pH245Channel->outQueue)); + memFreePtr(call->pctxt, call->pH245Channel); + } + } + + /* Close H.245 listener, if not already closed */ + if(call->h245listener) + { + ooCloseH245Listener(call); + } + + /* Close H225 connection, if not already closed. */ + if (0 != call->pH225Channel && 0 != call->pH225Channel->sock) + { + ooCloseH225Connection(call); + } + + /* Clean timers */ + if(call->timerList.count > 0) + { + dListFreeAll(call->pctxt, &(call->timerList)); + } + + if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK)) + { + ooGkClientCleanCall(gH323ep.gkClient, call); + } + + ooRemoveCallFromList (call); + OOTRACEINFO3("Removed call (%s, %s) from list\n", call->callType, + call->callToken); + + if(call->pCallFwdData && call->pCallFwdData->fwdedByRemote) + { + + if(gH323ep.h323Callbacks.onCallForwarded) + gH323ep.h323Callbacks.onCallForwarded(call); + + if(ooH323HandleCallFwdRequest(call)!= OO_OK) + { + OOTRACEERR3("Error:Failed to forward call (%s, %s)\n", call->callType, + call->callToken); + } + } + else { + if(gH323ep.h323Callbacks.onCallCleared) + gH323ep.h323Callbacks.onCallCleared(call); + } + + pctxt = call->pctxt; + freeContext(pctxt); + ASN1CRTFREE0(pctxt); + return OO_OK; +} + + +int ooCallSetCallerId(OOH323CallData* call, const char* callerid) +{ + if(!call || !callerid) return OO_FAILED; + strncpy(call->ourCallerId, callerid, sizeof(call->ourCallerId)-1); + call->ourCallerId[sizeof(call->ourCallerId)-1]='\0'; + return OO_OK; +} + +int ooCallSetCallingPartyNumber(OOH323CallData *call, const char *number) +{ + if(call->callingPartyNumber) + memFreePtr(call->pctxt, call->callingPartyNumber); + + call->callingPartyNumber = (char*) memAlloc(call->pctxt, strlen(number)+1); + if(call->callingPartyNumber) + { + strcpy(call->callingPartyNumber, number); + } + else{ + OOTRACEERR3("Error:Memory - ooCallSetCallingPartyNumber - " + "callingPartyNumber.(%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + /* Set dialed digits alias */ + /* if(!strcmp(call->callType, "outgoing")) + { + ooCallAddAliasDialedDigits(call, number); + }*/ + return OO_OK; +} + +int ooCallGetCallingPartyNumber(OOH323CallData *call, char *buffer, int len) +{ + if(call->callingPartyNumber) + { + if(len>(int)strlen(call->callingPartyNumber)) + { + strcpy(buffer, call->callingPartyNumber); + return OO_OK; + } + } + + return OO_FAILED; +} + + +int ooCallSetCalledPartyNumber(OOH323CallData *call, const char *number) +{ + if(call->calledPartyNumber) + memFreePtr(call->pctxt, call->calledPartyNumber); + + call->calledPartyNumber = (char*) memAlloc(call->pctxt, strlen(number)+1); + if(call->calledPartyNumber) + { + strcpy(call->calledPartyNumber, number); + } + else{ + OOTRACEERR3("Error:Memory - ooCallSetCalledPartyNumber - " + "calledPartyNumber.(%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + return OO_OK; +} + +int ooCallGetCalledPartyNumber(OOH323CallData *call, char *buffer, int len) +{ + if(call->calledPartyNumber) + { + if(len>(int)strlen(call->calledPartyNumber)) + { + strcpy(buffer, call->calledPartyNumber); + return OO_OK; + } + } + + return OO_FAILED; +} + +int ooCallClearAliases(OOH323CallData *call) +{ + if(call->ourAliases) + memFreePtr(call->pctxt, call->ourAliases); + call->ourAliases = NULL; + return OO_OK; +} + + +int ooCallAddAlias + (OOH323CallData *call, int aliasType, const char *value, OOBOOL local) +{ + ooAliases * psNewAlias=NULL; + psNewAlias = (ooAliases*)memAlloc(call->pctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR3("Error:Memory - ooCallAddAlias - psNewAlias" + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + psNewAlias->type = aliasType; + psNewAlias->value = (char*) memAlloc(call->pctxt, strlen(value)+1); + if(!psNewAlias->value) + { + OOTRACEERR3("Error:Memory - ooCallAddAlias - psNewAlias->value" + " (%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, value); + + if(local) + { + psNewAlias->next = call->ourAliases; + call->ourAliases = psNewAlias; + } + else { + psNewAlias->next = call->remoteAliases; + call->remoteAliases = psNewAlias; + } + + OOTRACEDBGC5("Added %s alias %s to call. (%s, %s)\n", + local?"local":"remote", value, call->callType, call->callToken); + return OO_OK; +} + +int ooCallAddAliasH323ID(OOH323CallData *call, const char* h323id) +{ + return ooCallAddAlias(call, T_H225AliasAddress_h323_ID, h323id, TRUE); +} + + +int ooCallAddAliasDialedDigits(OOH323CallData *call, const char* dialedDigits) +{ + return ooCallAddAlias + (call, T_H225AliasAddress_dialedDigits, dialedDigits, TRUE); +} + + +int ooCallAddAliasEmailID(OOH323CallData *call, const char* email) +{ + return ooCallAddAlias(call, T_H225AliasAddress_email_ID, email, TRUE); +} + + +int ooCallAddAliasURLID(OOH323CallData *call, const char* url) +{ + return ooCallAddAlias(call, T_H225AliasAddress_url_ID, url, TRUE); +} + + +int ooCallAddRemoteAliasH323ID(OOH323CallData *call, const char* h323id) +{ + return ooCallAddAlias(call, T_H225AliasAddress_h323_ID, h323id, FALSE); +} + +int ooCallAddRemoteAliasDialedDigits + (OOH323CallData *call, const char* dialedDigits) +{ + return ooCallAddAlias + (call, T_H225AliasAddress_dialedDigits, dialedDigits, FALSE); +} + + + +/* Used to override global end point capabilities and add call specific + capabilities */ + +int ooCallAddG7231Capability(OOH323CallData *call, int cap, int txframes, + int rxframes, OOBOOL silenceSuppression, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, + silenceSuppression, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, FALSE); +} + + + +int ooCallAddG729Capability(OOH323CallData *call, int cap, int txframes, + int rxframes, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, FALSE, + dir, startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, FALSE); +} + +/* +int ooCallAddG726Capability(OOH323CallData *call, int cap, int txframes, + int rxframes, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, FALSE, + dir, startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, FALSE); +} +*/ + +int ooCallAddG728Capability(OOH323CallData *call, int cap, int txframes, + int rxframes, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, FALSE, + dir, startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, FALSE); +} + +int ooCallAddG711Capability(OOH323CallData *call, int cap, int txframes, + int rxframes, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(call, cap, txframes, rxframes, FALSE, + dir, startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, FALSE); +} + +int ooCallAddGSMCapability + (OOH323CallData* call, int cap, ASN1USINT framesPerPkt, + OOBOOL comfortNoise, OOBOOL scrambled, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddGSMCapability(call, cap, framesPerPkt, comfortNoise, + scrambled, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, FALSE); +} + + +int ooCallAddH263VideoCapability + (OOH323CallData *call, int cap, unsigned sqcifMPI, unsigned qcifMPI, + unsigned cifMPI, unsigned cif4MPI, unsigned cif16MPI, unsigned maxBitRate, + int dir, cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + + return ooCapabilityAddH263VideoCapability(call, sqcifMPI, qcifMPI, cifMPI, + cif4MPI, cif16MPI, maxBitRate,dir, + startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, + FALSE); + +} + +int ooCallEnableDTMFRFC2833(OOH323CallData *call, int dynamicRTPPayloadType) +{ + return ooCapabilityEnableDTMFRFC2833(call, dynamicRTPPayloadType); +} + +int ooCallDisableDTMFRFC2833(OOH323CallData *call) +{ + return ooCapabilityDisableDTMFRFC2833(call); +} + + +int ooCallEnableDTMFH245Alphanumeric(OOH323CallData *call) +{ + return ooCapabilityEnableDTMFH245Alphanumeric(call); +} + +int ooCallDisableDTMFH245Alphanumeric(OOH323CallData *call) +{ + return ooCapabilityDisableDTMFH245Alphanumeric(call); +} + +int ooCallEnableDTMFH245Signal(OOH323CallData *call) +{ + return ooCapabilityEnableDTMFH245Signal(call); +} + +int ooCallDisableDTMFH245Signal(OOH323CallData *call) +{ + return ooCapabilityDisableDTMFH245Signal(call); +} + +int ooCallEnableDTMFQ931Keypad(OOH323CallData *call) +{ + return ooCapabilityEnableDTMFQ931Keypad(call); +} + +int ooCallDisableDTMFQ931Keypad(OOH323CallData *call) +{ + return ooCapabilityDisableDTMFQ931Keypad(call); +} + + +OOH323CallData* ooFindCallByToken(char *callToken) +{ + OOH323CallData *call; + if(!callToken) + { + OOTRACEERR1("ERROR:Invalid call token passed - ooFindCallByToken\n"); + return NULL; + } + if(!gH323ep.callList) + { + OOTRACEERR1("ERROR: Empty calllist - ooFindCallByToken failed\n"); + return NULL; + } + call = gH323ep.callList; + while(call) + { + if(!strcmp(call->callToken, callToken)) + break; + else + call = call->next; + } + + if(!call) + { + OOTRACEERR2("ERROR:Call with token %s not found\n", callToken); + return NULL; + } + return call; +} + + + +/* Checks whether session with suplied ID and direction is already active*/ +ASN1BOOL ooIsSessionEstablished(OOH323CallData *call, int sessionID, char* dir) +{ + OOLogicalChannel * temp = NULL; + temp = call->logicalChans; + while(temp) + { + if(temp->sessionID == sessionID && + temp->state == OO_LOGICALCHAN_ESTABLISHED && + !strcmp(temp->dir, dir) ) + return TRUE; + temp = temp->next; + } + return FALSE; +} + +int ooAddMediaInfo(OOH323CallData *call, OOMediaInfo mediaInfo) +{ + OOMediaInfo *newMediaInfo=NULL; + + if(!call) + { + OOTRACEERR3("Error:Invalid 'call' param for ooAddMediaInfo.(%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + newMediaInfo = (OOMediaInfo*) memAlloc(call->pctxt, sizeof(OOMediaInfo)); + if(!newMediaInfo) + { + OOTRACEERR3("Error:Memory - ooAddMediaInfo - newMediaInfo. " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + memcpy (newMediaInfo, &mediaInfo, sizeof(OOMediaInfo)); + + OOTRACEDBGC4("Configured mediainfo for cap %s (%s, %s)\n", + ooGetCapTypeText(mediaInfo.cap), + call->callType, call->callToken); + if(!call->mediaInfo) { + newMediaInfo->next = NULL; + call->mediaInfo = newMediaInfo; + } + else { + newMediaInfo->next = call->mediaInfo; + call->mediaInfo = newMediaInfo; + } + return OO_OK; +} + +unsigned ooCallGenerateSessionID + (OOH323CallData *call, OOCapType type, char *dir) +{ + unsigned sessionID=0; + + if(type == OO_CAP_TYPE_AUDIO) + { + if(!ooGetLogicalChannel(call, 1, dir)) + { + sessionID = 1; + } + else{ + if(call->masterSlaveState == OO_MasterSlave_Master) + sessionID = call->nextSessionID++; + else{ + OOTRACEDBGC4("Session id for %s channel of type audio has to be " + "provided by remote.(%s, %s)\n", dir, call->callType, + call->callToken); + sessionID = 0; /* Will be assigned by remote */ + } + } + } + + if(type == OO_CAP_TYPE_VIDEO) + { + if(!ooGetLogicalChannel(call, 2, dir)) + { + sessionID = 2; + } + else{ + if(call->masterSlaveState == OO_MasterSlave_Master) + sessionID = call->nextSessionID++; + else{ + sessionID = 0; /* Will be assigned by remote */ + OOTRACEDBGC4("Session id for %s channel of type video has to be " + "provided by remote.(%s, %s)\n", dir, call->callType, + call->callToken); + } + } + } + return sessionID; + +} + + +int ooCallH245ConnectionRetryTimerExpired(void *data) +{ + ooTimerCallback *cbData = (ooTimerCallback*) data; + OOH323CallData *call = cbData->call; + + OOTRACEINFO3("H245 connection retry timer expired. (%s, %s)\n", + call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + + call->h245ConnectionAttempts++; + + ooCreateH245Connection(call); + + return OO_OK; +} + +const char* ooGetReasonCodeText (OOUINT32 code) +{ + static const char* reasonCodeText[] = { + "OO_REASON_UNKNOWN", + "OO_REASON_INVALIDMESSAGE", + "OO_REASON_TRANSPORTFAILURE", + "OO_REASON_NOROUTE", + "OO_REASON_NOUSER", + "OO_REASON_NOBW", + "OO_REASON_GK_NOCALLEDUSER", + "OO_REASON_GK_NOCALLERUSER", + "OO_REASON_GK_NORESOURCES", + "OO_REASON_GK_UNREACHABLE", + "OO_REASON_GK_CLEARED", + "OO_REASON_NOCOMMON_CAPABILITIES", + "OO_REASON_REMOTE_FWDED", + "OO_REASON_LOCAL_FWDED", + "OO_REASON_REMOTE_CLEARED", + "OO_REASON_LOCAL_CLEARED", + "OO_REASON_REMOTE_BUSY", + "OO_REASON_LOCAL_BUSY", + "OO_REASON_REMOTE_NOANSWER", + "OO_REASON_LOCAL_NOTANSWERED", + "OO_REASON_REMOTE_REJECTED", + "OO_REASON_LOCAL_REJECTED", + "OO_REASON_REMOTE_CONGESTED", + "OO_REASON_LOCAL_CONGESTED" + }; + return ooUtilsGetText (code, reasonCodeText, OONUMBEROF(reasonCodeText)); +} + +const char* ooGetCallStateText (OOCallState callState) +{ + static const char* callStateText[] = { + "OO_CALL_CREATED", + "OO_CALL_WAITING_ADMISSION", + "OO_CALL_CONNECTING", + "OO_CALL_CONNECTED", + "OO_CALL_PAUSED", + "OO_CALL_CLEAR", + "OO_CALL_CLEAR_RELEASERECVD", + "OO_CALL_CLEAR_RELEASESENT", + "OO_CALL_CLEARED" + }; + return ooUtilsGetText (callState, callStateText, OONUMBEROF(callStateText)); +} + diff --git a/addons/ooh323c/src/ooCalls.h b/addons/ooh323c/src/ooCalls.h new file mode 100644 index 000000000..64d62d6e1 --- /dev/null +++ b/addons/ooh323c/src/ooCalls.h @@ -0,0 +1,822 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * @file ooCalls.h + * This file contains call management functions. + */ +#ifndef _OOCALLS_H_ +#define _OOCALLS_H_ + +#include "ooLogChan.h" +#include "ooCapability.h" + +#ifdef __cplusplus +extern "C" { +#endif + + +/** + * @defgroup callmgmt Call Management + * @{ + */ +/* Flag mask values */ +/* DISABLEGK is used to selectively disable gatekeeper use. For incoming calls + DISABLEGK can be set in onReceivedSetup callback by application. + Very useful in pbx applications where gk is used only when call is + to or from outside pbx domian. For outgoing calls, ooMakeCallNoGk + disables use of gk for specific call. +*/ + + +#define OO_M_ENDSESSION_BUILT ASN1UINTCNT(0x00800000) +#define OO_M_RELEASE_BUILT ASN1UINTCNT(0x00400000) +#define OO_M_FASTSTARTANSWERED ASN1UINTCNT(0x04000000) + +#define OO_M_ENDPOINTCREATED ASN1UINTCNT(0x00010000) +#define OO_M_GKROUTED ASN1UINTCNT(0x00200000) +#define OO_M_AUTOANSWER ASN1UINTCNT(0x00100000) +#define OO_M_TUNNELING ASN1UINTCNT(0x08000000) +#define OO_M_MEDIAWAITFORCONN ASN1UINTCNT(0x20000000) +#define OO_M_FASTSTART ASN1UINTCNT(0x02000000) +#define OO_M_DISABLEGK ASN1UINTCNT(0x01000000) +#define OO_M_MANUALRINGBACK ASN1UINTCNT(0x10000000) + + +/** + * Call states. + */ +typedef enum { + OO_CALL_CREATED, /*!< Call created. */ + OO_CALL_WAITING_ADMISSION, /*!< Call waiting for admission by GK */ + OO_CALL_CONNECTING, /*!< Call in process of connecting */ + OO_CALL_CONNECTED, /*!< Call currently connected. */ + OO_CALL_PAUSED, /*!< Call Paused for hold/transfer. */ + OO_CALL_CLEAR, /*!< Call marked for clearing */ + OO_CALL_CLEAR_RELEASERECVD, /*!< Release command received. */ + OO_CALL_CLEAR_RELEASESENT, /*!< Release sent */ + OO_CALL_CLEARED /*!< Call cleared */ +} OOCallState; + +/** + * H.245 session states. + */ +typedef enum { + OO_H245SESSION_IDLE, + OO_H245SESSION_PAUSED, + OO_H245SESSION_ACTIVE, + OO_H245SESSION_ENDSENT, + OO_H245SESSION_ENDRECVD, + OO_H245SESSION_CLOSED +} OOH245SessionState; + +/** + * Structure to store local and remote media endpoint info for a + * given media type. + */ +typedef struct OOMediaInfo{ + char dir[15]; /* transmit/receive*/ + int cap; + int lMediaPort; + int lMediaCntrlPort; + char lMediaIP[20]; + struct OOMediaInfo *next; +} OOMediaInfo; + +#define ooMediaInfo OOMediaInfo + +struct OOAliases; + +/** + * Structure to hold information on a forwarded call. + */ +typedef struct OOCallFwdData { + char ip[20]; + int port; + struct OOAliases *aliases; + OOBOOL fwdedByRemote; /*Set when we are being fwded by remote*/ +} OOCallFwdData; + +/** + * Structure to store information on an H.323 channel (H.225 or H.245) for + * a particular call. + */ +typedef struct OOH323Channel { + OOSOCKET sock; /*!< Socket connection for the channel */ + int port; /*!< Port assigned to the channel */ + DList outQueue; /*!< Output message queue */ +} OOH323Channel; + +/** + * Structure to store information on fast start response (H.225) to + * reply same answer in CALL PROCEEDING, ALERTING & CONNECT. + */ +typedef struct EXTERN FastStartResponse { + ASN1UINT n; + ASN1DynOctStr *elem; +} FastStartResponse; + + +/** + * This structure is used to maintain all information on an active call. + * A list of these structures is maintained within the global endpoint + * structure. + */ +typedef struct OOH323CallData { + OOCTXT *pctxt; + char callToken[20]; /* ex: ooh323c_call_1 */ + char callType[10]; /* incoming/outgoing */ + OOCallMode callMode; + ASN1USINT callReference; + char ourCallerId[256]; + H225CallIdentifier callIdentifier;/* The call identifier for the active + call. */ + char *callingPartyNumber; + char *calledPartyNumber; + H225ConferenceIdentifier confIdentifier; + ASN1UINT flags; + OOCallState callState; + OOCallClearReason callEndReason; + unsigned h245ConnectionAttempts; + OOH245SessionState h245SessionState; + int dtmfmode; + OOMediaInfo *mediaInfo; + OOCallFwdData *pCallFwdData; + char localIP[20];/* Local IP address */ + OOH323Channel* pH225Channel; + OOH323Channel* pH245Channel; + OOSOCKET *h245listener; + int *h245listenport; + char remoteIP[20];/* Remote IP address */ + int remotePort; + int remoteH245Port; + char *remoteDisplayName; + struct OOAliases *remoteAliases; + struct OOAliases *ourAliases; /*aliases used in the call for us */ + OOMasterSlaveState masterSlaveState; /*!< Master-Slave state */ + ASN1UINT statusDeterminationNumber; + OOCapExchangeState localTermCapState; + OOCapExchangeState remoteTermCapState; + struct ooH323EpCapability* ourCaps; + struct ooH323EpCapability* remoteCaps; /* TODO: once we start using jointCaps, get rid of remoteCaps*/ + struct ooH323EpCapability* jointCaps; + int jointDtmfMode; + DList remoteFastStartOLCs; + ASN1UINT8 remoteTermCapSeqNo; + ASN1UINT8 localTermCapSeqNo; + OOCapPrefs capPrefs; + OOLogicalChannel* logicalChans; + int noOfLogicalChannels; + int logicalChanNoBase; + int logicalChanNoMax; + int logicalChanNoCur; + unsigned nextSessionID; /* Note by default 1 is audio session, 2 is video and 3 is data, from 3 onwards master decides*/ + DList timerList; + ASN1UINT msdRetries; + FastStartResponse *pFastStartRes; /* fast start response */ + void *usrData; /*!dtmfmode |= OO_CAP_DTMF_RFC2833; + OOTRACEINFO3("Enabled RFC2833 DTMF capability for (%s, %s) \n", + call->callType, call->callToken); + } + + /*Dynamic RTP payload type range is from 96 - 127 */ + if(dynamicRTPPayloadType >= 96 && dynamicRTPPayloadType <= 127) + giDynamicRTPPayloadType = dynamicRTPPayloadType; + + return OO_OK; +} + + + +int ooCapabilityDisableDTMFRFC2833(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode ^= OO_CAP_DTMF_RFC2833; + OOTRACEINFO1("Disabled RFC2833 DTMF capability for end-point\n"); + } + else{ + call->dtmfmode ^= OO_CAP_DTMF_RFC2833; + OOTRACEINFO3("Disabled RFC2833 DTMF capability for (%s, %s)\n", + call->callType, call->callToken); + } + + return OO_OK; +} + +int ooCapabilityEnableDTMFH245Alphanumeric(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode |= OO_CAP_DTMF_H245_alphanumeric; + OOTRACEINFO1("Dtmf mode set to H.245(alphanumeric) for endpoint\n"); + } + else { + call->dtmfmode |= OO_CAP_DTMF_H245_alphanumeric; + OOTRACEINFO3("Dtmf mode set to H.245(alphanumeric) for (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityDisableDTMFH245Alphanumeric(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode ^= OO_CAP_DTMF_H245_alphanumeric; + OOTRACEINFO1("Dtmf mode H.245(alphanumeric) disabled for endpoint\n"); + } + else { + call->dtmfmode ^= OO_CAP_DTMF_H245_alphanumeric; + OOTRACEINFO3("Dtmf mode H.245(alphanumeric) disabled for (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityEnableDTMFH245Signal(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode |= OO_CAP_DTMF_H245_signal; + OOTRACEINFO1("Dtmf mode set to H.245(signal) for endpoint\n"); + } + else { + call->dtmfmode |= OO_CAP_DTMF_H245_signal; + OOTRACEINFO3("Dtmf mode set to H.245(signal) for (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityDisableDTMFH245Signal(OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode ^= OO_CAP_DTMF_H245_signal; + OOTRACEINFO1("Dtmf mode H.245(signal) disabled for endpoint\n"); + } + else { + call->dtmfmode ^= OO_CAP_DTMF_H245_signal; + OOTRACEINFO3("Dtmf mode H.245(signal) disabled for (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityEnableDTMFQ931Keypad(struct OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode |= OO_CAP_DTMF_Q931; + OOTRACEINFO1("Dtmf mode set to Q.931(keypad) for the endpoint\n"); + } + else { + call->dtmfmode |= OO_CAP_DTMF_Q931; + OOTRACEINFO3("Dtmf mode set to Q.931(keypad) for the call (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityDisableDTMFQ931Keypad(struct OOH323CallData *call) +{ + if(!call){ + gH323ep.dtmfmode ^= OO_CAP_DTMF_Q931; + OOTRACEINFO1("Dtmf mode Q.931(keypad) disabled for the endpoint\n"); + } + else { + call->dtmfmode ^= OO_CAP_DTMF_Q931; + OOTRACEINFO3("Dtmf mode Q.931(keypad) disabled for the call (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCapabilityAddH263VideoCapability(ooCallData *call, + unsigned sqcifMPI, unsigned qcifMPI, + unsigned cifMPI, unsigned cif4MPI, + unsigned cif16MPI, unsigned maxBitRate, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote) +{ + int ret = OO_OK; + if(sqcifMPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, sqcifMPI, 0, + 0, 0, 0, maxBitRate, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 sqcifMPI capability\n"); + return OO_FAILED; + } + } + if(qcifMPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, 0, qcifMPI, 0, + 0, 0, maxBitRate, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 qcifMPI capability\n"); + return OO_FAILED; + } + } + if(cifMPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, 0, 0, cifMPI, + 0, 0, maxBitRate, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 cifMPI capability\n"); + return OO_FAILED; + } + } + if(cif4MPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, 0, 0, 0, + cif4MPI, 0, maxBitRate, dir, + startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 cif4MPI capability\n"); + return OO_FAILED; + } + } + if(cif16MPI>0) + { + ret = ooCapabilityAddH263VideoCapability_helper(call, dir, 0, 0, 0, 0, + cif16MPI, maxBitRate, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, remote); + if(ret != OO_OK) + { + OOTRACEERR1("Error: Failed to add H263 cif16MPI capability\n"); + return OO_FAILED; + } + } + return OO_OK; + +} + +int ooCapabilityAddH263VideoCapability_helper(ooCallData *call, + unsigned sqcifMPI, unsigned qcifMPI, + unsigned cifMPI, unsigned cif4MPI, + unsigned cif16MPI, unsigned maxBitRate, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote) +{ + + ooH323EpCapability *epCap = NULL, *cur=NULL; + OOH263CapParams *params=NULL; + OOCTXT *pctxt=NULL; + char *pictureType = NULL; + int cap = OO_H263VIDEO; + + if(!call) pctxt = &gH323ep.ctxt; + else pctxt = call->pctxt; + + epCap = (ooH323EpCapability*)memAllocZ(pctxt, sizeof(ooH323EpCapability)); + params = (OOH263CapParams*) memAllocZ(pctxt, sizeof(OOH263CapParams)); + if(!epCap || !params) + { + OOTRACEERR1("Error:Memory - ooCapabilityAddH263Capability - epCap/params" + ".\n"); + return OO_FAILED; + } + + if(sqcifMPI>0) + { + params->MPI = sqcifMPI; + params->picFormat = OO_PICFORMAT_SQCIF; + pictureType = "SQCIF"; + } + if(qcifMPI>0) + { + params->MPI = qcifMPI; + params->picFormat = OO_PICFORMAT_QCIF; + pictureType = "QCIF"; + } + if(cifMPI>0) + { + params->MPI = cifMPI; + params->picFormat = OO_PICFORMAT_CIF; + pictureType = "CIF"; + } + if(cif4MPI>0) + { + params->MPI = cif4MPI; + params->picFormat = OO_PICFORMAT_CIF4; + pictureType = "CIF4"; + } + if(cif16MPI>0) + { + params->MPI = cif16MPI; + params->picFormat = OO_PICFORMAT_CIF16; + pictureType = "CIF16"; + } + + params->maxBitRate = maxBitRate; + + + if(dir & OORXANDTX) + { + epCap->dir = OORX; + epCap->dir |= OOTX; + } + else + epCap->dir = dir; + + epCap->cap = OO_H263VIDEO; + epCap->capType = OO_CAP_TYPE_VIDEO; + epCap->params = (void*)params; + epCap->startReceiveChannel = startReceiveChannel; + epCap->startTransmitChannel = startTransmitChannel; + epCap->stopReceiveChannel = stopReceiveChannel; + epCap->stopTransmitChannel = stopTransmitChannel; + + epCap->next = NULL; + + if(!call) + {/*Add as local capability */ + OOTRACEDBGC2("Adding endpoint H263 video capability %s.\n", pictureType); + if(!gH323ep.myCaps) + gH323ep.myCaps = epCap; + else{ + cur = gH323ep.myCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(NULL, cap); + gH323ep.noOfCaps++; + } + else{ + if(remote) + { + /*Add as remote capability */ + if(!call->remoteCaps) + call->remoteCaps = epCap; + else{ + cur = call->remoteCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + } + else{ + /*Add as our capability */ + OOTRACEDBGC4("Adding call specific H263 video capability %s. " + "(%s, %s)\n", pictureType, call->callType, + call->callToken); + if(!call->ourCaps){ + call->ourCaps = epCap; + ooResetCapPrefs(call); + } + else{ + cur = call->ourCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(call, cap); + } + } + + return OO_OK; +} + +/* Used for g711 ulaw/alaw, g728, g729 and g7231 */ +int ooCapabilityAddSimpleCapability + (OOH323CallData *call, int cap, int txframes, + int rxframes, OOBOOL silenceSuppression, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote) +{ + ooH323EpCapability *epCap = NULL, *cur=NULL; + OOCapParams *params=NULL; + OOCTXT *pctxt=NULL; + if(!call) pctxt = &gH323ep.ctxt; + else pctxt = call->pctxt; + + epCap = (ooH323EpCapability*)memAlloc(pctxt, sizeof(ooH323EpCapability)); + params = (OOCapParams*) memAlloc(pctxt, sizeof(OOCapParams)); + if(!epCap || !params) + { + OOTRACEERR1("ERROR: Memory - ooCapabilityAddSimpleCapability - " + "epCap/params\n"); + return OO_FAILED; + } + + + params->txframes = txframes; + params->rxframes = rxframes; + /* Ignore silence suppression parameter unless cap is g7231 */ + if(cap == OO_G7231) + params->silenceSuppression = silenceSuppression; + else + params->silenceSuppression = FALSE; /* Set to false for g711 and g729*/ + + if(dir & OORXANDTX) { + epCap->dir = OORX; + epCap->dir |= OOTX; + } + else { + epCap->dir = dir; + } + + epCap->cap = cap; + epCap->capType = OO_CAP_TYPE_AUDIO; + epCap->params = (void*)params; + epCap->startReceiveChannel = startReceiveChannel; + epCap->startTransmitChannel = startTransmitChannel; + epCap->stopReceiveChannel = stopReceiveChannel; + epCap->stopTransmitChannel = stopTransmitChannel; + epCap->next = NULL; + + if(!call) + { + /* Add as local capability */ + OOTRACEDBGC2("Adding endpoint capability %s. \n", + ooGetCapTypeText(epCap->cap)); + if(!gH323ep.myCaps) { + gH323ep.myCaps = epCap; + } + else{ + cur = gH323ep.myCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(NULL, cap); + gH323ep.noOfCaps++; + } + else{ + if(remote) + { + /* Add as remote capability */ + if(!call->remoteCaps) { + call->remoteCaps = epCap; + } + else{ + cur = call->remoteCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + } + else{ + /* Add as our capability */ + OOTRACEDBGC4("Adding call specific capability %s. (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + if(!call->ourCaps){ + call->ourCaps = epCap; + ooResetCapPrefs(call); + } + else{ + cur = call->ourCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(call, cap); + } + } + + return OO_OK; +} + + +int ooCapabilityAddGSMCapability(OOH323CallData *call, int cap, + unsigned framesPerPkt, OOBOOL comfortNoise, + OOBOOL scrambled, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote) +{ + + ooH323EpCapability *epCap = NULL, *cur=NULL; + OOGSMCapParams *params=NULL; + OOCTXT *pctxt = NULL; + + if(!call) pctxt = &gH323ep.ctxt; + else pctxt = call->pctxt; + + epCap = (ooH323EpCapability*)memAlloc(pctxt, sizeof(ooH323EpCapability)); + params = (OOGSMCapParams*) memAlloc(pctxt, sizeof(OOGSMCapParams)); + if(!epCap || !params) + { + OOTRACEERR1("Error:Memory - ooCapabilityAddGSMCapability - " + "epCap/params\n"); + return OO_FAILED; + } + + + params->rxframes = framesPerPkt; + params->txframes = framesPerPkt; + params->comfortNoise = comfortNoise; + params->scrambled = scrambled; + if(dir & OORXANDTX) + { + epCap->dir = OORX; + epCap->dir |= OOTX; + } + else + epCap->dir = dir; + + epCap->cap = cap; + epCap->capType = OO_CAP_TYPE_AUDIO; + epCap->params = (void*)params; + epCap->startReceiveChannel = startReceiveChannel; + epCap->startTransmitChannel = startTransmitChannel; + epCap->stopReceiveChannel = stopReceiveChannel; + epCap->stopTransmitChannel = stopTransmitChannel; + + epCap->next = NULL; + /* Add as local capability */ + if(!call) + { + if(!gH323ep.myCaps) + gH323ep.myCaps = epCap; + else{ + cur = gH323ep.myCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(NULL, cap); + gH323ep.noOfCaps++; + } + else{ + if(remote) + { + /*Add as remote capability */ + if(!call->remoteCaps) + call->remoteCaps = epCap; + else{ + cur = call->remoteCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + } + else{ + OOTRACEDBGC4("Adding call specific capability %s. (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + /*Add as our capability */ + if(!call->ourCaps){ + call->ourCaps = epCap; + ooResetCapPrefs(call); + } + else{ + cur = call->ourCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + ooAppendCapToCapPrefs(call, cap); + } + } + + return OO_OK; +} + + + + +struct H245VideoCapability* ooCapabilityCreateVideoCapability + (ooH323EpCapability *epCap, OOCTXT *pctxt, int dir) +{ + + if(!epCap) + { + OOTRACEERR1("Error:Invalid capability parameter passed to " + "ooCapabilityCreateVideoCapability.\n"); + return NULL; + } + + if(!(epCap->dir & dir)) + { + OOTRACEERR1("Error:Failed to create capability due to direction " + "mismatch.\n"); + return NULL; + } + + switch(epCap->cap) + { + case OO_H263VIDEO: + return ooCapabilityCreateH263VideoCapability(epCap, pctxt, dir); + + case OO_NONSTDVIDEO: + case OO_H261VIDEO: + case OO_H262VIDEO: + case OO_IS11172VIDEO: + case OO_GENERICVIDEO: + case OO_EXTELEMVIDEO: + default: + OOTRACEERR2("ERROR: Don't know how to create video capability %s\n", + ooGetCapTypeText(epCap->cap)); + } + return NULL; +} + + + +struct H245AudioCapability* ooCapabilityCreateAudioCapability + (ooH323EpCapability *epCap, OOCTXT *pctxt, int dir) +{ + + if(!epCap) + { + OOTRACEERR1("Error:Invalid capability parameter passed to " + "ooCapabilityCreateAudioCapability.\n"); + return NULL; + } + + if(!(epCap->dir & dir)) + { + OOTRACEERR1("Error:Failed to create capability due to direction " + "mismatch.\n"); + return NULL; + } + + switch(epCap->cap) + { + case OO_G711ALAW64K: + case OO_G711ALAW56K: + case OO_G711ULAW64K: + case OO_G711ULAW56K: + /*case OO_G726:*/ + case OO_G728: + case OO_G729: + case OO_G729A: + case OO_G7231: + return ooCapabilityCreateSimpleCapability(epCap, pctxt, dir); + case OO_GSMFULLRATE: + return ooCapabilityCreateGSMFullRateCapability(epCap, pctxt, dir); + default: + OOTRACEERR2("ERROR: Don't know how to create audio capability %d\n", + epCap->cap); + } + return NULL; +} + + + +void* ooCapabilityCreateDTMFCapability(int cap, OOCTXT *pctxt) +{ + H245AudioTelephonyEventCapability *pATECap=NULL; + H245UserInputCapability *userInput = NULL; + char *events=NULL; + switch(cap) + { + case OO_CAP_DTMF_RFC2833: + pATECap = (H245AudioTelephonyEventCapability*)memAlloc(pctxt, + sizeof(H245AudioTelephonyEventCapability)); + if(!pATECap) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - pATECap\n"); + return NULL; + } + memset(pATECap, 0, sizeof(H245AudioTelephonyEventCapability)); + pATECap->dynamicRTPPayloadType = giDynamicRTPPayloadType; + events = (char*)memAlloc(pctxt, strlen("0-16")+1); + if(!events) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - events\n"); + memFreePtr(pctxt, pATECap); + return NULL; + } + strncpy(events, "0-16", strlen("0-16")); + pATECap->audioTelephoneEvent = events; + return pATECap; + case OO_CAP_DTMF_H245_alphanumeric: + userInput = (H245UserInputCapability*)memAllocZ(pctxt, + sizeof(H245UserInputCapability)); + if(!userInput) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - " + "userInput\n"); + return NULL; + } + userInput->t = T_H245UserInputCapability_basicString; + return userInput; + case OO_CAP_DTMF_H245_signal: + userInput = (H245UserInputCapability*)memAllocZ(pctxt, + sizeof(H245UserInputCapability)); + if(!userInput) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateDTMFCapability - " + "userInput\n"); + return NULL; + } + userInput->t = T_H245UserInputCapability_dtmf; + return userInput; + default: + OOTRACEERR1("Error:unknown dtmf capability type\n"); + } + return NULL; +} + + + +struct H245VideoCapability* ooCapabilityCreateH263VideoCapability + (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir) +{ + H245VideoCapability *pVideo=NULL; + OOH263CapParams *params=NULL; + H245H263VideoCapability *pH263Cap=NULL; + + if(!epCap || !epCap->params) + { + OOTRACEERR1("Error:Invalid capability parameters to " + "ooCapabilityCreateH263VideoCapability.\n"); + return NULL; + } + params =(OOH263CapParams*)epCap->params; + + pVideo = (H245VideoCapability*)memAllocZ(pctxt, + sizeof(H245VideoCapability)); + pH263Cap = (H245H263VideoCapability*) memAllocZ(pctxt, + sizeof(H245H263VideoCapability)); + if(!pVideo || !pH263Cap) + { + OOTRACEERR1("ERROR:Memory - ooCapabilityCreateH263VideoCapability - " + "pVideo/pH263Cap\n"); + return NULL; + } + + pVideo->t = T_H245VideoCapability_h263VideoCapability; + pVideo->u.h263VideoCapability = pH263Cap; + + + if(params->picFormat == OO_PICFORMAT_SQCIF) { + pH263Cap->m.sqcifMPIPresent = TRUE; + pH263Cap->sqcifMPI = params->MPI; + } + else if(params->picFormat == OO_PICFORMAT_QCIF) { + pH263Cap->m.qcifMPIPresent = TRUE; + pH263Cap->qcifMPI = params->MPI; + } + else if(params->picFormat == OO_PICFORMAT_CIF) { + pH263Cap->m.cifMPIPresent = TRUE; + pH263Cap->cifMPI = params->MPI; + } + else if(params->picFormat == OO_PICFORMAT_CIF4) { + pH263Cap->m.cif4MPIPresent = TRUE; + pH263Cap->cif4MPI = params->MPI; + } + else if(params->picFormat == OO_PICFORMAT_CIF16) { + pH263Cap->m.cif16MPIPresent = TRUE; + pH263Cap->cif16MPI = params->MPI; + } + + pH263Cap->m.errorCompensationPresent = TRUE; + pH263Cap->maxBitRate = params->maxBitRate; + pH263Cap->unrestrictedVector = FALSE; + pH263Cap->arithmeticCoding = FALSE; + pH263Cap->advancedPrediction = FALSE; + pH263Cap->pbFrames = FALSE; + pH263Cap->temporalSpatialTradeOffCapability = FALSE; + pH263Cap->hrd_B = 0; + pH263Cap->bppMaxKb = 0; + pH263Cap->slowSqcifMPI = FALSE; + pH263Cap->slowQcifMPI = FALSE; + pH263Cap->slowCifMPI = FALSE; + pH263Cap->slowCif4MPI = FALSE; + pH263Cap->slowCif16MPI = FALSE; + pH263Cap->errorCompensation = FALSE; + return pVideo; +} + +struct H245AudioCapability* ooCapabilityCreateGSMFullRateCapability + (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir) +{ + H245AudioCapability *pAudio=NULL; + H245GSMAudioCapability *pGSMCap=NULL; + if(!epCap || !epCap->params) + { + OOTRACEERR1("Error:Invalid capability parameters to " + "ooCapabilityCreateGSMFullRateCapability.\n"); + return NULL; + } + + pAudio = (H245AudioCapability*)memAlloc(pctxt, + sizeof(H245AudioCapability)); + pGSMCap = (H245GSMAudioCapability*)memAlloc(pctxt, + sizeof(H245GSMAudioCapability)); + if(!pAudio || !pGSMCap) + { + OOTRACEERR1("ERROR:Memory - ooCapabilityCreateGSMFullRateCapability - " + "pAudio/pGSMCap\n"); + return NULL; + } + + pAudio->t = T_H245AudioCapability_gsmFullRate; + pAudio->u.gsmFullRate = pGSMCap; + if(dir & OORX) + pGSMCap->audioUnitSize = ((OOGSMCapParams*)epCap->params)->rxframes*OO_GSMFRAMESIZE; + else + pGSMCap->audioUnitSize = ((OOGSMCapParams*)epCap->params)->txframes*OO_GSMFRAMESIZE; + + pGSMCap->comfortNoise = ((OOGSMCapParams*)epCap->params)->comfortNoise; + pGSMCap->scrambled = ((OOGSMCapParams*)epCap->params)->scrambled; + + return pAudio; +} + +/* This is used for g711 ulaw/alaw, g728, g729, g729A, g7231*/ +struct H245AudioCapability* ooCapabilityCreateSimpleCapability + (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir) +{ + H245AudioCapability *pAudio=NULL; + OOCapParams *params; + if(!epCap || !epCap->params) + { + OOTRACEERR1("Error:Invalid capability parameters to " + "ooCapabilityCreateSimpleCapability.\n"); + return NULL; + } + params =(OOCapParams*)epCap->params; + pAudio = (H245AudioCapability*)memAlloc(pctxt, + sizeof(H245AudioCapability)); + if(!pAudio) + { + OOTRACEERR1("ERROR:Memory - ooCapabilityCreateSimpleCapability - pAudio\n"); + return NULL; + } + + + switch(epCap->cap) + { + case OO_G711ALAW64K: + pAudio->t = T_H245AudioCapability_g711Alaw64k; + if(dir & OORX) + pAudio->u.g711Alaw64k = params->rxframes; + else + pAudio->u.g711Alaw64k = params->txframes; + return pAudio; + case OO_G711ALAW56K: + pAudio->t = T_H245AudioCapability_g711Alaw56k; + if(dir & OORX) + pAudio->u.g711Alaw56k = params->rxframes; + else + pAudio->u.g711Alaw56k = params->txframes; + return pAudio; + case OO_G711ULAW64K: + pAudio->t = T_H245AudioCapability_g711Ulaw64k; + if(dir & OORX) + pAudio->u.g711Ulaw64k = params->rxframes; + else + pAudio->u.g711Ulaw64k = params->txframes; + return pAudio; + case OO_G711ULAW56K: + pAudio->t = T_H245AudioCapability_g711Ulaw56k; + if(dir & OORX) + pAudio->u.g711Ulaw56k = params->rxframes; + else + pAudio->u.g711Ulaw64k = params->txframes; + return pAudio; + /*case OO_G726: + pAudio->t = T_H245AudioCapability_g726; + if(dir & OORX) + pAudio->u.g726 = params->rxframes; + else + pAudio->u.g726 = params->txframes; + return pAudio;*/ + case OO_G728: + pAudio->t = T_H245AudioCapability_g728; + if(dir & OORX) + pAudio->u.g728 = params->rxframes; + else + pAudio->u.g728 = params->txframes; + return pAudio; + case OO_G729: + pAudio->t = T_H245AudioCapability_g729; + if(dir & OORX) + pAudio->u.g729 = params->rxframes; + else + pAudio->u.g729 = params->txframes; + return pAudio; + case OO_G729A: + pAudio->t = T_H245AudioCapability_g729AnnexA; + if(dir & OORX) + pAudio->u.g729AnnexA = params->rxframes; + else + pAudio->u.g729AnnexA = params->txframes; + return pAudio; + case OO_G7231: + pAudio->t = T_H245AudioCapability_g7231; + pAudio->u.g7231 = (H245AudioCapability_g7231*)memAlloc(pctxt, + sizeof(H245AudioCapability_g7231)); + if(!pAudio->u.g7231) + { + OOTRACEERR1("Error:Memory - ooCapabilityCreateSimpleCapability - g7231\n"); + memFreePtr(pctxt, pAudio); + return NULL; + } + pAudio->u.g7231->silenceSuppression = params->silenceSuppression; + if(dir & OORX) + pAudio->u.g7231->maxAl_sduAudioFrames = params->rxframes; + else + pAudio->u.g7231->maxAl_sduAudioFrames = params->txframes; + return pAudio; + + default: + OOTRACEERR2("ERROR: Don't know how to create audio capability %d\n", + epCap->cap); + } + return NULL; +} + +/* Used for g711 ulaw/alaw, g728, g729, g729a, g7231 */ +ASN1BOOL ooCapabilityCheckCompatibility_Simple + (OOH323CallData *call, ooH323EpCapability* epCap, + H245AudioCapability* audioCap, int dir) +{ + int noofframes=0, cap; + + OOTRACEDBGC2("Comparing channel with codec type: %d\n", audioCap->t); + + switch(audioCap->t) + { + case T_H245AudioCapability_g711Ulaw56k: + cap = OO_G711ULAW56K; + noofframes = audioCap->u.g711Ulaw56k; + break; + case T_H245AudioCapability_g711Ulaw64k: + cap = OO_G711ULAW64K; + noofframes = audioCap->u.g711Ulaw64k; + break; + case T_H245AudioCapability_g711Alaw64k: + cap = OO_G711ALAW64K; + noofframes = audioCap->u.g711Alaw64k; + break; + case T_H245AudioCapability_g711Alaw56k: + cap = OO_G711ALAW56K; + noofframes = audioCap->u.g711Alaw56k; + break; + /*case T_H245AudioCapability_g726: + cap = OO_G726; + noofframes = audioCap->u.g726; + break;*/ + case T_H245AudioCapability_g728: + cap = OO_G728; + noofframes = audioCap->u.g728; + break; + case T_H245AudioCapability_g729: + cap = OO_G729; + noofframes = audioCap->u.g729; + break; + case T_H245AudioCapability_g729AnnexA: + cap = OO_G729A; + noofframes = audioCap->u.g729AnnexA; + break; + case T_H245AudioCapability_g7231: + cap = OO_G7231; + noofframes = audioCap->u.g7231->maxAl_sduAudioFrames; + break; + default: + return FALSE; + } + + OOTRACEDBGC3("Comparing codecs: current=%d, requested=%d\n", + epCap->cap, cap); + if(cap != epCap->cap) { return FALSE; } + + /* Can we receive this capability */ + if(dir & OORX) + { + OOTRACEDBGC3("Comparing RX frame rate: channel's=%d, requested=%d\n", + ((OOCapParams*)epCap->params)->rxframes, noofframes); + if(((OOCapParams*)epCap->params)->rxframes >= noofframes) { + return TRUE; + } + //else { + // not supported, as already told other ep our max. receive rate + // our ep can't receive more rate than it + // return FALSE; + //} + } + + /* Can we transmit compatible stream */ + if(dir & OOTX) + { + OOTRACEDBGC3("Comparing TX frame rate: channel's=%d, requested=%d\n", + ((OOCapParams*)epCap->params)->txframes, noofframes); + if(((OOCapParams*)epCap->params)->txframes <= noofframes) { + return TRUE; + } + //else { + // TODO: reduce our ep transmission rate, as peer EP has low receive + // cap, than return TRUE + //} + } + return FALSE; + +} + + +OOBOOL ooCapabilityCheckCompatibility_GSM + (OOH323CallData *call, ooH323EpCapability* epCap, + H245AudioCapability* audioCap, int dir) +{ + unsigned noofframes=0, cap; + switch(audioCap->t) + { + case T_H245AudioCapability_gsmFullRate: + cap = OO_GSMFULLRATE; + noofframes = (audioCap->u.gsmFullRate->audioUnitSize)/OO_GSMFRAMESIZE; + break; + case T_H245AudioCapability_gsmHalfRate: + cap = OO_GSMHALFRATE; + noofframes = (audioCap->u.gsmHalfRate->audioUnitSize)/OO_GSMFRAMESIZE; + break; + case T_H245AudioCapability_gsmEnhancedFullRate: + cap = OO_GSMENHANCEDFULLRATE; + noofframes = (audioCap->u.gsmEnhancedFullRate->audioUnitSize)/OO_GSMFRAMESIZE; + break; + default: + return FALSE; + } + + /* can we receive this capability */ + if(dir & OORX) + { + if(((OOGSMCapParams*)epCap->params)->rxframes >= noofframes) + return TRUE; + } + + /* Make sure we transmit compatible stream */ + if(dir & OOTX) + { + if(((OOGSMCapParams*)epCap->params)->txframes > noofframes){ + OOTRACEDBGA5("Reducing txframes for GSM from %d to %d to match " + "receive capability of remote end.(%s, %s)\n", + ((OOGSMCapParams*)epCap->params)->txframes, noofframes, + call->callType, call->callToken); + ((OOGSMCapParams*)epCap->params)->txframes = noofframes; + } + return TRUE; + } + return FALSE; + +} + + +OOBOOL ooCapabilityCheckCompatibility_H263Video + (struct OOH323CallData *call, ooH323EpCapability *epCap, + H245VideoCapability *pVideoCap, int dir) +{ + H245H263VideoCapability *pH263Cap = NULL; + + OOH263CapParams *params = epCap->params; + if(!pVideoCap->u.h263VideoCapability) + { + OOTRACEERR3("Error:No H263 video capability present in video capability" + "structure. (%s, %s)\n", call->callType, call->callToken); + return FALSE; + } + pH263Cap = pVideoCap->u.h263VideoCapability; + + /* can we receive/transmit this capability */ + if(OORX & dir) + { + if(pH263Cap->m.sqcifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_SQCIF) + { + return FALSE; + } + else{ + if(pH263Cap->sqcifMPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.qcifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_QCIF) + { + return FALSE; + } + else{ + if(pH263Cap->qcifMPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF) + { + return FALSE; + } + else{ + if(pH263Cap->cifMPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cif4MPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF4) + { + return FALSE; + } + else{ + if(pH263Cap->cif4MPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cif16MPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF16) + { + return FALSE; + } + else{ + if(pH263Cap->cif16MPI >= params->MPI) + return TRUE; + else + return FALSE; + } + } + } + + /* Can we transmit */ + if(OOTX & dir) + { + if(pH263Cap->m.sqcifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_SQCIF) + { + return FALSE; + } + else{ + if(pH263Cap->sqcifMPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.qcifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_QCIF) + { + return FALSE; + } + else{ + if(pH263Cap->qcifMPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cifMPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF) + { + return FALSE; + } + else{ + if(pH263Cap->cifMPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cif4MPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF4) + { + return FALSE; + } + else{ + if(pH263Cap->cif4MPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + if(pH263Cap->m.cif16MPIPresent) + { + if(params->picFormat != OO_PICFORMAT_CIF16) + { + return FALSE; + } + else{ + if(pH263Cap->cif16MPI <= params->MPI) + return TRUE; + else + return FALSE; + } + } + } + + return FALSE; + +} + + +OOBOOL ooCapabilityCheckCompatibility_Audio + (OOH323CallData *call, ooH323EpCapability* epCap, + H245AudioCapability* audioCap, int dir) +{ + + switch(audioCap->t) + { + case T_H245AudioCapability_g711Ulaw56k: + case T_H245AudioCapability_g711Ulaw64k: + case T_H245AudioCapability_g711Alaw64k: + case T_H245AudioCapability_g711Alaw56k: + /*case T_H245AudioCapability_g726:*/ + case T_H245AudioCapability_g728: + case T_H245AudioCapability_g729: + case T_H245AudioCapability_g729AnnexA: + case T_H245AudioCapability_g7231: + return ooCapabilityCheckCompatibility_Simple(call, epCap, audioCap, dir); + case T_H245AudioCapability_gsmFullRate: + return ooCapabilityCheckCompatibility_GSM(call, epCap, audioCap, dir); + default: + return FALSE; + } + + return FALSE; +} + +OOBOOL ooCapabilityCheckCompatibility_Video + (OOH323CallData *call, ooH323EpCapability* epCap, + H245VideoCapability* videoCap, int dir) +{ + switch(videoCap->t) + { + case T_H245VideoCapability_h263VideoCapability: + return ooCapabilityCheckCompatibility_H263Video(call, epCap, + videoCap, dir); + default: + OOTRACEDBGC3("ooCapabilityCheckCompatibility_Video - Unsupported video " + "capability. (%s, %s)\n", call->callType, call->callToken); + } + return FALSE; +} +/* + Note: In faststart if we sent transmit rate (x>y) and remote + can receive only y, then we can't reduce our transmit rate +*/ +OOBOOL ooCapabilityCheckCompatibility + (struct OOH323CallData *call, ooH323EpCapability* epCap, + H245DataType* dataType, int dir) +{ + switch(dataType->t) + { + case T_H245DataType_audioData: + if(epCap->capType == OO_CAP_TYPE_AUDIO) + return ooCapabilityCheckCompatibility_Audio(call, epCap, + dataType->u.audioData, dir); + break; + case T_H245DataType_videoData: + if(epCap->capType == OO_CAP_TYPE_VIDEO) + return ooCapabilityCheckCompatibility_Video(call, epCap, + dataType->u.videoData, dir); + break; + case T_H245DataType_data: + default: + OOTRACEDBGC3("ooCapabilityCheckCompatibility - Unsupported " + "capability. (%s, %s)\n", call->callType, call->callToken); + } + + return FALSE; +} + +#if 0 +/** + TODO: If txCap is local and number of txframes is greater than remote can + receive, we should automatically decrease it. And logical channel cap should + be the one where it should be decreased. The start logical channel will + indicate the application that it is supposed to tx and a reduced rate. + */ +ASN1BOOL ooCheckCompatibility + (OOH323CallData *call, ooH323EpCapability *txCap, ooH323EpCapability *rxCap) +{ + + if(txCap->cap != rxCap->cap) return FALSE; + + if(!(txCap->dir & OOTX)) return FALSE; + + if(!(rxCap->dir & OORX)) return FALSE; + + switch(txCap->cap) + { + case OO_G711ALAW64K: + case OO_G711ALAW56K: + case OO_G711ULAW64K: + case OO_G711ULAW56K: + /*case OO_G726:*/ + case OO_G728: + case OO_G729: + case OO_G729A: + case OO_G7231: + if(((OOCapParams*)txCap->params)->txframes <= + ((OOCapParams*)rxCap->params)->rxframes) + return TRUE; + else{ + OOTRACEDBGA4("Simple caps %s are not compatible.(%s, %s)\n", + ooGetCapTypeText(txCap->cap), call->callType, + call->callToken); + return FALSE; + } + case OO_GSMFULLRATE: + case OO_GSMHALFRATE: + case OO_GSMENHANCEDFULLRATE: + if(((OOGSMCapParams*)txCap->params)->txframes <= + ((OOGSMCapParams*)rxCap->params)->rxframes) + return TRUE; + else{ + OOTRACEDBGA3("GSM caps are not compatible. (%s, %s)\n", call->callType, + call->callToken); + return FALSE; + } + default: + OOTRACEWARN3("WARN: Unsupported capabilities being compared. (%s, %s)\n", + call->callType, call->callToken); + } + return FALSE; + +} + +#endif + +ooH323EpCapability* ooIsAudioDataTypeGSMSupported + (OOH323CallData *call, H245AudioCapability* audioCap, int dir) +{ + unsigned framesPerPkt=0; + int cap=0; + ooH323EpCapability *cur = NULL, *epCap=NULL; + OOGSMCapParams *params = NULL; + + switch(audioCap->t) + { + case T_H245AudioCapability_gsmFullRate: + framesPerPkt = (audioCap->u.gsmFullRate->audioUnitSize)/OO_GSMFRAMESIZE; + cap = OO_GSMFULLRATE; + break; + case T_H245AudioCapability_gsmHalfRate: + framesPerPkt = (audioCap->u.gsmHalfRate->audioUnitSize)/OO_GSMFRAMESIZE; + cap = OO_GSMHALFRATE; + break; + case T_H245AudioCapability_gsmEnhancedFullRate: + framesPerPkt = (audioCap->u.gsmEnhancedFullRate->audioUnitSize)/OO_GSMFRAMESIZE; + cap = OO_GSMENHANCEDFULLRATE; + break; + default: + OOTRACEERR3("Error:Invalid GSM capability type.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + } + + OOTRACEDBGC4("Determined audio data type to be of type %d. Searching" + " for matching capability.(%s, %s)\n", cap, call->callType, + call->callToken); + + /* If we have call specific caps then we use them, otherwise we use + general endpoint caps*/ + if(call->ourCaps) + cur = call->ourCaps; + else + cur = gH323ep.myCaps; + + while(cur) + { + OOTRACEDBGC4("Local cap being compared %d. (%s, %s)\n", cur->cap, + call->callType, call->callToken); + + if(cur->cap == cap && (cur->dir & dir)) + break; + cur = cur->next; + } + + if(!cur) return NULL; + + OOTRACEDBGC4("Found matching audio capability type %d. Comparing" + " other parameters. (%s, %s)\n", cap, call->callType, + call->callToken); + + /* can we receive this capability */ + if(dir & OORX) + { + if(((OOGSMCapParams*)cur->params)->rxframes < framesPerPkt) + return NULL; + else{ + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params =(OOGSMCapParams*)memAlloc(call->pctxt,sizeof(OOGSMCapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsAudioDataTypeGSMSupported - " + "epCap/params (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOGSMCapParams)); + return epCap; + } + } + + /* Can we transmit compatible stream */ + if(dir & OOTX) + { + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params =(OOGSMCapParams*)memAlloc(call->pctxt,sizeof(OOGSMCapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsAudioDataTypeGSMSupported - " + "epCap/params (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOGSMCapParams)); + if(params->txframes > framesPerPkt) + { + OOTRACEINFO5("Reducing framesPerPkt for transmission of GSM " + "capability from %d to %d to match receive capability of" + " remote endpoint.(%s, %s)\n", params->txframes, + framesPerPkt, call->callType, call->callToken); + params->txframes = framesPerPkt; + } + + return epCap; + + } + return NULL; + +} + +/* used for g711 ulaw/alaw, g728, g729, g729a, g7231 */ +ooH323EpCapability* ooIsAudioDataTypeSimpleSupported + (OOH323CallData *call, H245AudioCapability* audioCap, int dir) +{ + int cap, framesPerPkt=0; + ooH323EpCapability *cur=NULL, *epCap=NULL; + OOCapParams * params= NULL; + + /* Find similar capability */ + switch(audioCap->t) + { + case T_H245AudioCapability_g711Alaw64k: + framesPerPkt = audioCap->u.g711Alaw64k; + cap = OO_G711ALAW64K; + break; + case T_H245AudioCapability_g711Alaw56k: + framesPerPkt = audioCap->u.g711Alaw56k; + cap = OO_G711ALAW56K; + break; + case T_H245AudioCapability_g711Ulaw56k: + framesPerPkt = audioCap->u.g711Ulaw56k; + cap = OO_G711ULAW56K; + break; + case T_H245AudioCapability_g711Ulaw64k: + framesPerPkt = audioCap->u.g711Ulaw64k; + cap = OO_G711ULAW64K; + break; + +/* case T_H245AudioCapability_g726: + framesPerPkt = audioCap->u.g726; + cap = OO_G726; + break; +*/ + case T_H245AudioCapability_g728: + framesPerPkt = audioCap->u.g728; + cap = OO_G728; + break; + + case T_H245AudioCapability_g729: + framesPerPkt = audioCap->u.g729; + cap = OO_G729; + break; + case T_H245AudioCapability_g729AnnexA: + framesPerPkt = audioCap->u.g729AnnexA; + cap = OO_G729A; + break; + case T_H245AudioCapability_g7231: + framesPerPkt = audioCap->u.g7231->maxAl_sduAudioFrames; + cap = OO_G7231; + break; + default: + return NULL; + } + + OOTRACEDBGC4("Determined Simple audio data type to be of type %s. Searching" + " for matching capability.(%s, %s)\n", + ooGetCapTypeText(cap), call->callType, call->callToken); + + /* If we have call specific caps, we use them; otherwise use general + endpoint caps + */ + if(call->ourCaps) + cur = call->ourCaps; + else + cur = gH323ep.myCaps; + + while(cur) + { + OOTRACEDBGC4("Local cap being compared %s. (%s, %s)\n", + ooGetCapTypeText(cur->cap),call->callType, call->callToken); + + if(cur->cap == cap && (cur->dir & dir)) + break; + cur = cur->next; + } + + if(!cur) return NULL; + + OOTRACEDBGC4("Found matching simple audio capability type %s. Comparing" + " other parameters. (%s, %s)\n", ooGetCapTypeText(cap), + call->callType, call->callToken); + + /* can we receive this capability */ + if(dir & OORX) + { + if(((OOCapParams*)cur->params)->rxframes < framesPerPkt) + return NULL; + else{ + OOTRACEDBGC4("We can receive Simple capability %s. (%s, %s)\n", + ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params=(OOCapParams*)memAlloc(call->pctxt,sizeof(OOCapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsAudioDataTypeSimpleSupported - " + "epCap/params (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOCapParams)); + OOTRACEDBGC4("Returning copy of matched receive capability %s. " + "(%s, %s)\n", + ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + return epCap; + } + } + + /* Can we transmit compatible stream */ + if(dir & OOTX) + { + OOTRACEDBGC4("We can transmit Simple capability %s. (%s, %s)\n", + ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params =(OOCapParams*)memAlloc(call->pctxt,sizeof(OOCapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsAudioDataTypeSimpleSupported - " + "epCap/params (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOCapParams)); + if(params->txframes > framesPerPkt) + { + OOTRACEINFO5("Reducing framesPerPkt for transmission of Simple " + "capability from %d to %d to match receive capability of" + " remote endpoint.(%s, %s)\n", params->txframes, + framesPerPkt, call->callType, call->callToken); + params->txframes = framesPerPkt; + } + OOTRACEDBGC4("Returning copy of matched transmit capability %s." + "(%s, %s)\n", + ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + return epCap; + } + return NULL; +} + + + +ooH323EpCapability* ooIsAudioDataTypeSupported + (OOH323CallData *call, H245AudioCapability* audioCap, int dir) +{ + /* Find similar capability */ + switch(audioCap->t) + { + case T_H245AudioCapability_g711Alaw64k: + case T_H245AudioCapability_g711Alaw56k: + case T_H245AudioCapability_g711Ulaw56k: + case T_H245AudioCapability_g711Ulaw64k: + /*case T_H245AudioCapability_g726:*/ + case T_H245AudioCapability_g728: + case T_H245AudioCapability_g729: + case T_H245AudioCapability_g729AnnexA: + case T_H245AudioCapability_g7231: + return ooIsAudioDataTypeSimpleSupported(call, audioCap, dir); + case T_H245AudioCapability_gsmFullRate: + case T_H245AudioCapability_gsmHalfRate: + case T_H245AudioCapability_gsmEnhancedFullRate: + return ooIsAudioDataTypeGSMSupported(call, audioCap, dir); + default: + return NULL; + } +} + + +ooH323EpCapability* ooIsVideoDataTypeH263Supported + (OOH323CallData *call, H245H263VideoCapability* pH263Cap, int dir, + OOPictureFormat picFormat) +{ + int cap; + ooH323EpCapability *cur=NULL, *epCap=NULL; + OOH263CapParams *params= NULL; + char *pictureType=NULL; + unsigned mpi=0; + cap = OO_H263VIDEO; + + if(picFormat == OO_PICFORMAT_SQCIF && pH263Cap->m.sqcifMPIPresent) + { + pictureType = "SQCIF"; + mpi = pH263Cap->sqcifMPI; + } + if(picFormat == OO_PICFORMAT_QCIF && pH263Cap->m.qcifMPIPresent) + { + pictureType = "QCIF"; + mpi = pH263Cap->qcifMPI; + } + if(picFormat == OO_PICFORMAT_CIF && pH263Cap->m.cifMPIPresent) + { + pictureType = "CIF"; + mpi = pH263Cap->cifMPI; + } + if(picFormat == OO_PICFORMAT_CIF4 && pH263Cap->m.cif4MPIPresent) + { + pictureType = "CIF4"; + mpi = pH263Cap->cif4MPI; + } + if(picFormat == OO_PICFORMAT_CIF16 && pH263Cap->m.cif16MPIPresent) + { + pictureType = "CIF16"; + mpi = pH263Cap->cif16MPI; + } + + + OOTRACEDBGA4("Looking for H263 video capability(%s). (%s, %s)\n", + pictureType, call->callType, call->callToken); + + /* If we have call specific caps, we use them; otherwise use general + endpoint caps + */ + if(call->ourCaps) + cur = call->ourCaps; + else + cur = gH323ep.myCaps; + + while(cur) + { + OOTRACEDBGC4("Local cap being compared %s. (%s, %s)\n", + ooGetCapTypeText(cur->cap),call->callType, call->callToken); + + if(cur->cap == cap && (cur->dir & dir)) + { + if(((OOH263CapParams*)cur->params)->picFormat == picFormat) + break; + } + cur = cur->next; + } + + if(!cur) return NULL; + + OOTRACEDBGC4("Found matching H.263 video capability type %s. Comparing" + " other parameters. (%s, %s)\n", ooGetCapTypeText(cap), + call->callType, call->callToken); + if(dir & OORX) + { + if(mpi < ((OOH263CapParams*)cur->params)->MPI) + return NULL; + else{ + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params = (OOH263CapParams*) memAlloc(call->pctxt, + sizeof(OOH263CapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsVideoDataTypeH263Supported - " + "epCap/params. (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOH263CapParams)); + OOTRACEDBGC4("Returning copy of matched receive capability %s. " + "(%s, %s)\n", ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + return epCap; + } + } + if(dir & OOTX) + { + epCap = (ooH323EpCapability*)memAlloc(call->pctxt, + sizeof(ooH323EpCapability)); + params = (OOH263CapParams*) memAlloc(call->pctxt, + sizeof(OOH263CapParams)); + if(!epCap || !params) + { + OOTRACEERR3("Error:Memory - ooIsVideoDataTypeH263Supported - " + "epCap/params. (%s, %s)\n", call->callType, + call->callToken); + return NULL; + } + epCap->params = params; + epCap->cap = cur->cap; + epCap->dir = cur->dir; + epCap->capType = cur->capType; + epCap->startReceiveChannel = cur->startReceiveChannel; + epCap->startTransmitChannel= cur->startTransmitChannel; + epCap->stopReceiveChannel = cur->stopReceiveChannel; + epCap->stopTransmitChannel = cur->stopTransmitChannel; + epCap->next = NULL; + memcpy(epCap->params, cur->params, sizeof(OOH263CapParams)); + if(params->MPI < mpi) + { + OOTRACEINFO5("Increasing minimum picture interval for transmission of" + " H263 video capability from %d to %d to match receive " + "capability of remote endpoint.(%s, %s)\n", params->MPI, + mpi, call->callType, call->callToken); + params->MPI = mpi; + } + OOTRACEDBGC4("Returning copy of matched receive capability %s. " + "(%s, %s)\n", ooGetCapTypeText(cur->cap), call->callType, + call->callToken); + return epCap; + } + return NULL; + +} + +ooH323EpCapability* ooIsVideoDataTypeSupported + (OOH323CallData *call, H245VideoCapability* pVideoCap, int dir) +{ + switch(pVideoCap->t) + { + case T_H245VideoCapability_h263VideoCapability: + if(pVideoCap->u.h263VideoCapability->m.sqcifMPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_SQCIF); + else if(pVideoCap->u.h263VideoCapability->m.qcifMPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_QCIF); + else if(pVideoCap->u.h263VideoCapability->m.cifMPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF); + else if(pVideoCap->u.h263VideoCapability->m.cif4MPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF4); + else if(pVideoCap->u.h263VideoCapability->m.cif16MPIPresent) + return ooIsVideoDataTypeH263Supported(call, + pVideoCap->u.h263VideoCapability, dir, OO_PICFORMAT_CIF16); + break; + case T_H245VideoCapability_nonStandard: + case T_H245VideoCapability_h261VideoCapability: + case T_H245VideoCapability_h262VideoCapability: + case T_H245VideoCapability_is11172VideoCapability: + case T_H245VideoCapability_genericVideoCapability: + case T_H245VideoCapability_extElem1: + default: + OOTRACEDBGA1("Unsupported video capability type in " + "ooIsVideoDataTypeSupported\n"); + return NULL; + } + return NULL; +} + +ooH323EpCapability* ooIsDataTypeSupported + (OOH323CallData *call, H245DataType *data, int dir) +{ + OOTRACEDBGC3("Looking for data type support. (%s, %s)\n", call->callType, + call->callToken); + + switch(data->t) + { + case T_H245DataType_nonStandard: + OOTRACEDBGC3("NonStandard data type not supported.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + case T_H245DataType_nullData: + OOTRACEDBGC3("Null data type not supported.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + case T_H245DataType_videoData: + OOTRACEDBGC3("Looking for video dataType support. (%s, %s)\n", + call->callType, call->callToken); + return ooIsVideoDataTypeSupported(call, data->u.videoData, dir); + case T_H245DataType_audioData: + OOTRACEDBGC3("Looking for audio dataType support. (%s, %s)\n", + call->callType, call->callToken); + return ooIsAudioDataTypeSupported(call, data->u.audioData, dir); + case T_H245DataType_data: + OOTRACEDBGC3("Data type not supported.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + case T_H245DataType_encryptionData: + OOTRACEDBGC3("Encryption data type not supported.(%s, %s)\n", + call->callType, call->callToken); + return NULL; + case T_H245DataType_h235Control: + return NULL; + case T_H245DataType_h235Media: + return NULL; + case T_H245DataType_multiplexedStream: + return NULL; + default: + OOTRACEINFO3("Unknown data type (%s, %s)\n", call->callType, + call->callToken); + } + return NULL; +} + +int ooResetCapPrefs(OOH323CallData *call) +{ + OOCapPrefs *capPrefs=NULL; + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + memset(capPrefs, 0, sizeof(OOCapPrefs)); + return OO_OK; +} + +int ooRemoveCapFromCapPrefs(OOH323CallData *call, int cap) +{ + int i=0, j=0; + OOCapPrefs *capPrefs=NULL, oldPrefs; + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + + memcpy(&oldPrefs, capPrefs, sizeof(OOCapPrefs)); + memset(capPrefs, 0, sizeof(OOCapPrefs)); + for(i=0; iorder[j++] = oldPrefs.order[i]; + } + capPrefs->index = j; + return OO_OK; +} + + +int ooAppendCapToCapPrefs(OOH323CallData *call, int cap) +{ + OOCapPrefs *capPrefs=NULL; + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + + capPrefs->order[capPrefs->index++] = cap; + return OO_OK; +} + +int ooChangeCapPrefOrder(OOH323CallData *call, int cap, int pos) +{ + int i=0, j=0; + OOCapPrefs *capPrefs = NULL; + + /* Whether to change prefs for call or for endpoint as a whole */ + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + + /* check whether cap exists, cap must exist */ + for(i=0; iindex; i++) + { + if(capPrefs->order[i] == cap) + break; + } + if(i == capPrefs->index) return OO_FAILED; + + if(i==pos) return OO_OK; /* No need to change */ + + /* Decrease Pref order */ + if(i < pos) + { + for( ; iorder[i] = capPrefs->order[i+1]; + capPrefs->order[i]=cap; + return OO_OK; + } + /* Increase Pref order */ + if(i>pos) + { + for(j=i; j>pos; j--) + capPrefs->order[j] = capPrefs->order[j-1]; + capPrefs->order[j] = cap; + return OO_OK; + } + + return OO_FAILED; + +} + +int ooPreppendCapToCapPrefs(OOH323CallData *call, int cap) +{ + int i=0, j=0; + OOCapPrefs *capPrefs=NULL, oldPrefs; + if(call) + capPrefs = &call->capPrefs; + else + capPrefs = &gH323ep.capPrefs; + + memcpy(&oldPrefs, capPrefs, sizeof(OOCapPrefs)); + + + capPrefs->order[j++] = cap; + + for(i=0; iorder[j++] = oldPrefs.order[i]; + } + capPrefs->index = j; + return OO_OK; +} + + +int ooAddRemoteCapability(OOH323CallData *call, H245Capability *cap) +{ + switch(cap->t) + { + case T_H245Capability_receiveAudioCapability: + return ooAddRemoteAudioCapability(call, cap->u.receiveAudioCapability, + OORX); + case T_H245Capability_transmitAudioCapability: + return ooAddRemoteAudioCapability(call, cap->u.transmitAudioCapability, + OOTX); + case T_H245Capability_receiveAndTransmitAudioCapability: + return ooAddRemoteAudioCapability(call, + cap->u.receiveAndTransmitAudioCapability, OORXTX); + default: + OOTRACEDBGA3("Unsupported cap type encountered. Ignoring. (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooAddRemoteAudioCapability(OOH323CallData *call, + H245AudioCapability *audioCap, + int dir) +{ + int rxframes=0, txframes=0; + + switch(audioCap->t) + { + case T_H245AudioCapability_g711Alaw64k: + if(dir&OOTX) txframes = audioCap->u.g711Alaw64k; + else if(dir&OORX) rxframes = audioCap->u.g711Alaw64k; + else{ + txframes = audioCap->u.g711Alaw64k; + rxframes = audioCap->u.g711Alaw64k; + } + return ooCapabilityAddSimpleCapability(call, OO_G711ALAW64K, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL,TRUE); + case T_H245AudioCapability_g711Alaw56k: + if(dir&OOTX) txframes = audioCap->u.g711Alaw56k; + else if(dir&OORX) rxframes = audioCap->u.g711Alaw56k; + else{ + txframes = audioCap->u.g711Alaw56k; + rxframes = audioCap->u.g711Alaw56k; + } + return ooCapabilityAddSimpleCapability(call, OO_G711ALAW56K, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_g711Ulaw64k: + if(dir&OOTX) txframes = audioCap->u.g711Ulaw64k; + else if(dir&OORX) rxframes = audioCap->u.g711Ulaw64k; + else{ + txframes = audioCap->u.g711Ulaw64k; + rxframes = audioCap->u.g711Ulaw64k; + } + return ooCapabilityAddSimpleCapability(call, OO_G711ULAW64K, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_g711Ulaw56k: + if(dir&OOTX) txframes = audioCap->u.g711Ulaw56k; + else if(dir&OORX) rxframes = audioCap->u.g711Ulaw56k; + else{ + txframes = audioCap->u.g711Ulaw56k; + rxframes = audioCap->u.g711Ulaw56k; + } + return ooCapabilityAddSimpleCapability(call, OO_G711ULAW56K, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + +/* case T_H245AudioCapability_g726: + if(dir&OOTX) txframes = audioCap->u.g726; + else if(dir&OORX) rxframes = audioCap->u.g726; + else{ + txframes = audioCap->u.g726; + rxframes = audioCap->u.g726; + } + return ooCapabilityAddSimpleCapability(call, OO_G726, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); +*/ + case T_H245AudioCapability_g728: + if(dir&OOTX) txframes = audioCap->u.g728; + else if(dir&OORX) rxframes = audioCap->u.g728; + else{ + txframes = audioCap->u.g728; + rxframes = audioCap->u.g728; + } + return ooCapabilityAddSimpleCapability(call, OO_G728, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + + case T_H245AudioCapability_g729: + if(dir&OOTX) txframes = audioCap->u.g729; + else if(dir&OORX) rxframes = audioCap->u.g729; + else{ + txframes = audioCap->u.g729; + rxframes = audioCap->u.g729; + } + return ooCapabilityAddSimpleCapability(call, OO_G729, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + + case T_H245AudioCapability_g729AnnexA: + if(dir&OOTX) txframes = audioCap->u.g729AnnexA; + else if(dir&OORX) rxframes = audioCap->u.g729AnnexA; + else{ + txframes = audioCap->u.g729AnnexA; + rxframes = audioCap->u.g729AnnexA; + } + return ooCapabilityAddSimpleCapability(call, OO_G729A, txframes, + rxframes, FALSE, dir, NULL, NULL, NULL, NULL, TRUE); + + case T_H245AudioCapability_g7231: + if(dir&OOTX) txframes = audioCap->u.g7231->maxAl_sduAudioFrames; + else if(dir&OORX) rxframes = audioCap->u.g7231->maxAl_sduAudioFrames; + else{ + txframes = audioCap->u.g7231->maxAl_sduAudioFrames; + rxframes = audioCap->u.g7231->maxAl_sduAudioFrames; + } + return ooCapabilityAddSimpleCapability(call, OO_G7231, txframes,rxframes, + audioCap->u.g7231->silenceSuppression, + dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_gsmFullRate: + return ooCapabilityAddGSMCapability(call, OO_GSMFULLRATE, + (unsigned)(audioCap->u.gsmFullRate->audioUnitSize/OO_GSMFRAMESIZE), + audioCap->u.gsmFullRate->comfortNoise, + audioCap->u.gsmFullRate->scrambled, + dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_gsmHalfRate: + return ooCapabilityAddGSMCapability(call, OO_GSMHALFRATE, + (unsigned)(audioCap->u.gsmHalfRate->audioUnitSize/OO_GSMFRAMESIZE), + audioCap->u.gsmHalfRate->comfortNoise, + audioCap->u.gsmHalfRate->scrambled, + dir, NULL, NULL, NULL, NULL, TRUE); + case T_H245AudioCapability_gsmEnhancedFullRate: + return ooCapabilityAddGSMCapability(call, OO_GSMENHANCEDFULLRATE, + (unsigned)(audioCap->u.gsmEnhancedFullRate->audioUnitSize/OO_GSMFRAMESIZE), + audioCap->u.gsmEnhancedFullRate->comfortNoise, + audioCap->u.gsmEnhancedFullRate->scrambled, + dir, NULL, NULL, NULL, NULL, TRUE); + + default: + OOTRACEDBGA1("Unsupported audio capability type\n"); + + } + + return OO_OK; +} + + + + + +int ooCapabilityUpdateJointCapabilities + (OOH323CallData* call, H245Capability *cap) +{ + ooH323EpCapability * epCap = NULL, *cur = NULL; + OOTRACEDBGC3("checking whether we need to add cap to joint capabilities" + "(%s, %s)\n", call->callType, call->callToken); + + switch(cap->t) + { + case T_H245Capability_receiveAudioCapability: + epCap= ooIsAudioDataTypeSupported(call, cap->u.receiveAudioCapability, + OOTX); + break; + case T_H245Capability_transmitAudioCapability: + epCap = ooIsAudioDataTypeSupported(call, cap->u.transmitAudioCapability, + OORX); + break; + case T_H245Capability_receiveAndTransmitAudioCapability: + epCap = NULL; + break; + case T_H245Capability_receiveVideoCapability: + return ooCapabilityUpdateJointCapabilitiesVideo(call, + cap->u.receiveVideoCapability, OOTX); + case T_H245Capability_transmitVideoCapability: + return ooCapabilityUpdateJointCapabilitiesVideo(call, + cap->u.transmitVideoCapability, OORX); + case T_H245Capability_receiveUserInputCapability: + if((cap->u.receiveUserInputCapability->t == + T_H245UserInputCapability_basicString) && + (call->dtmfmode & OO_CAP_DTMF_H245_alphanumeric)) + { + call->jointDtmfMode |= OO_CAP_DTMF_H245_alphanumeric; + return OO_OK; + } + else if((cap->u.receiveUserInputCapability->t == + T_H245UserInputCapability_dtmf) && + (call->dtmfmode & OO_CAP_DTMF_H245_signal)) + { + call->jointDtmfMode |= OO_CAP_DTMF_H245_signal; + return OO_OK; + } + //break; + default: + OOTRACEDBGA3("Unsupported cap type encountered. Ignoring. (%s, %s)\n", + call->callType, call->callToken); + } + + if(epCap) + { + OOTRACEDBGC3("Adding cap to joint capabilities(%s, %s)\n",call->callType, + call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + return OO_OK; + } + + OOTRACEDBGC3("Not adding to joint capabilities. (%s, %s)\n", call->callType, + call->callToken); + return OO_OK; +} + + + +int ooCapabilityUpdateJointCapabilitiesVideo + (OOH323CallData *call, H245VideoCapability *videoCap, int dir) +{ + switch(videoCap->t) + { + case T_H245VideoCapability_h263VideoCapability: + return ooCapabilityUpdateJointCapabilitiesVideoH263(call, + videoCap->u.h263VideoCapability, dir); + default: + OOTRACEDBGC3("ooCapabilityUpdateJointCapabilitiesVideo - Unsupported" + "capability type. (%s, %s)\n", call->callType, + call->callToken); + } + return OO_OK; +} + + +int ooCapabilityUpdateJointCapabilitiesVideoH263 + (OOH323CallData *call, H245H263VideoCapability *pH263Cap, int dir) +{ + ooH323EpCapability *epCap = NULL, *cur = NULL; + if(pH263Cap->m.sqcifMPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_SQCIF); + if(epCap) + { + OOTRACEDBGC3("Adding H263-SQCIF to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + } + } + + epCap = NULL; + + if(pH263Cap->m.qcifMPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_QCIF); + if(epCap) + { + OOTRACEDBGC3("Adding H263-QCIF to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + } + } + + epCap = NULL; + + if(pH263Cap->m.cifMPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_CIF); + if(epCap) + { + OOTRACEDBGC3("Adding H263-CIF to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + } + } + + epCap = NULL; + + if(pH263Cap->m.cif4MPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_CIF4); + if(epCap) + { + OOTRACEDBGC3("Adding H263-CIF4 to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + } + } + + epCap = NULL; + + if(pH263Cap->m.cif16MPIPresent) + { + epCap = ooIsVideoDataTypeH263Supported(call, pH263Cap, dir, + OO_PICFORMAT_CIF16); + if(epCap) + { + OOTRACEDBGC3("Adding H263-CIF16 to joint capabilities(%s, %s)\n", + call->callType, call->callToken); + /* Note:we add jointCaps in remote endpoints preference order.*/ + if(!call->jointCaps) + call->jointCaps = epCap; + else { + cur = call->jointCaps; + while(cur->next) cur = cur->next; + cur->next = epCap; + } + + } + } + + return OO_OK; +} + +const char* ooGetCapTypeText (OOCapabilities cap) +{ + static const char *capTypes[]={ + "unknown", + "OO_NONSTANDARD", + "OO_G711ALAW64K", + "OO_G711ALAW56K", + "OO_G711ULAW64K", + "OO_G711ULAW56K", + "OO_G72264K", + "OO_G72256K", + "OO_G72248K", + "OO_G7231", + "OO_G728", + "OO_G729", + "OO_G729ANNEXA", + "OO_IS11172AUDIO", + "OO_IS13818AUDIO", + "OO_G729WANNEXB", + "OO_G729ANNEXAWANNEXB", + "OO_G7231ANNEXC", + "OO_GSMFULLRATE", + "OO_GSMHALFRATE", + "OO_GSMENHANCEDFULLRATE", + "OO_GENERICAUDIO", + "OO_G729EXTENSIONS", + "OO_VBD", + "OO_AUDIOTELEPHONYEVENT", + "OO_AUDIOTONE", + "OO_EXTELEM1", + "OO_VIDEO_BASE", + "OO_NONSTDVIDEO", + "OO_H261VIDEO", + "OO_H262VIDEO", + "OO_H263VIDEO", + "OO_IS11172VIDEO", /* mpeg */ + "OO_GENERICVIDEO", + "OO_EXTELEMVIDEO" + }; + return ooUtilsGetText (cap, capTypes, OONUMBEROF(capTypes)); +} diff --git a/addons/ooh323c/src/ooCapability.h b/addons/ooh323c/src/ooCapability.h new file mode 100644 index 000000000..75d0d563a --- /dev/null +++ b/addons/ooh323c/src/ooCapability.h @@ -0,0 +1,726 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * @file ooCapability.h + * This file contains Capability management functions. + */ +#ifndef OO_CAPABILITY_H_ +#define OO_CAPABILITY_H_ +#include "ootypes.h" +#include "ooasn1.h" + + +#define OO_GSMFRAMESIZE 33 /* standard frame size for gsm is 33 bytes */ + +#define OORX (1<<0) +#define OOTX (1<<1) +#define OORXANDTX (1<<2) +#define OORXTX (1<<3) /* For symmetric capabilities */ +/* Various types of caps. Note that not all + supported */ +typedef enum OOCapabilities{ + OO_CAP_AUDIO_BASE = 0, + OO_G711ALAW64K = 2, + OO_G711ALAW56K = 3, + OO_G711ULAW64K = 4, + OO_G711ULAW56K = 5, + OO_G722_64k = 6, + OO_G722_56k = 7, + OO_G722_48k = 8, + OO_G7231 = 9, + OO_G728 = 10, + OO_G729 = 11, + OO_G729A = 12, + OO_IS11172_AUDIO = 13, + OO_IS13818_AUDIO = 14, + OO_G729B = 15, + OO_G729AB = 16, + OO_G7231C = 17, + OO_GSMFULLRATE = 18, + OO_GSMHALFRATE = 19, + OO_GSMENHANCEDFULLRATE = 20, + OO_GENERICAUDIO = 21, + OO_G729EXT = 22, + OO_AUDIO_VBD = 23, + OO_AUDIOTELEPHONYEVENT = 24, + OO_AUDIO_TONE = 25, + OO_EXTELEM1 = 26, + OO_CAP_VIDEO_BASE = 27, + OO_NONSTDVIDEO = 28, + OO_H261VIDEO = 29, + OO_H262VIDEO = 30, + OO_H263VIDEO = 31, + OO_IS11172VIDEO = 32, /* mpeg */ + OO_GENERICVIDEO = 33, + OO_EXTELEMVIDEO = 34 +} OOCapabilities; + + +/*DTMF capabilities*/ +#define OO_CAP_DTMF_RFC2833 (1<<0) +#define OO_CAP_DTMF_Q931 (1<<1) +#define OO_CAP_DTMF_H245_alphanumeric (1<<2) +#define OO_CAP_DTMF_H245_signal (1<<3) + +/** + * This structure defines the preference order for capabilities. + * + */ +typedef struct OOCapPrefs { + int order[20]; + int index; +}OOCapPrefs; + +typedef struct OOCapParams { + int txframes; /*!< Number of frames per packet for transmission */ + int rxframes; /*!< Number of frames per packet for reception */ + OOBOOL silenceSuppression; +} OOCapParams; + +typedef struct OOGSMCapParams { + unsigned txframes; + unsigned rxframes; + OOBOOL scrambled; + OOBOOL comfortNoise; +} OOGSMCapParams; + +typedef enum OOPictureFormat{ + OO_PICFORMAT_SQCIF, + OO_PICFORMAT_QCIF, + OO_PICFORMAT_CIF, + OO_PICFORMAT_CIF4, + OO_PICFORMAT_CIF16 +}OOPictureFormat; + +typedef struct OOH263CapParams { + enum OOPictureFormat picFormat; /* !< One of sqcif, qcif, cif, cif4, cif16*/ + unsigned MPI; /* !< Minimum Picture Interval */ + unsigned maxBitRate; /* !< Maximum bit rate for transmission/reception in units of 100 bits/sec */ +} OOH263CapParams; + +struct OOH323CallData; +struct OOLogicalChannel; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * This callback is used for starting media receive channel. This callback + * function is triggered when receive media channel has to be started. + * @param call Call for which receive media channel has to be started. + * @param pChannel Channel details. This structure has important information + * such as rtp ip:port and capability describing media type + * to be received. + * @return OO_OK, on success. OO_FAILED, on failure + */ +typedef int (*cb_StartReceiveChannel) + (struct OOH323CallData *call, struct OOLogicalChannel *pChannel); + + +/** + * This callback is used for starting media transmit channel. This callback + * function is triggered when transmit media channel has to be started. + * @param call Call for which transmit media channel has to be started. + * @param pChannel Channel details. This structure has important information + * such as rtp ip:port and capability describing media type + * to be transmitted. + * @return OO_OK, on success. OO_FAILED, on failure + */ +typedef int (*cb_StartTransmitChannel) + (struct OOH323CallData *call, struct OOLogicalChannel *pChannel); + +/** + * This callback is used for stopping media receive channel. This callback + * function is triggered when receive media channel has to be stopped. + * @param call Call for which receive media channel has to be stopped. + * @param pChannel Channel details. This structure has important information + * such as rtp ip:port and capability describing media type + * being received. + * @return OO_OK, on success. OO_FAILED, on failure + */ +typedef int (*cb_StopReceiveChannel) + (struct OOH323CallData *call, struct OOLogicalChannel *pChannel); + +/** + * This callback is used for stopping media transmit channel. This callback + * function is triggered when transmit media channel has to be stopped. + * @param call Call for which transmit media channel has to be stopped. + * @param pChannel Channel details. This structure has important information + * such as rtp ip:port and capability describing media type + * being transmitted. + * @return OO_OK, on success. OO_FAILED, on failure + */ +typedef int (*cb_StopTransmitChannel) + (struct OOH323CallData *call, struct OOLogicalChannel *pChannel); + +typedef enum OOCapType { + OO_CAP_TYPE_AUDIO, + OO_CAP_TYPE_VIDEO, + OO_CAP_TYPE_DATA +} OOCapType; + +/** + * Structure to store information related to end point + * capability + */ +typedef struct ooH323EpCapability { + int dir; + int cap; + OOCapType capType; + void *params; + cb_StartReceiveChannel startReceiveChannel; + cb_StartTransmitChannel startTransmitChannel; + cb_StopReceiveChannel stopReceiveChannel; + cb_StopTransmitChannel stopTransmitChannel; + struct ooH323EpCapability *next; +} ooH323EpCapability; + + + + +#ifndef EXTERN +#if defined (MAKE_DLL) +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +/** + * @defgroup capmgmt Capability Management + * @{ + */ + +/** + * This function is used to add rfc2833 based dtmf detection capability + * @param call Call if enabling for call, else null for + * endpoint. + * @param dynamicRTPPayloadType dynamicRTPPayloadType to be used. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityEnableDTMFRFC2833 + (struct OOH323CallData *call, int dynamicRTPPayloadType); + +/** + * This function is used to remove rfc2833 dtmf detection capability. + * @param call Handle to call, if disabling for the call, else NULL + * for end-point. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityDisableDTMFRFC2833(struct OOH323CallData *call); + + +/** + * This function is used to enable support for H.245 based alphanumeric dtmf + * capability. + * @param call Handle to call, if enabling for the call, else NULL + * for end-point. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityEnableDTMFH245Alphanumeric(struct OOH323CallData *call); + +/** + * This function is used to disable support for H.245 based alphanumeric dtmf + * capability. + * @param call Handle to call, if disabling for the call, else NULL + * for end-point. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityDisableDTMFH245Alphanumeric + (struct OOH323CallData *call); + +/** + * This function is used to enable support for H.245 based signal dtmf + * capability. + * @param call Handle to call, if enabling for the call, else NULL + * for end-point. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityEnableDTMFH245Signal(struct OOH323CallData *call); + +/** + * This function is used to disable support for H.245 based signal dtmf + * capability. + * @param call Handle to call, if disabling for the call, else NULL + * for end-point. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityDisableDTMFH245Signal(struct OOH323CallData *call); + +/** + * This function is used to enable support for dtmf using Q.931 Keypad IE. + * @param call Handle to call, if enabling for the call, else NULL + * for end-point. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityEnableDTMFQ931Keypad(struct OOH323CallData *call); + +/** + * This function is used to disable support for dtmf using Q.931 Keypad IE. + * @param call Handle to call, if disabling for the call, else NULL + * for end-point. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityDisableDTMFQ931Keypad(struct OOH323CallData *call); + +/** + * This function is used to add simple capabilities which have only rxframes + * and txframes parameters to the endpoint or call.(ex. G711, G728, G723.1, + * G729) + * @param call Handle to a call. If this is not Null, then + * capability is added to call's remote enpoint + * capability list, else it is added to local H323 + * endpoint list. + * @param cap Type of G711 capability to be added. + * @param txframes Number of frames per packet for transmission. + * @param rxframes Number of frames per packet for reception. + * @param silenceSuppression Indicates support for silence suppression. + * Used only in case of g7231, otherwise ignored. + * @param dir Direction of capability.OORX, OOTX, OORXANDTX + * @param startReceiveChannel Callback function to start receive channel. + * @param startTransmitChannel Callback function to start transmit channel. + * @param stopReceiveChannel Callback function to stop receive channel. + * @param stopTransmitChannel Callback function to stop transmit channel. + * @param remote TRUE, if adding call's remote capability. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityAddSimpleCapability + (struct OOH323CallData *call, int cap, int txframes, int rxframes, + OOBOOL silenceSuppression, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote); + + +/** + * This is an internal helper function which is used to add a GSM capability + * to local endpoints capability list or to remote endpoints capability list or + * to a call's capability list. + * @param call Handle to a call. If this is not Null, then + * capability is added to call's remote enpoint + * capability list, else it is added to local H323 + * endpoint list. + * @param cap Type of GSM capability to be added. + * @param framesPerPkt Number of GSM frames per packet. + * @param comfortNoise Comfort noise spec for the capability. + * @param scrambled Scrambled enabled/disabled for the capability. + * @param dir Direction of capability.OORX, OOTX, OORXANDTX + * @param startReceiveChannel Callback function to start receive channel. + * @param startTransmitChannel Callback function to start transmit channel. + * @param stopReceiveChannel Callback function to stop receive channel. + * @param stopTransmitChannel Callback function to stop transmit channel. + * @param remote TRUE, if adding call's remote capabilities. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooCapabilityAddGSMCapability(struct OOH323CallData *call, int cap, + unsigned framesPerPkt, OOBOOL comfortNoise, + OOBOOL scrambled, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote); + + +/** + * This function is used to add H263 video capability to local endpoints + * capability list or to remote endpoints capability list or to a call's + * capability list. + * @param call Handle to a call. If this is not Null, then + * capability is added to call's remote enpoint + * capability list, else it is added to local H323 + * endpoint list. + * @param sqcifMPI Minimum picture interval for encoding/decoding + * of SQCIF pictures. + * @param qcifMPI Minimum picture interval for encoding/decoding + * of QCIF pictures. + * @param cifMPI Minimum picture interval for encoding/decoding + * of CIF pictures. + * @param cif4MPI Minimum picture interval for encoding/decoding + * of CIF4 pictures. + * @param cif16MPI Minimum picture interval for encoding/decoding + * of CIF16 pictures. + * @param maxBitRate Maximum bit rate in units of 100 bits/s at + * which a transmitter can transmit video or a + * receiver can receive video. + * @param dir Direction of capability.OORX, OOTX, OORXANDTX + * @param startReceiveChannel Callback function to start receive channel. + * @param startTransmitChannel Callback function to start transmit channel. + * @param stopReceiveChannel Callback function to stop receive channel. + * @param stopTransmitChannel Callback function to stop transmit channel. + * @param remote TRUE, if adding call's remote capabilities. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCapabilityAddH263VideoCapability(struct OOH323CallData *call, + unsigned sqcifMPI, unsigned qcifMPI, + unsigned cifMPI, unsigned cif4MPI, + unsigned cif16MPI, unsigned maxBitRate, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote); + + +/** + * This function is an helper function to ooCapabilityAddH263VideoCapability. + * @param call Handle to a call. If this is not Null, then + * capability is added to call's remote enpoint + * capability list, else it is added to local H323 + * endpoint list. + * @param sqcifMPI Minimum picture interval for encoding/decoding + * of SQCIF pictures. + * @param qcifMPI Minimum picture interval for encoding/decoding + * of QCIF pictures. + * @param cifMPI Minimum picture interval for encoding/decoding + * of CIF pictures. + * @param cif4MPI Minimum picture interval for encoding/decoding + * of CIF4 pictures. + * @param cif16MPI Minimum picture interval for encoding/decoding + * of CIF16 pictures. + * @param maxBitRate Maximum bit rate in units of 100 bits/s at + * which a transmitter can transmit video or a + * receiver can receive video. + * @param dir Direction of capability.OORX, OOTX, OORXANDTX + * @param startReceiveChannel Callback function to start receive channel. + * @param startTransmitChannel Callback function to start transmit channel. + * @param stopReceiveChannel Callback function to stop receive channel. + * @param stopTransmitChannel Callback function to stop transmit channel. + * @param remote TRUE, if adding call's remote capabilities. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooCapabilityAddH263VideoCapability_helper(struct OOH323CallData *call, + unsigned sqcifMPI, unsigned qcifMPI, + unsigned cifMPI, unsigned cif4MPI, + unsigned cif16MPI, unsigned maxBitRate, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel, + OOBOOL remote); + +/** + * This function is used to add a audio capability to calls remote + * capability list. + * @param call Handle to the call. + * @param audioCap Handle to the remote endpoint's audio capability. + * @param dir Direction in which capability is supported by + * remote endpoint. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooAddRemoteAudioCapability(struct OOH323CallData *call, + H245AudioCapability *audioCap, int dir); + + +/** + * This function is used to add a capability to call's remote capability list. + * The capabilities to be added are extracted from received TCS message. + * @param call Handle to the call. + * @param cap Handle to the remote endpoint's H245 capability. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooAddRemoteCapability(struct OOH323CallData *call, H245Capability *cap); + +/** + * This function is used to update joint capabilities for call. It checks + * whether remote capability can be supported by local capabilities for the + * call and if supported makes entry into the joint capability list for the + * call. + * @param call Handle to the call + * @param cap Remote cap which will be tested for compatibility. + * + * @return returns OO_OK, if updated else OO_FAILED; + */ +EXTERN int ooCapabilityUpdateJointCapabilities + (struct OOH323CallData* call, H245Capability *cap); + + +/** + * This function is used to update joint video capabilities for call. It checks + * whether remote capability can be supported by local capabilities for the + * call and if supported makes entry into the joint capability list for the + * call. + * @param call Handle to the call + * @param videoCap Remote video capability which will be tested for + * compatibility. + * @param dir Direction of the capability + * + * @return returns OO_OK, if updated else OO_FAILED; + */ +EXTERN int ooCapabilityUpdateJointCapabilitiesVideo + (struct OOH323CallData *call, H245VideoCapability *videoCap, int dir); + + +/** + * This function is used to update joint video H263 capabilities for call. It + * checks whether remote capability can be supported by local capabilities for + * the call and if supported makes entry into the joint capability list for the + * call. + * @param call Handle to the call + * @param pH263Cap Remote H263 video capability which will be tested for + * compatibility. + * @param dir Direction of the H263 capability + * + * @return returns OO_OK, if updated else OO_FAILED; + */ +EXTERN int ooCapabilityUpdateJointCapabilitiesVideoH263 + (struct OOH323CallData *call, H245H263VideoCapability *pH263Cap, int dir); + + +/** + * This function is used to test whether the endpoint capability in the + * specified direction can be supported by the audio capability. + * @param call Handle to the call. + * @param epCap Endpoint capability. + * @param dataType Data type with which compatibility has to + * be tested. + * @param dir Direction indicating whether endpoint capability + * will be used for transmission or reception. + * + * @return TRUE, if compatible. FALSE, otherwise. + */ + +ASN1BOOL ooCapabilityCheckCompatibility(struct OOH323CallData *call, + ooH323EpCapability *epCap, + H245DataType *dataType, int dir); + + +/** + * This function is used to create a audio capability structure using the + * capability type. + * @param epCap Capability. + * @param pctxt Handle to OOCTXT which will be used to allocate memory + * for new audio capability. + * @param dir Direction in which the newly created capability will be + * used. + * + * @return Newly created audio capability on success, NULL on + * failure. + */ +struct H245AudioCapability* ooCapabilityCreateAudioCapability +(ooH323EpCapability* epCap, OOCTXT *pctxt, int dir); + +/** + * This function is used to create a video capability structure using the + * capability type. + * @param epCap Capability. + * @param pctxt Handle to OOCTXT which will be used to allocate memory + * for new video capability. + * @param dir Direction in which the newly created capability will be + * used. + * + * @return Newly created video capability on success, NULL on + * failure. + */ +struct H245VideoCapability* ooCapabilityCreateVideoCapability + (ooH323EpCapability *epCap, OOCTXT *pctxt, int dir); + + +/** + * This function is used to create a dtmf capability which can be added to + * a TCS message. + * @param cap Type of dtmf capability to be created. + * @param pctxt Pointer to OOCTXT structure to be used for memory + * allocation. + * + * @return Pointer to the created DTMF capability, NULL in case of + * failure. + */ +void * ooCapabilityCreateDTMFCapability(int cap, OOCTXT *pctxt); + + +/** + * This function is used to create a GSM Full Rate capability structure. + * @param epCap Handle to the endpoint capability. + * @param pctxt Handle to OOCTXT which will be used to allocate memory + * for new audio capability. + * @param dir Direction for the newly created capability. + * + * @return Newly created audio capability on success, NULL on + * failure. + */ +struct H245AudioCapability* ooCapabilityCreateGSMFullRateCapability + (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir); + +/** + * This function is used to create a simple(g711, g728, g723.1, g729) audio + * capability structure. + * + * @param epCap Handle to the endpoint capability + * @param pctxt Handle to OOCTXT which will be used to allocate memory + * for new audio capability. + * @param dir Direction in which the newly created capability will be + * used. + * + * @return Newly created audio capability on success, NULL on + * failure. + */ +struct H245AudioCapability* ooCapabilityCreateSimpleCapability + (ooH323EpCapability *epCap, OOCTXT* pctxt, int dir); + + +/** + * This function is used to create a H263 video capability + * structure. + * @param epCap Handle to the endpoint capability + * @param pctxt Handle to OOCTXT which will be used to allocate memory + * for new video capability. + * @param dir Direction in which the newly created capability will be + * used. + * + * @return Newly created video capability on success, NULL on + * failure. + */ +struct H245VideoCapability* ooCapabilityCreateH263VideoCapability +(ooH323EpCapability *epCap, OOCTXT* pctxt, int dir); + + +/** + * This function is used to determine whether a particular capability + * can be supported by the endpoint. + * @param call Handle to the call. + * @param audioCap Handle to the audio capability. + * @param dir Direction in which support is desired. + * + * @return Handle to the copyof capability which supports audioCap, + * Null if none found + */ +ooH323EpCapability* ooIsAudioDataTypeSupported +(struct OOH323CallData *call, H245AudioCapability* audioCap, int dir); + +/** + * This function is used to determine whether a particular video capability + * can be supported by the endpoint. + * @param call Handle to the call. + * @param pVideoCap Handle to the video capability. + * @param dir Direction in which support is desired. + * + * @return Handle to the copy of capability which supports video + * capability, Null if none found + */ +ooH323EpCapability* ooIsVideoDataTypeSupported + (struct OOH323CallData *call, H245VideoCapability* pVideoCap, int dir); + +/** + * This function is used to determine whether a particular H263 capability + * can be supported by the endpoint. + * @param call Handle to the call. + * @param pH263Cap Handle to the H263 video capability. + * @param dir Direction in which support is desired. + * @param picFormat Picture type(cif, qcif etc.) + * + * @return Handle to the copy of capability which supports H263 + * capability, Null if none found + */ +ooH323EpCapability* ooIsVideoDataTypeH263Supported + (struct OOH323CallData *call, H245H263VideoCapability* pH263Cap, int dir, + OOPictureFormat picFormat); + +/** + * This function is used to determine whether a particular capability type + * can be supported by the endpoint. + * @param call Handle to the call. + * @param data Handle to the capability type. + * @param dir Direction in which support is desired. + * + * @return Handle to the copy of capability which supports specified + * capability type, Null if none found + */ +ooH323EpCapability* ooIsDataTypeSupported +(struct OOH323CallData *call, H245DataType *data, int dir); + +/** + * This function is used to clear the capability preference order. + * @param call Handle to call, if capability preference order for call + * has to be cleared, NULL for endpoint. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooResetCapPrefs(struct OOH323CallData *call); + +/** + * This function is used to remove a particular capability from preference + * list. + * @param call Handle to call, if call's preference list has to be modified + * else NULL, to modify endpoint's preference list. + * @param cap Capability to be removed + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooRemoveCapFromCapPrefs(struct OOH323CallData *call, int cap); + +/** + * This function is used to append a particular capability to preference + * list. + * @param call Handle to call, if call's preference list has to be modified + * else NULL, to modify endpoint's preference list. + * @param cap Capability to be appended. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooAppendCapToCapPrefs(struct OOH323CallData *call, int cap); + +/** + * This function is used to change preference order of a particular capability + * in the preference list. + * @param call Handle to call, if call's preference list has to be modified + * else NULL, to modify endpoint's preference list. + * @param cap Capability concerned + * @param pos New position in the preference order + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooChangeCapPrefOrder(struct OOH323CallData *call, int cap, int pos); + +/** + * This function is used to preppend a particular capability to preference + * list. + * @param call Handle to call, if call's preference list has to be modified + * else NULL, to modify endpoint's preference list. + * @param cap Capability to be preppended. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooPreppendCapToCapPrefs(struct OOH323CallData *call, int cap); + +/** + * This function is used to retrieve the text description for a capability + * type. + * @param cap Capability + * @return The text description string. + */ +EXTERN const char* ooGetCapTypeText (OOCapabilities cap); + + +/** + * @} + */ +#ifdef __cplusplus +} +#endif + +#endif + + diff --git a/addons/ooh323c/src/ooCmdChannel.c b/addons/ooh323c/src/ooCmdChannel.c new file mode 100644 index 000000000..8dfd01376 --- /dev/null +++ b/addons/ooh323c/src/ooCmdChannel.c @@ -0,0 +1,193 @@ +/* + * 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 "ooStackCmds.h" +#include "ootrace.h" +#include "ooq931.h" +#include "ooh245.h" +#include "ooh323ep.h" +#include "oochannels.h" +#include "ooCalls.h" +#include "ooCmdChannel.h" + +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + +OOSOCKET gCmdChan = 0; +pthread_mutex_t gCmdChanLock; + +int ooCreateCmdConnection() +{ + int ret = 0; + int thePipe[2]; + + if ((ret = pipe(thePipe)) == -1) { + return OO_FAILED; + } + pthread_mutex_init(&gCmdChanLock, NULL); + + gH323ep.cmdSock = dup(thePipe[0]); + close(thePipe[0]); + gCmdChan = dup(thePipe[1]); + close(thePipe[1]); + return OO_OK; +} + + +int ooCloseCmdConnection() +{ + close(gH323ep.cmdSock); + gH323ep.cmdSock = 0; + close(gCmdChan); + gCmdChan = 0; + pthread_mutex_destroy(&gCmdChanLock); + + return OO_OK; +} + +int ooWriteStackCommand(OOStackCommand *cmd) +{ + + pthread_mutex_lock(&gCmdChanLock); + if (write(gCmdChan, (char*)cmd, sizeof(OOStackCommand)) == -1) { + pthread_mutex_unlock(&gCmdChanLock); + return OO_FAILED; + } + pthread_mutex_unlock(&gCmdChanLock); + + return OO_OK; +} + + +int ooReadAndProcessStackCommand() +{ + OOH323CallData *pCall = NULL; + unsigned char buffer[MAXMSGLEN]; + int i, recvLen = 0; + OOStackCommand cmd; + memset(&cmd, 0, sizeof(OOStackCommand)); + recvLen = read(gH323ep.cmdSock, buffer, MAXMSGLEN); + if(recvLen <= 0) + { + OOTRACEERR1("Error:Failed to read CMD message\n"); + return OO_FAILED; + } + + for(i=0; (int)(i+sizeof(OOStackCommand)) <= recvLen; i += sizeof(OOStackCommand)) + { + memcpy(&cmd, buffer+i, sizeof(OOStackCommand)); + + if(cmd.type == OO_CMD_NOOP) + continue; + + if(gH323ep.gkClient && gH323ep.gkClient->state != GkClientRegistered) + { + OOTRACEINFO1("Ignoring stack command as Gk Client is not registered" + " yet\n"); + } + else { + switch(cmd.type) { + case OO_CMD_MAKECALL: + OOTRACEINFO2("Processing MakeCall command %s\n", + (char*)cmd.param2); + + ooH323MakeCall ((char*)cmd.param1, (char*)cmd.param2, + (ooCallOptions*)cmd.param3); + break; + + case OO_CMD_MANUALRINGBACK: + if(OO_TESTFLAG(gH323ep.flags, OO_M_MANUALRINGBACK)) + { + pCall = ooFindCallByToken((char*)cmd.param1); + if(!pCall) { + OOTRACEINFO2("Call \"%s\" does not exist\n", + (char*)cmd.param1); + OOTRACEINFO1("Call migth be cleared/closed\n"); + } + else { + ooSendAlerting(ooFindCallByToken((char*)cmd.param1)); + if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER)) { + ooSendConnect(ooFindCallByToken((char*)cmd.param1)); + } + } + } + break; + + case OO_CMD_ANSCALL: + pCall = ooFindCallByToken((char*)cmd.param1); + if(!pCall) { + OOTRACEINFO2("Call \"%s\" does not exist\n", + (char*)cmd.param1); + OOTRACEINFO1("Call might be cleared/closed\n"); + } + else { + OOTRACEINFO2("Processing Answer Call command for %s\n", + (char*)cmd.param1); + ooSendConnect(pCall); + } + break; + + case OO_CMD_FWDCALL: + OOTRACEINFO3("Forwarding call %s to %s\n", (char*)cmd.param1, + (char*)cmd.param2); + ooH323ForwardCall((char*)cmd.param1, (char*)cmd.param2); + break; + + case OO_CMD_HANGCALL: + OOTRACEINFO2("Processing Hang call command %s\n", + (char*)cmd.param1); + ooH323HangCall((char*)cmd.param1, + *(OOCallClearReason*)cmd.param2); + break; + + case OO_CMD_SENDDIGIT: + pCall = ooFindCallByToken((char*)cmd.param1); + if(!pCall) { + OOTRACEERR2("ERROR:Invalid calltoken %s\n", + (char*)cmd.param1); + break; + } + if(pCall->jointDtmfMode & OO_CAP_DTMF_H245_alphanumeric) { + ooSendH245UserInputIndication_alphanumeric( + pCall, (const char*)cmd.param2); + } + else if(pCall->jointDtmfMode & OO_CAP_DTMF_H245_signal) { + ooSendH245UserInputIndication_signal( + pCall, (const char*)cmd.param2); + } + else { + ooQ931SendDTMFAsKeyPadIE(pCall, (const char*)cmd.param2); + } + + break; + + case OO_CMD_STOPMONITOR: + OOTRACEINFO1("Processing StopMonitor command\n"); + ooStopMonitorCalls(); + break; + + default: OOTRACEERR1("ERROR:Unknown command\n"); + } + } + if(cmd.param1) free(cmd.param1); + if(cmd.param2) free(cmd.param2); + if(cmd.param3) free(cmd.param3); + } + + + return OO_OK; +} + diff --git a/addons/ooh323c/src/ooCmdChannel.h b/addons/ooh323c/src/ooCmdChannel.h new file mode 100644 index 000000000..cc1dfaa25 --- /dev/null +++ b/addons/ooh323c/src/ooCmdChannel.h @@ -0,0 +1,90 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * @file ooCmdChannel.h + * This file contains stack commands which an user application can use to make + * call, hang call etc. + */ + +#ifndef OO_CMDCHANNEL_H +#define OO_CMDCHANNEL_H + +#include "ootypes.h" +#include "ooStackCmds.h" +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#if defined (MAKE_DLL) +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + + +#define OO_DEFAULT_CMDLISTENER_PORT 7575 + +/** + * @addtogroup channels + * @{ + */ + +/** + * This function is used to setup a command connection with the main stack + * thread. The application commands are sent over this connection to stack + * thread. + * + * @return OO_OK, on success; OO_FAILED, on failure + */ +EXTERN int ooCreateCmdConnection(); + +/** + * This function is used to close a command channel setup with the stack + * thread. + * + * @return OO_OK, on success; OO_FAILED, on failure + */ +EXTERN int ooCloseCmdConnection(); + + +/** + * This function is used by stack api to write stack commands to command + * channel. + * + * @return OO_OK, on success; OO_FAILED, on failure + */ +EXTERN int ooWriteStackCommand(OOStackCommand *cmd); + +/** + * This function is used by stack thread to read and process stack commands + * received over command channel. + * + * @return OO_OK, on success; OO_FAILED, on failure + */ +EXTERN int ooReadAndProcessStackCommand(); + + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/ooCommon.h b/addons/ooh323c/src/ooCommon.h new file mode 100644 index 000000000..bb034c569 --- /dev/null +++ b/addons/ooh323c/src/ooCommon.h @@ -0,0 +1,124 @@ +/* + * 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 LICENSE.txt 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. + * + *****************************************************************************/ +/** + * @file ooCommon.h + * Common runtime constant and type definitions. + */ +#ifndef _OOCOMMON_H_ +#define _OOCOMMON_H_ + +#include +#include +#include +#include + +#ifdef _WIN32_WCE +#include +#elif defined(_WIN32) || defined(_WIN64) +#include +#define INCL_WINSOCK_API_TYPEDEFS 1 +#define INCL_WINSOCK_API_PROTOTYPES 0 +#include +#else +#include +#include +#include +#include +#include +#include +#include +#endif + +/** + * @ingroup cruntime C Runtime Common Constant and Type Definitions. + * @{ + */ + +/* Basic type definitions */ + +typedef char OOCHAR; +typedef unsigned char OOUCHAR; +typedef signed char OOINT8; +typedef unsigned char OOUINT8; +typedef short OOINT16; +typedef unsigned short OOUINT16; +typedef int OOINT32; +typedef unsigned int OOUINT32; +typedef OOUINT8 OOBOOL; + +#define OOUINT32_MAX 4294967295U +#define OOINT32_MAX ((OOINT32)2147483647L) +#define OOINT32_MIN ((OOINT32)(-OOINT32_MAX-1)) + +#ifndef FALSE +#define FALSE 0 +#define TRUE 1 +#endif + +/* Common error codes */ + +#define OOERRINVPARAM (-50) /* Invalid parameter */ +#define OOERRBUFOVFLW (-51) /* Buffer overflow */ +#define OOERRNOMEM (-52) /* No dynamic memory available */ + +/* Message buffer: this is used for asynchronous transfers */ + +typedef struct _OOMsgBuf { + OOUINT8* pdata; /* Pointer to binary or text data */ + OOUINT32 bufsiz; /* Size of the buffer in bytes */ + OOUINT32 length; /* # bytes to send (write) or # received (read) */ + OOUINT32 offset; /* Offset into buffer of first byte to send */ + OOBOOL dynamic; /* pdata is dynamic (allocated with OOMEMALLOC) */ +} OOMsgBuf; + +/* Memory allocation and free function definitions. These definitions */ +/* can be changed if a non-standard allocation/free function is to be */ +/* used.. */ + +#define OOMEMALLOC malloc +#define OOMEMFREE free + +/* Min/max macros */ + +#ifndef OOMAX +#define OOMAX(a,b) (((a)>(b))?(a):(b)) +#endif + +#ifndef OOMIN +#define OOMIN(a,b) (((a)<(b))?(a):(b)) +#endif + +/* Get count of number of items in an array */ + +#define OONUMBEROF(items) (sizeof(items)/sizeof(items[0])) + +/* This is used for creating a Windows DLL. Specify -DMAKE_DLL to */ +/* compile code for inclusion in a DLL. */ + +#ifndef EXTERN +#if defined (MAKE_DLL) +#define EXTERN __declspec(dllexport) +#elif defined (USE_DLL) +#define EXTERN __declspec(dllimport) +#else +#define EXTERN +#endif /* _DLL */ +#endif /* EXTERN */ + +/** + * @} + */ +#endif /* _OOCOMMON_H_ */ diff --git a/addons/ooh323c/src/ooDateTime.c b/addons/ooh323c/src/ooDateTime.c new file mode 100644 index 000000000..af6faec65 --- /dev/null +++ b/addons/ooh323c/src/ooDateTime.c @@ -0,0 +1,175 @@ +/* + * 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 LICENSE.txt 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 "ooCommon.h" + +#if defined(_WIN32) || defined(_MSC_VER) || defined(__MINGW32__) + +#ifndef __MINGW32__ +#include +int gettimeofday (struct timeval *tv, struct timezone *tz) +{ + struct _timeb currSysTime; + _ftime(&currSysTime); + + tv->tv_sec = currSysTime.time; + tv->tv_usec = currSysTime.millitm * 1000; + + return 0; +} + +#else +/* Mingw specific logic..probably works with regular winders + * too, but cannot test. --Ben + */ +#define uint64 unsigned long long +#define uint32 unsigned long + +static uint64 calcEpocOffset() { + SYSTEMTIME st; + FILETIME ft; + + memset(&st, 0, sizeof(st)); + memset(&ft, 0, sizeof(ft)); + + st.wYear = 1970; + st.wMonth = 1; + st.wDayOfWeek = 0; + st.wDay = 1; + st.wHour = 0; + st.wMinute = 0; + st.wSecond = 0; + st.wMilliseconds = 0; + + if (!SystemTimeToFileTime(&st, &ft)) { + //cout << "ERROR: SystemTimeToFileTime failed, err: " + // << GetLastError() << endl; + } + + uint64 t = ft.dwHighDateTime; + t = t << 32; + t |= ft.dwLowDateTime; + + return t; +} + +// Gets high resolution by spinning up to 15ms. Don't call this often!!! +static uint64 getRawCurMsSpin() { + FILETIME tm; + uint64 t_now; + + static uint64 epocOffset = 0; + static int do_once = 1; + if (do_once) { + epocOffset = calcEpocOffset(); + do_once = 0; + } + + GetSystemTimeAsFileTime(&tm); + uint64 t_start = tm.dwHighDateTime; + t_start = t_start << 32; + t_start |= tm.dwLowDateTime; + while (1) { + GetSystemTimeAsFileTime(&tm); + t_now = tm.dwHighDateTime; + t_now = t_now << 32; + t_now |= tm.dwLowDateTime; + + if (t_now != t_start) { + // Hit a boundary...as accurate as we are going to get. + break; + } + } + + + t_now -= epocOffset; + + // t is in 100ns units, convert to usecs + t_now = t_now / 10000; //msecs + + return t_now; +} + +static uint64 baselineMs = 0; +static uint32 tickBaseline = 0; + +int gettimeofday(struct timeval* tv, void* null) { + + // Get baseline time, in seconds. + if (baselineMs == 0) { + baselineMs = getRawCurMsSpin(); + tickBaseline = timeGetTime(); + } + + uint32 curTicks = timeGetTime(); + if (curTicks < tickBaseline) { + // Wrap! + baselineMs = getRawCurMsSpin(); + tickBaseline = timeGetTime(); + } + + uint64 now_ms = (baselineMs + (curTicks - tickBaseline)); + *tv = oo_ms_to_tv(now_ms); + return 0; +}; + + +/* Correctly synched with the 'real' time/date clock, but only exact to + * about 15ms. Set foo to non NULL if you want to recalculate the + */ +uint64 getCurMsFromClock() { + // This has resolution of only about 15ms + FILETIME tm; + // The Windows epoc is January 1, 1601 (UTC). + static uint64 offset = 0; + static int do_once = 1; + if (do_once) { + offset = calcEpocOffset(); + do_once = 0; + } + + + GetSystemTimeAsFileTime(&tm); + uint64 t = tm.dwHighDateTime; + t = t << 32; + t |= tm.dwLowDateTime; + + /*cout << "file-time: " << t << " offset: " << offset + << " normalized: " << (t - offset) << " hi: " + << tm.dwHighDateTime << " lo: " << tm.dwLowDateTime + << " calc-offset:\n" << calcEpocOffset() << "\n\n"; + */ + t -= offset; + + // t is in 100ns units, convert to ms + t = t / 10000; + return t; +} +#endif +#endif + +int ooGetTimeOfDay (struct timeval *tv, struct timezone *tz) +{ + return gettimeofday (tv, tz); +} + + +long ooGetTimeDiff(struct timeval *tv1, struct timeval *tv2) +{ + return ( ((tv2->tv_sec-tv1->tv_sec)*1000) + + ((tv2->tv_usec-tv1->tv_usec)/1000) ); +} + diff --git a/addons/ooh323c/src/ooDateTime.h b/addons/ooh323c/src/ooDateTime.h new file mode 100644 index 000000000..afcc9b308 --- /dev/null +++ b/addons/ooh323c/src/ooDateTime.h @@ -0,0 +1,54 @@ +/* + * 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 LICENSE.txt 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. + * + *****************************************************************************/ +/** + * @file ooDateTime.h + * Time functions that reconcile differences between Windows and UNIX. + */ +#ifndef _OOTIME_H_ +#define _OOTIME_H_ + +#include "ooCommon.h" +#include + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * This function provides an abstraction for the UNIX 'gettimeofday' + * function which is not available on Windows. + * + * @param tv Pointer to time value structure to receive + * current time value. + * @param tz Point to time zone information. + * @return Completion status of operation: 0 = success, + * negative return value is error. + */ +EXTERN int ooGetTimeOfDay (struct timeval *tv, struct timezone *tz); + +/** + * This function subtracts first timeval parameter from second and provides + * the difference in milliseconds. + * @param tv1 Pointer to timeval value. + * @param tv2 Pointer to timeval value. + * + * @return Difference between two timevals in milliseconds. + */ +EXTERN long ooGetTimeDiff(struct timeval *tv1, struct timeval *tv2); +#ifdef __cplusplus +} +#endif +#endif diff --git a/addons/ooh323c/src/ooGkClient.c b/addons/ooh323c/src/ooGkClient.c new file mode 100644 index 000000000..1a920e3a7 --- /dev/null +++ b/addons/ooh323c/src/ooGkClient.c @@ -0,0 +1,2443 @@ +/* + * Copyright (C) 2005 by Page Iberica, S.A. + * Copyright (C) 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. + * + *****************************************************************************/ + +/** + * @file ooGkClient.c + * This file contains functions to support RAS protocol. + * + */ +#include "ooGkClient.h" +#include "ootypes.h" +#include "ootrace.h" +#include "ooports.h" +#include "ooasn1.h" +#include "oochannels.h" +#include "printHandler.h" +#include "ooCalls.h" +#include "H323-MESSAGES.h" +#include "ooDateTime.h" +#include "ooq931.h" +#include "ooh323.h" +#include "ooh323ep.h" +#include "ooTimer.h" +#include "ooSocket.h" +#include "ooUtils.h" + +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + +static ASN1OBJID gProtocolID = { + 6, { 0, 0, 8, 2250, 0, 4 } +}; + +int ooGkClientInit(enum RasGatekeeperMode eGkMode, + char *szGkAddr, int iGkPort ) +{ + ooGkClient *pGkClient=NULL; + OOInterface *cur=NULL; + pGkClient = (ooGkClient*) + memAlloc(&gH323ep.ctxt, sizeof(ooGkClient)); + if(!pGkClient) + { + OOTRACEERR1("Error: Failed to allocate memory to Gatekeeper Client.\n"); + return OO_FAILED; + } + + memset(pGkClient, 0, sizeof(ooGkClient)); + gH323ep.gkClient = pGkClient; + initContext(&(pGkClient->ctxt)); + initContext(&(pGkClient->msgCtxt)); + pGkClient->rrqRetries = 0; + pGkClient->grqRetries = 0; + + strcpy(pGkClient->localRASIP, gH323ep.signallingIP); +#ifndef _WIN32 + if(!strcmp(pGkClient->localRASIP, "0.0.0.0") || + !strcmp(pGkClient->localRASIP, "127.0.0.1")) + { + if(!gH323ep.ifList) + { + if(ooSocketGetInterfaceList(&gH323ep.ctxt, &gH323ep.ifList)!= ASN_OK) + { + OOTRACEERR1("Error:Failed to retrieve interface addresses\n"); + return OO_FAILED; + } + } + for(cur = gH323ep.ifList; cur; cur = cur->next) + { + if(!strcmp(cur->name, "lo") || !strcmp(cur->addr, "127.0.0.1")) + continue; + break; + } + if(cur) + { + OOTRACEINFO2("Using local RAS Ip address %s\n", cur->addr); + strcpy(pGkClient->localRASIP, cur->addr); + } + else{ + OOTRACEERR1("Error:Failed to assign a local RAS IP address\n"); + return OO_FAILED; + } + } +#endif + if(OO_OK != ooGkClientSetGkMode(pGkClient, eGkMode, szGkAddr, iGkPort)) + { + OOTRACEERR1("Error:Failed to set Gk mode\n"); + memReset(&gH323ep.ctxt); + return OO_FAILED; + } + + /* Create default parameter set */ + pGkClient->grqTimeout = DEFAULT_GRQ_TIMEOUT; + pGkClient->rrqTimeout = DEFAULT_RRQ_TIMEOUT; + pGkClient->regTimeout = DEFAULT_REG_TTL; + pGkClient->arqTimeout = DEFAULT_ARQ_TIMEOUT; + pGkClient->drqTimeout = DEFAULT_DRQ_TIMEOUT; + dListInit(&pGkClient->callsPendingList); + dListInit(&pGkClient->callsAdmittedList); + dListInit(&pGkClient->timerList); + pGkClient->state = GkClientIdle; + return OO_OK; +} + + +int ooGkClientSetCallbacks + (ooGkClient *pGkClient, OOGKCLIENTCALLBACKS callbacks) +{ + pGkClient->callbacks.onReceivedRegistrationConfirm = + callbacks.onReceivedRegistrationConfirm; + pGkClient->callbacks.onReceivedUnregistrationConfirm = + callbacks.onReceivedUnregistrationConfirm; + pGkClient->callbacks.onReceivedUnregistrationRequest = + callbacks.onReceivedUnregistrationRequest; + return OO_OK; +} + +int ooGkClientReInit(ooGkClient *pGkClient) +{ + + ooGkClientCloseChannel(pGkClient); + pGkClient->gkRasIP[0]='\0'; + pGkClient->gkCallSignallingIP[0]='\0'; + pGkClient->gkRasPort = 0; + pGkClient->gkCallSignallingPort = 0; + pGkClient->rrqRetries = 0; + pGkClient->grqRetries = 0; + pGkClient->requestSeqNum = 0; + + dListFreeAll(&pGkClient->ctxt, &pGkClient->callsPendingList); + dListFreeAll(&pGkClient->ctxt, &pGkClient->callsAdmittedList); + dListFreeAll(&pGkClient->ctxt, &pGkClient->timerList); + pGkClient->state = GkClientIdle; + return OO_OK; +} + +void ooGkClientPrintConfig(ooGkClient *pGkClient) +{ + OOTRACEINFO1("Gatekeeper Client Configuration:\n"); + if(pGkClient->gkMode == RasUseSpecificGatekeeper) + { + OOTRACEINFO1("\tGatekeeper mode - UseSpecificGatekeeper\n"); + OOTRACEINFO3("\tGatekeeper To Use - %s:%d\n", pGkClient->gkRasIP, + pGkClient->gkRasPort); + } + else if(pGkClient->gkMode == RasDiscoverGatekeeper) { + OOTRACEINFO1("\tGatekeeper mode - UseSpecificGatekeeper\n"); + } + else { + OOTRACEERR1("Invalid GatekeeperMode\n"); + } +} + +int ooGkClientDestroy(void) +{ + if(gH323ep.gkClient) + { + if(gH323ep.gkClient->state == GkClientRegistered) + { + OOTRACEINFO1("Unregistering from Gatekeeper\n"); + if(ooGkClientSendURQ(gH323ep.gkClient, NULL)!=OO_OK) + OOTRACEERR1("Error:Failed to send URQ to gatekeeper\n"); + } + OOTRACEINFO1("Destroying Gatekeeper Client\n"); + ooGkClientCloseChannel(gH323ep.gkClient); + freeContext(&gH323ep.gkClient->msgCtxt); + freeContext(&gH323ep.gkClient->ctxt); + memFreePtr(&gH323ep.ctxt, gH323ep.gkClient); + gH323ep.gkClient = NULL; + } + return OO_OK; +} + +int ooGkClientStart(ooGkClient *pGkClient) +{ + int iRet=0; + iRet = ooGkClientCreateChannel(pGkClient); + + if(iRet != OO_OK) + { + OOTRACEERR1("Error: GkClient Channel Creation failed\n"); + return OO_FAILED; + } + + pGkClient->discoveryComplete = FALSE; + iRet = ooGkClientSendGRQ(pGkClient); + if(iRet != OO_OK) + { + OOTRACEERR1("Error:Failed to send GRQ message\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + return OO_OK; +} + + +int ooGkClientSetGkMode(ooGkClient *pGkClient, enum RasGatekeeperMode eGkMode, + char *szGkAddr, int iGkPort ) +{ + pGkClient->gkMode = eGkMode; + if(eGkMode == RasUseSpecificGatekeeper) + { + OOTRACEINFO1("Gatekeeper Mode - RasUseSpecificGatekeeper\n"); + if(szGkAddr) + { + if(strlen(szGkAddr)>MAX_IP_LEN) + { + OOTRACEERR2("Error:Invalid IP address specified - %s\n", szGkAddr); + return OO_FAILED; + } + strcpy(pGkClient->gkRasIP, szGkAddr); + } + if(iGkPort) + pGkClient->gkRasPort = iGkPort; + else + pGkClient->gkRasPort = DEFAULT_GKPORT; + + OOTRACEINFO3("Gatekeeper IP:port set to - %s:%d\n", + szGkAddr, pGkClient->gkRasPort); + } + else if(eGkMode == RasDiscoverGatekeeper) { + OOTRACEINFO1("Gatekeeper Mode - RasDiscoverGatekeeper\n"); + } + else if(eGkMode == RasNoGatekeeper) { + OOTRACEINFO1("Gatekeeper Mode - RasNoGatekeeper\n"); + } + return OO_OK; +} + + +/** + * Create the RAS channel (socket). + * + */ + +int ooGkClientCreateChannel(ooGkClient *pGkClient) +{ + int ret=0; + OOIPADDR ipaddrs; + /* Create socket */ + if((ret=ooSocketCreateUDP(&pGkClient->rasSocket))!=ASN_OK) + { + OOTRACEERR1("Failed to create RAS socket\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + if(pGkClient->localRASPort) + { + ret= ooSocketStrToAddr (pGkClient->localRASIP, &ipaddrs); + if( (ret=ooSocketBind( pGkClient->rasSocket, ipaddrs, + pGkClient->localRASPort))!=ASN_OK ) + { + OOTRACEERR1("ERROR:Failed to create RAS channel\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + } + else { + ret = ooBindPort (OOUDP, pGkClient->rasSocket, pGkClient->localRASIP); + if(ret == OO_FAILED) + { + OOTRACEERR1("ERROR: Failed to bind port to RAS socket\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pGkClient->localRASPort = ret; + } + /* Test Code NOTE- This doesn't work..:(( Have to fix this */ + /* If multihomed, get ip from socket */ + if(!strcmp(pGkClient->localRASIP, "0.0.0.0")) + { + OOTRACEDBGA1("Determining ip address for RAS channel " + "multihomed mode. \n"); + ret = ooSocketGetIpAndPort(pGkClient->rasSocket, pGkClient->localRASIP, + 20, &pGkClient->localRASPort); + if(ret != ASN_OK) + { + OOTRACEERR1("Error:Failed to retrieve local ip and port from " + "socket for RAS channel(multihomed).\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + OOTRACEDBGA3("Using local ip %s and port %d for RAS channel" + "(multihomedMode).\n", pGkClient->localRASIP, + pGkClient->localRASPort); + } + /* End of Test code */ + OOTRACEINFO1("H323 RAS channel creation - successful\n"); + return OO_OK; +} + + +int ooGkClientCloseChannel(ooGkClient *pGkClient) +{ + int ret; + if(pGkClient->rasSocket != 0) + { + ret = ooSocketClose(pGkClient->rasSocket); + if(ret != ASN_OK) + { + OOTRACEERR1("Error: failed to close RAS channel\n"); + pGkClient->rasSocket = 0; + return OO_FAILED; + } + pGkClient->rasSocket = 0; + } + OOTRACEINFO1("Closed RAS channel\n"); + return OO_OK; +} + + +/** + * Fill vendor data in RAS message structure. + */ + +void ooGkClientFillVendor + (ooGkClient *pGkClient, H225VendorIdentifier *pVendor ) +{ + pVendor->vendor.t35CountryCode = gH323ep.t35CountryCode; + pVendor->vendor.t35Extension = gH323ep.t35Extension; + pVendor->vendor.manufacturerCode = gH323ep.manufacturerCode; + pVendor->enterpriseNumber.numids=0; + if(gH323ep.productID) + { + pVendor->m.productIdPresent = TRUE; + pVendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), + sizeof(pVendor->productId.data)); + memcpy(pVendor->productId.data, gH323ep.productID, + pVendor->productId.numocts); + } + if(gH323ep.versionID) + { + pVendor->m.versionIdPresent = 1; + pVendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), + sizeof(pVendor->versionId.data)); + memcpy(pVendor->versionId.data, gH323ep.versionID, + pVendor->versionId.numocts); + } +} + + +int ooGkClientReceive(ooGkClient *pGkClient) +{ + ASN1OCTET recvBuf[1024]; + int recvLen; + char remoteHost[32]; + int iFromPort=0; + OOCTXT *pctxt=NULL; + H225RasMessage *pRasMsg=NULL; + int iRet=OO_OK; + + pctxt = &pGkClient->msgCtxt; + + recvLen = ooSocketRecvFrom(pGkClient->rasSocket, recvBuf, 1024, remoteHost, + 32, &iFromPort); + if(recvLen <0) + { + OOTRACEERR1("Error:Failed to receive RAS message\n"); + return OO_FAILED; + } + OOTRACEDBGA1("GkClient Received RAS Message\n"); + + /* Verify the gk */ + if(pGkClient->discoveryComplete) + { + if((strncmp(pGkClient->gkRasIP, remoteHost,strlen(pGkClient->gkRasIP)))|| + (pGkClient->gkRasPort!= iFromPort) ) + { + OOTRACEWARN3("WARN:Ignoring message received from unknown gatekeeper " + "%s:%d\n", remoteHost, iFromPort); + return OO_OK; + } + } + + if(ASN_OK != setPERBuffer (pctxt, recvBuf, recvLen, TRUE ) ) + { + OOTRACEERR1("Error:Failed to set PER buffer for RAS message decoding\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage)); + if(!pRasMsg) + { + OOTRACEERR1("Error: Failed to allocate memory for RAS message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } +#ifndef _COMPACT + initializePrintHandler(&printHandler, "Received RAS Message"); + /* Add event handler to list */ + setEventHandler (pctxt, &printHandler); +#endif + if(ASN_OK == asn1PD_H225RasMessage(pctxt, pRasMsg)) + { +#ifndef _COMPACT + finishPrint(); + removeEventHandler(pctxt); +#endif + iRet=ooGkClientHandleRASMessage( pGkClient, pRasMsg ); + if(iRet != OO_OK) + { + OOTRACEERR1("Error: Failed to handle received RAS message\n"); + //pGkClient->state = GkClientFailed; + } + memReset(pctxt); + } + else{ + OOTRACEERR1("ERROR:Failed to decode received RAS message- ignoring" + "received message.\n"); +#ifndef _COMPACT + removeEventHandler(pctxt); +#endif + memReset(pctxt); + return OO_FAILED; + } + return iRet; +} + + + + +/** + * Manage incoming RAS message. + */ + +int ooGkClientHandleRASMessage(ooGkClient *pGkClient, H225RasMessage *pRasMsg) +{ + int iRet = OO_OK; + switch( pRasMsg->t) + { + case T_H225RasMessage_gatekeeperConfirm: + OOTRACEINFO1("Gatekeeper Confirmed (GCF) message received.\n"); + iRet = ooGkClientHandleGatekeeperConfirm(pGkClient, + pRasMsg->u.gatekeeperConfirm); + break; + case T_H225RasMessage_gatekeeperReject: + OOTRACEINFO1("Gatekeeper Reject (GRJ) message received\n"); + iRet = ooGkClientHandleGatekeeperReject(pGkClient, + pRasMsg->u.gatekeeperReject); + break; + case T_H225RasMessage_registrationConfirm: + OOTRACEINFO1("Registration Confirm (RCF) message received\n"); + iRet = ooGkClientHandleRegistrationConfirm(pGkClient, + pRasMsg->u.registrationConfirm ); + break; + case T_H225RasMessage_registrationReject: + OOTRACEINFO1("Registration Reject (RRJ) message received.\n"); + iRet = ooGkClientHandleRegistrationReject(pGkClient, + pRasMsg->u.registrationReject); + break; + case T_H225RasMessage_infoRequest: + //ooRasSendIRR( psRasMsg->sMessage.u.infoRequest->requestSeqNum ); + break; + case T_H225RasMessage_admissionConfirm: + OOTRACEINFO1("Admission Confirm (ACF) message received\n"); + iRet = ooGkClientHandleAdmissionConfirm(pGkClient, + pRasMsg->u.admissionConfirm); + break; + case T_H225RasMessage_unregistrationRequest: + OOTRACEINFO1("UnRegistration Request (URQ) message received.\n"); + iRet = ooGkClientHandleUnregistrationRequest(pGkClient, + pRasMsg->u.unregistrationRequest); + break; + case T_H225RasMessage_unregistrationConfirm: + OOTRACEINFO1("UnRegistration Confirm (UCF) message received.\n"); + break; + case T_H225RasMessage_unregistrationReject: + OOTRACEINFO1("UnRegistration Reject (URJ) message received.\n"); + break; + case T_H225RasMessage_admissionReject: + OOTRACEINFO1("Admission Reject (ARJ) message received.\n"); + iRet = ooGkClientHandleAdmissionReject(pGkClient, + pRasMsg->u.admissionReject); + break; + case T_H225RasMessage_disengageConfirm: + iRet = ooGkClientHandleDisengageConfirm(pGkClient, + pRasMsg->u.disengageConfirm); + break; + case T_H225RasMessage_disengageReject: + case T_H225RasMessage_bandwidthConfirm: + case T_H225RasMessage_bandwidthReject: + case T_H225RasMessage_locationRequest: + case T_H225RasMessage_locationConfirm: + case T_H225RasMessage_locationReject: + case T_H225RasMessage_infoRequestResponse: + case T_H225RasMessage_nonStandardMessage: + case T_H225RasMessage_unknownMessageResponse: + case T_H225RasMessage_requestInProgress: + case T_H225RasMessage_resourcesAvailableIndicate: + case T_H225RasMessage_resourcesAvailableConfirm: + case T_H225RasMessage_infoRequestAck: + case T_H225RasMessage_infoRequestNak: + case T_H225RasMessage_serviceControlIndication: + case T_H225RasMessage_serviceControlResponse: + case T_H225RasMessage_admissionConfirmSequence: + default: + /* Unhandled RAS message */ + iRet= OO_OK; + } + + return iRet; +} + +#ifndef _COMPACT +void ooGkClientPrintMessage + (ooGkClient *pGkClient, ASN1OCTET *msg, ASN1UINT len) +{ + OOCTXT ctxt; + H225RasMessage rasMsg; + int ret; + + initContext(&ctxt); + setPERBuffer(&ctxt, msg, len, TRUE); + initializePrintHandler(&printHandler, "Sending RAS Message"); + setEventHandler(&ctxt, &printHandler); + + ret = asn1PD_H225RasMessage(&ctxt, &rasMsg); + if(ret != ASN_OK) + { + OOTRACEERR1("Error: Failed to decode RAS message\n"); + } + finishPrint(); + freeContext(&ctxt); +} +#endif +/** + * Encode and send RAS message. + */ + +int ooGkClientSendMsg(ooGkClient *pGkClient, H225RasMessage *pRasMsg) +{ + ASN1OCTET msgBuf[MAXMSGLEN]; + ASN1OCTET *msgPtr=NULL; + int iLen; + OOCTXT *pctxt = &pGkClient->msgCtxt; + + setPERBuffer( pctxt, msgBuf, MAXMSGLEN, TRUE ); + if ( ASN_OK == asn1PE_H225RasMessage(pctxt, pRasMsg) ) + { + OOTRACEDBGC1("Ras message encoding - successful\n"); + } + else { + OOTRACEERR1("Error: RAS message encoding failed\n"); + return OO_FAILED; + } + + msgPtr = encodeGetMsgPtr( pctxt, &iLen ); + /* If gatekeeper specified or have been discovered */ + if(pGkClient->gkMode == RasUseSpecificGatekeeper || + pGkClient->discoveryComplete) + { + if(ASN_OK != ooSocketSendTo( pGkClient->rasSocket, msgPtr, iLen, + pGkClient->gkRasIP, pGkClient->gkRasPort)) + { + OOTRACEERR1("Error sending RAS message\n"); + return OO_FAILED; + } + } + else if(pGkClient->gkMode == RasDiscoverGatekeeper && + !pGkClient->discoveryComplete) { + if(ASN_OK != ooSocketSendTo(pGkClient->rasSocket, msgPtr, iLen, + MULTICAST_GKADDRESS, MULTICAST_GKPORT)) + { + OOTRACEERR1("Error sending multicast RAS message\n" ); + return OO_FAILED; + } + } + else {/* should never go here */ + OOTRACEERR1("Error: GkClient in invalid state.\n"); + return OO_FAILED; + } +#ifndef _COMPACT + ooGkClientPrintMessage(pGkClient, msgPtr, iLen); +#endif + return OO_OK; +} + + + +int ooGkClientSendGRQ(ooGkClient *pGkClient) +{ + int iRet; + H225RasMessage *pRasMsg=NULL; + H225GatekeeperRequest *pGkReq=NULL; + H225TransportAddress_ipAddress *pRasAddress; + OOCTXT *pctxt = &pGkClient->msgCtxt; + ooGkClientTimerCb *cbData=NULL; + + + + /* Allocate memory for RAS message */ + pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage)); + if(!pRasMsg) + { + OOTRACEERR1("Error: Memory allocation for GRQ RAS message failed\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + pGkReq = (H225GatekeeperRequest*)memAlloc(pctxt, + sizeof(H225GatekeeperRequest)); + if(!pGkReq) + { + OOTRACEERR1("Error:Memory allocation for GRQ failed\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memset(pGkReq, 0, sizeof(H225GatekeeperRequest)); + pRasMsg->t = T_H225RasMessage_gatekeeperRequest; + pRasMsg->u.gatekeeperRequest = pGkReq; + + /* Populate message structure */ + pGkReq->requestSeqNum = pGkClient->requestSeqNum++; + if ( !pGkReq->requestSeqNum ) + pGkReq->requestSeqNum = pGkClient->requestSeqNum++; + + pGkReq->protocolIdentifier = gProtocolID; + pGkReq->m.nonStandardDataPresent=0; + pGkReq->rasAddress.t=T_H225TransportAddress_ipAddress; /* IPv4 address */ + pRasAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + if(!pRasAddress) + { + OOTRACEERR1("Error: Memory allocation for Ras Address of GRQ message " + "failed\n"); + memReset(&pGkClient->msgCtxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + + ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pRasAddress->ip.data); + + pRasAddress->ip.numocts = 4; + pRasAddress->port = pGkClient->localRASPort; + pGkReq->rasAddress.u.ipAddress = pRasAddress; + + /* Pose as gateway or terminal as per config */ + if(gH323ep.isGateway) + pGkReq->endpointType.m.gatewayPresent = TRUE; + else + pGkReq->endpointType.m.terminalPresent = TRUE; + + pGkReq->endpointType.m.nonStandardDataPresent=0; + pGkReq->endpointType.m.vendorPresent=1; + + ooGkClientFillVendor(pGkClient, &pGkReq->endpointType.vendor); + + + pGkReq->m.endpointAliasPresent=TRUE; + if(OO_OK != ooPopulateAliasList(&pGkClient->msgCtxt, gH323ep.aliases, + &pGkReq->endpointAlias)) + { + OOTRACEERR1("Error Failed to fill alias information for GRQ message\n"); + memReset(&pGkClient->msgCtxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + iRet = ooGkClientSendMsg(pGkClient, pRasMsg); + if(iRet != OO_OK) + { + OOTRACEERR1("Error: Failed to send GRQ message\n"); + memReset(&pGkClient->msgCtxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + OOTRACEINFO1("Sent GRQ message\n"); + cbData = (ooGkClientTimerCb*) memAlloc + (&pGkClient->ctxt, sizeof(ooGkClientTimerCb)); + if(!cbData) + { + OOTRACEERR1("Error:Failed to allocate memory to GRQ timer callback\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + cbData->timerType = OO_GRQ_TIMER; + cbData->pGkClient = pGkClient; + if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, + &ooGkClientGRQTimerExpired, pGkClient->grqTimeout, + cbData, FALSE)) + { + OOTRACEERR1("Error:Unable to create GRQ timer.\n "); + memFreePtr(&pGkClient->ctxt, cbData); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + return OO_OK; +} + +int ooGkClientHandleGatekeeperReject + (ooGkClient *pGkClient, H225GatekeeperReject *pGatekeeperReject) +{ + unsigned int x=0; + DListNode *pNode = NULL; + OOTimer *pTimer = NULL; + + if(pGkClient->gkMode == RasUseSpecificGatekeeper) + { + /* delete the corresponding GRQ timer */ + for(x=0; xtimerList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->timerList, x); + pTimer = (OOTimer*)pNode->data; + if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_GRQ_TIMER) + { + memFreePtr(&pGkClient->ctxt, pTimer->cbData); + ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer); + OOTRACEDBGA1("Deleted GRQ Timer.\n"); + break; + } + } + + pGkClient->state = GkClientGkErr; + switch(pGatekeeperReject->rejectReason.t) + { + case T_H225GatekeeperRejectReason_resourceUnavailable: + OOTRACEERR1("Error: Gatekeeper Reject - Resource Unavailable\n"); + break; + case T_H225GatekeeperRejectReason_terminalExcluded: + OOTRACEERR1("Error: Gatekeeper Reject - Terminal Excluded\n"); + break; + case T_H225GatekeeperRejectReason_invalidRevision: + OOTRACEERR1("Error: Gatekeeper Reject - Invalid Revision\n"); + break; + case T_H225GatekeeperRejectReason_undefinedReason: + OOTRACEERR1("Error: Gatekeeper Reject - Undefined Reason\n"); + break; + case T_H225GatekeeperRejectReason_securityDenial: + OOTRACEERR1("Error: Gatekeeper Reject - Security Denial\n"); + break; + case T_H225GatekeeperRejectReason_genericDataReason: + OOTRACEERR1("Error: Gatekeeper Reject - Generic Data Reason\n"); + break; + case T_H225GatekeeperRejectReason_neededFeatureNotSupported: + OOTRACEERR1("Error: Gatekeeper Reject - Needed Feature Not " + "Supported\n"); + break; + case T_H225GatekeeperRejectReason_securityError: + OOTRACEERR1("Error:Gatekeeper Reject - Security Error\n"); + break; + default: + OOTRACEERR1("Error: Gatekeeper Reject - Invalid reason\n"); + } + return OO_OK; + } + OOTRACEDBGB1("Gatekeeper Reject response received for multicast GRQ " + "request\n"); + return OO_OK; + +} + +int ooGkClientHandleGatekeeperConfirm + (ooGkClient *pGkClient, H225GatekeeperConfirm *pGatekeeperConfirm) +{ + int iRet=0; + unsigned int x=0; + DListNode *pNode = NULL; + OOTimer *pTimer = NULL; + H225TransportAddress_ipAddress *pRasAddress; + + if(pGkClient->discoveryComplete) + { + OOTRACEDBGB1("Ignoring GKConfirm as Gatekeeper has been discovered\n"); + return OO_OK; + } + + if(pGatekeeperConfirm->m.gatekeeperIdentifierPresent) + { + pGkClient->gkId.nchars = pGatekeeperConfirm->gatekeeperIdentifier.nchars; + pGkClient->gkId.data = (ASN116BITCHAR*)memAlloc(&pGkClient->ctxt, + sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars); + if(!pGkClient->gkId.data) + { + OOTRACEERR1("Error:Failed to allocate memory for GK ID data\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + memcpy(pGkClient->gkId.data, + pGatekeeperConfirm->gatekeeperIdentifier.data, + sizeof(ASN116BITCHAR)* pGkClient->gkId.nchars); + } + else{ + OOTRACEERR1("ERROR:No Gatekeeper ID present in received GKConfirmed " + "message\n"); + OOTRACEINFO1("Ignoring message and will retransmit GRQ after timeout\n"); + return OO_FAILED; + } + + /* Extract Gatekeeper's RAS address */ + if(pGatekeeperConfirm->rasAddress.t != T_H225TransportAddress_ipAddress) + { + OOTRACEERR1("ERROR:Unsupported RAS address type in received Gk Confirm" + " message.\n"); + pGkClient->state = GkClientGkErr; + return OO_FAILED; + } + pRasAddress = pGatekeeperConfirm->rasAddress.u.ipAddress; + sprintf(pGkClient->gkRasIP, "%d.%d.%d.%d", pRasAddress->ip.data[0], + pRasAddress->ip.data[1], + pRasAddress->ip.data[2], + pRasAddress->ip.data[3]); + pGkClient->gkRasPort = pRasAddress->port; + + pGkClient->discoveryComplete = TRUE; + pGkClient->state = GkClientDiscovered; + OOTRACEINFO1("Gatekeeper Confirmed\n"); + + + /* Delete the corresponding GRQ timer */ + for(x=0; xtimerList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->timerList, x); + pTimer = (OOTimer*)pNode->data; + if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_GRQ_TIMER) + { + memFreePtr(&pGkClient->ctxt, pTimer->cbData); + ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer); + OOTRACEDBGA1("Deleted GRQ Timer.\n"); + break; + } + } + + iRet = ooGkClientSendRRQ(pGkClient, FALSE); + if(iRet != OO_OK) + { + OOTRACEERR1("Error:Failed to send initial RRQ\n"); + return OO_FAILED; + } + return OO_OK; +} + +/** + * Send RRQ. + */ + +int ooGkClientSendRRQ(ooGkClient *pGkClient, ASN1BOOL keepAlive) +{ + int iRet; + H225RasMessage *pRasMsg=NULL; + H225RegistrationRequest *pRegReq=NULL; + OOCTXT *pctxt=NULL; + H225TransportAddress *pTransportAddress=NULL; + H225TransportAddress_ipAddress *pIpAddress=NULL; + ooGkClientTimerCb *cbData =NULL; + + pctxt = &pGkClient->msgCtxt; + + pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage)); + if(!pRasMsg) + { + OOTRACEERR1("Error: Memory allocation for RRQ RAS message failed\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + pRegReq = (H225RegistrationRequest*)memAlloc(pctxt, + sizeof(H225RegistrationRequest)); + if(!pRegReq) + { + OOTRACEERR1("Error:Memory allocation for RRQ failed\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memset(pRegReq, 0, sizeof(H225RegistrationRequest)); + pRasMsg->t = T_H225RasMessage_registrationRequest; + pRasMsg->u.registrationRequest = pRegReq; + + pRegReq->protocolIdentifier = gProtocolID; + pRegReq->m.nonStandardDataPresent=0; + /* Populate CallSignal Address List*/ + pTransportAddress = (H225TransportAddress*) memAlloc(pctxt, + sizeof(H225TransportAddress)); + pIpAddress = (H225TransportAddress_ipAddress*) memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + if(!pTransportAddress || !pIpAddress) + { + OOTRACEERR1("Error:Failed to allocate memory for signalling address of " + "RRQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pTransportAddress->t = T_H225TransportAddress_ipAddress; + pTransportAddress->u.ipAddress = pIpAddress; + ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddress->ip.data); + pIpAddress->ip.numocts = 4; + pIpAddress->port = gH323ep.listenPort; + + dListInit(&pRegReq->callSignalAddress); + dListAppend(pctxt, &pRegReq->callSignalAddress, + (void*)pTransportAddress); + + /* Populate RAS Address List*/ + pTransportAddress = NULL; + pIpAddress = NULL; + pTransportAddress = (H225TransportAddress*) memAlloc(pctxt, + sizeof(H225TransportAddress)); + pIpAddress = (H225TransportAddress_ipAddress*) memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + if(!pTransportAddress || !pIpAddress) + { + OOTRACEERR1("Error:Failed to allocate memory for RAS address of " + "RRQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + pTransportAddress->t = T_H225TransportAddress_ipAddress; + pTransportAddress->u.ipAddress = pIpAddress; + + ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddress->ip.data); + + pIpAddress->ip.numocts = 4; + pIpAddress->port = pGkClient->localRASPort; + + dListInit(&pRegReq->rasAddress); + dListAppend(pctxt, &pRegReq->rasAddress, + (void*)pTransportAddress); + + /* Pose as gateway or terminal as per config */ + if(gH323ep.isGateway) + pRegReq->terminalType.m.gatewayPresent = TRUE; + else + pRegReq->terminalType.m.terminalPresent = TRUE; + + pRegReq->terminalType.m.vendorPresent=TRUE; + ooGkClientFillVendor(pGkClient, &pRegReq->terminalType.vendor ); + + pRegReq->m.terminalAliasPresent=TRUE; + if(OO_OK != ooPopulateAliasList(pctxt, gH323ep.aliases, + &pRegReq->terminalAlias)) + { + OOTRACEERR1("Error filling alias for RRQ\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + pRegReq->m.gatekeeperIdentifierPresent=TRUE; + pRegReq->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars; + pRegReq->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc + (pctxt, pGkClient->gkId.nchars*sizeof(ASN116BITCHAR)); + if(!pRegReq->gatekeeperIdentifier.data) + { + OOTRACEERR1("Error: Failed to allocate memory for GKIdentifier in RRQ " + "message.\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memcpy(pRegReq->gatekeeperIdentifier.data, pGkClient->gkId.data, + pGkClient->gkId.nchars*sizeof(ASN116BITCHAR)); + + ooGkClientFillVendor(pGkClient, &pRegReq->endpointVendor); + + pRegReq->m.willSupplyUUIEsPresent=TRUE; + pRegReq->willSupplyUUIEs=FALSE; + + pRegReq->requestSeqNum = pGkClient->requestSeqNum++; + if(!pRegReq->requestSeqNum) + pRegReq->requestSeqNum = pGkClient->requestSeqNum++; + + pRegReq->discoveryComplete= pGkClient->discoveryComplete; + pRegReq->m.keepAlivePresent=TRUE; + pRegReq->keepAlive= keepAlive; + + /* + * Cisco Gatekeeper re-registration fix. Thanks to Mike Tubby (mike@tubby.org) 28feb2007 + * Without this patch initial registration works, but re-registration fails! + * + * For light-weight re-registration, keepalive is set true + * GK needs rasAddress, keepAlive, endpointIdentifier, gatekeeperIdentifier, + * tokens, and timeToLive + * GK will ignore all other params if KeepAlive is set. + * + */ + if(keepAlive) { + /* KeepAlive, re-registration message... + allocate storage for endpoint-identifier, and populate it from what the + GK told us from the previous RCF. Only allocate on the first pass thru here */ + pRegReq->endpointIdentifier.data = + (ASN116BITCHAR*)memAlloc(pctxt, pGkClient->gkId.nchars*sizeof(ASN116BITCHAR)); + if (pRegReq->endpointIdentifier.data) { + pRegReq->endpointIdentifier.nchars = pGkClient->endpointId.nchars; + pRegReq->m.endpointIdentifierPresent = TRUE; + memcpy(pRegReq->endpointIdentifier.data, pGkClient->endpointId.data, pGkClient->endpointId.nchars*sizeof(ASN116BITCHAR)); + OOTRACEINFO1("Sending RRQ for re-registration (with EndpointID)\n"); + } + else { + OOTRACEERR1("Error: Failed to allocate memory for EndpointIdentifier in RRQ \n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + } + + pRegReq->m.timeToLivePresent = TRUE; + pRegReq->timeToLive = pGkClient->regTimeout; + + iRet = ooGkClientSendMsg(pGkClient, pRasMsg); + if(iRet != OO_OK) + { + OOTRACEERR1("Error: Failed to send RRQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + OOTRACEINFO1("Sent RRQ message \n"); + /* Start RRQ Timer */ + cbData = (ooGkClientTimerCb*) memAlloc + (&pGkClient->ctxt, sizeof(ooGkClientTimerCb)); + if(!cbData) + { + OOTRACEERR1("Error:Failed to allocate memory to RRQ timer callback\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + cbData->timerType = OO_RRQ_TIMER; + cbData->pGkClient = pGkClient; + if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, + &ooGkClientRRQTimerExpired, pGkClient->rrqTimeout, + cbData, FALSE)) + { + OOTRACEERR1("Error:Unable to create GRQ timer.\n "); + memFreePtr(&pGkClient->ctxt, cbData); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + return OO_OK; +} + + + +/** + * Manage incoming RCF message. + */ + +int ooGkClientHandleRegistrationConfirm + (ooGkClient *pGkClient, H225RegistrationConfirm *pRegistrationConfirm) +{ + int i=0; + unsigned int x=0; + OOTimer *pTimer = NULL; + DListNode *pNode = NULL; + H225TransportAddress *pCallSigAddr=NULL; + ooGkClientTimerCb *cbData; + ASN1UINT regTTL=0; + /* Extract Endpoint Id */ + pGkClient->endpointId.nchars = + pRegistrationConfirm->endpointIdentifier.nchars; + pGkClient->endpointId.data = (ASN116BITCHAR*)memAlloc(&pGkClient->ctxt, + sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars); + if(!pGkClient->endpointId.data) + { + OOTRACEERR1("Error:Failed to allocate memory for endpoint Id.\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + memcpy(pGkClient->endpointId.data, + pRegistrationConfirm->endpointIdentifier.data, + sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars); + + /* Extract CallSignalling Address */ + for(i=0; i<(int)pRegistrationConfirm->callSignalAddress.count; i++) + { + pNode = dListFindByIndex(&pRegistrationConfirm->callSignalAddress, i); + if(!pNode) + { + OOTRACEERR1("Error:Invalid Registration confirmed message\n"); + OOTRACEINFO1("Ignoring RCF, will retransmit RRQ after timeout\n"); + return OO_FAILED; + } + pCallSigAddr = (H225TransportAddress*)pNode->data; + if(pCallSigAddr->t != T_H225TransportAddress_ipAddress) + continue; + sprintf(pGkClient->gkCallSignallingIP, "%d.%d.%d.%d", + pCallSigAddr->u.ipAddress->ip.data[0], + pCallSigAddr->u.ipAddress->ip.data[1], + pCallSigAddr->u.ipAddress->ip.data[2], + pCallSigAddr->u.ipAddress->ip.data[3]); + pGkClient->gkCallSignallingPort = pCallSigAddr->u.ipAddress->port; + } + + /* Update list of registered aliases*/ + if(pRegistrationConfirm->m.terminalAliasPresent) + { + ooGkClientUpdateRegisteredAliases(pGkClient, + &pRegistrationConfirm->terminalAlias, TRUE); + } + else{/* Everything registered*/ + ooGkClientUpdateRegisteredAliases(pGkClient, NULL, TRUE); + } + + /* Is keepAlive supported */ + if(pRegistrationConfirm->m.timeToLivePresent) + { + pGkClient->regTimeout = pRegistrationConfirm->timeToLive; + OOTRACEINFO2("Gatekeeper supports KeepAlive, Registration TTL is %d\n", + pRegistrationConfirm->timeToLive); + + if(pGkClient->regTimeout > DEFAULT_TTL_OFFSET) + regTTL = pGkClient->regTimeout - DEFAULT_TTL_OFFSET; + else + regTTL = pGkClient->regTimeout; + + cbData = (ooGkClientTimerCb*) memAlloc + (&pGkClient->ctxt, sizeof(ooGkClientTimerCb)); + if(!cbData) + { + OOTRACEERR1("Error:Failed to allocate memory for Regisration timer." + "\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + cbData->timerType = OO_REG_TIMER; + cbData->pGkClient = pGkClient; + if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, + &ooGkClientREGTimerExpired, regTTL, + cbData, FALSE)) + { + OOTRACEERR1("Error:Unable to create REG timer.\n "); + memFreePtr(&pGkClient->ctxt, cbData); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + } + else{ + pGkClient->regTimeout = 0; + OOTRACEINFO1("Gatekeeper does not support KeepAlive.\n"); + } + /* Extract Pre-Granted ARQ */ + if(pRegistrationConfirm->m.preGrantedARQPresent) + { + memcpy(&pGkClient->gkInfo.preGrantedARQ, + &pRegistrationConfirm->preGrantedARQ, + sizeof(H225RegistrationConfirm_preGrantedARQ)); + } + + + /* First delete the corresponding RRQ timer */ + pNode = NULL; + for(x=0; xtimerList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->timerList, x); + pTimer = (OOTimer*)pNode->data; + if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_RRQ_TIMER) + { + memFreePtr(&pGkClient->ctxt, pTimer->cbData); + ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer); + OOTRACEDBGA1("Deleted RRQ Timer.\n"); + break; + } + } + pGkClient->state = GkClientRegistered; + if(pGkClient->callbacks.onReceivedRegistrationConfirm) + pGkClient->callbacks.onReceivedRegistrationConfirm(pRegistrationConfirm, + gH323ep.aliases); + return OO_OK; +} + +int ooGkClientHandleRegistrationReject + (ooGkClient *pGkClient, H225RegistrationReject *pRegistrationReject) +{ + int iRet=0; + unsigned int x=0; + DListNode *pNode = NULL; + OOTimer *pTimer = NULL; + /* First delete the corresponding RRQ timer */ + for(x=0; xtimerList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->timerList, x); + pTimer = (OOTimer*)pNode->data; + if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_RRQ_TIMER) + { + memFreePtr(&pGkClient->ctxt, pTimer->cbData); + ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer); + OOTRACEDBGA1("Deleted RRQ Timer.\n"); + break; + } + } + + switch(pRegistrationReject->rejectReason.t) + { + case T_H225RegistrationRejectReason_discoveryRequired: + OOTRACEINFO1("RRQ Rejected - Discovery Required\n"); + + pGkClient->discoveryComplete = FALSE; + pGkClient->state = GkClientIdle; + pGkClient->rrqRetries = 0; + pGkClient->grqRetries = 0; + if(OO_OK != ooGkClientSendGRQ(pGkClient)) + { + OOTRACEERR1("Error:Failed to send GRQ message\n"); + return OO_FAILED; + } + return OO_OK; + case T_H225RegistrationRejectReason_invalidRevision: + OOTRACEERR1("RRQ Rejected - Invalid Revision\n"); + break; + case T_H225RegistrationRejectReason_invalidCallSignalAddress: + OOTRACEERR1("RRQ Rejected - Invalid CallSignalAddress\n"); + break; + case T_H225RegistrationRejectReason_invalidRASAddress: + OOTRACEERR1("RRQ Rejected - Invalid RAS Address\n"); + break; + case T_H225RegistrationRejectReason_duplicateAlias: + OOTRACEERR1("RRQ Rejected - Duplicate Alias\n"); + break; + case T_H225RegistrationRejectReason_invalidTerminalType: + OOTRACEERR1("RRQ Rejected - Invalid Terminal Type\n"); + break; + case T_H225RegistrationRejectReason_undefinedReason: + OOTRACEERR1("RRQ Rejected - Undefined Reason\n"); + break; + case T_H225RegistrationRejectReason_transportNotSupported: + OOTRACEERR1("RRQ Rejected - Transport Not supported\n"); + break; + case T_H225RegistrationRejectReason_transportQOSNotSupported: + OOTRACEERR1("RRQ Rejected - Transport QOS Not Supported\n"); + break; + case T_H225RegistrationRejectReason_resourceUnavailable: + OOTRACEERR1("RRQ Rejected - Resource Unavailable\n"); + break; + case T_H225RegistrationRejectReason_invalidAlias: + OOTRACEERR1("RRQ Rejected - Invalid Alias\n"); + break; + case T_H225RegistrationRejectReason_securityDenial: + OOTRACEERR1("RRQ Rejected - Security Denial\n"); + break; + case T_H225RegistrationRejectReason_fullRegistrationRequired: + OOTRACEINFO1("RRQ Rejected - Full Registration Required\n"); + pGkClient->state = GkClientDiscovered; + pGkClient->rrqRetries = 0; + iRet = ooGkClientSendRRQ(pGkClient, 0); /* No keepAlive */ + if(iRet != OO_OK){ + OOTRACEERR1("\nError: Full Registration transmission failed\n"); + return OO_FAILED; + } + return OO_OK; + case T_H225RegistrationRejectReason_additiveRegistrationNotSupported: + OOTRACEERR1("RRQ Rejected - Additive Registration Not Supported\n"); + break; + case T_H225RegistrationRejectReason_invalidTerminalAliases: + OOTRACEERR1("RRQ Rejected - Invalid Terminal Aliases\n"); + break; + case T_H225RegistrationRejectReason_genericDataReason: + OOTRACEERR1("RRQ Rejected - Generic Data Reason\n"); + break; + case T_H225RegistrationRejectReason_neededFeatureNotSupported: + OOTRACEERR1("RRQ Rejected - Needed Feature Not Supported\n"); + break; + case T_H225RegistrationRejectReason_securityError: + OOTRACEERR1("RRQ Rejected - Security Error\n"); + break; + default: + OOTRACEINFO1("RRQ Rejected - Invalid Reason\n"); + } + pGkClient->state = GkClientGkErr; + return OO_OK; +} + + +int ooGkClientSendURQ(ooGkClient *pGkClient, ooAliases *aliases) +{ + int iRet; + H225RasMessage *pRasMsg=NULL; + H225UnregistrationRequest *pUnregReq=NULL; + OOCTXT *pctxt=NULL; + H225TransportAddress *pTransportAddress=NULL; + H225TransportAddress_ipAddress *pIpAddress=NULL; + + pctxt = &pGkClient->msgCtxt; + + OOTRACEDBGA1("Building Unregistration Request message\n"); + + pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage)); + if(!pRasMsg) + { + OOTRACEERR1("Error: Memory allocation for URQ RAS message failed\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + pUnregReq = (H225UnregistrationRequest*)memAlloc(pctxt, + sizeof(H225UnregistrationRequest)); + if(!pUnregReq) + { + OOTRACEERR1("Error:Memory allocation for URQ failed\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memset(pUnregReq, 0, sizeof(H225UnregistrationRequest)); + pRasMsg->t = T_H225RasMessage_unregistrationRequest; + pRasMsg->u.unregistrationRequest = pUnregReq; + + pUnregReq->requestSeqNum = pGkClient->requestSeqNum++; + if(!pUnregReq->requestSeqNum) + pUnregReq->requestSeqNum = pGkClient->requestSeqNum++; + + + + /* Populate CallSignal Address List*/ + pTransportAddress = (H225TransportAddress*) memAlloc(pctxt, + sizeof(H225TransportAddress)); + pIpAddress = (H225TransportAddress_ipAddress*) memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + if(!pTransportAddress || !pIpAddress) + { + OOTRACEERR1("Error:Failed to allocate memory for signalling address of " + "RRQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pTransportAddress->t = T_H225TransportAddress_ipAddress; + pTransportAddress->u.ipAddress = pIpAddress; + ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddress->ip.data); + pIpAddress->ip.numocts = 4; + pIpAddress->port = gH323ep.listenPort; + + dListInit(&pUnregReq->callSignalAddress); + dListAppend(pctxt, &pUnregReq->callSignalAddress, + (void*)pTransportAddress); + + /* Populate Endpoint Identifier */ + pUnregReq->m.endpointIdentifierPresent = TRUE; + pUnregReq->endpointIdentifier.nchars = pGkClient->endpointId.nchars; + pUnregReq->endpointIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt, + sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars); + if(!pUnregReq->endpointIdentifier.data) + { + OOTRACEERR1("Error: Failed to allocate memory for EndPoint Id in URQ " + "message.\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memcpy((void*)pUnregReq->endpointIdentifier.data, + (void*)pGkClient->endpointId.data, + sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars); + + /* Populate gatekeeper identifier */ + pUnregReq->m.gatekeeperIdentifierPresent = TRUE; + pUnregReq->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars; + pUnregReq->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt, + sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars); + if(!pUnregReq->gatekeeperIdentifier.data) + { + OOTRACEERR1("Error:Failed to allocate memory for GKID of URQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memcpy((void*)pUnregReq->gatekeeperIdentifier.data, + (void*)pGkClient->gkId.data, + sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars); + + /* Check whether specific aliases are to be unregistered*/ + if(aliases) + { + pUnregReq->m.endpointAliasPresent = TRUE; + ooPopulateAliasList(pctxt, aliases, &pUnregReq->endpointAlias); + } + + + iRet = ooGkClientSendMsg(pGkClient, pRasMsg); + if(iRet != OO_OK) + { + OOTRACEERR1("Error:Failed to send UnregistrationRequest message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pGkClient->state = GkClientUnregistered; + OOTRACEINFO1("Unregistration Request message sent.\n"); + + return OO_OK; +} + + + +int ooGkClientHandleUnregistrationRequest + (ooGkClient *pGkClient, H225UnregistrationRequest * punregistrationRequest) +{ + int iRet=0; + + /* Lets first send unregistration confirm message back to gatekeeper*/ + ooGkClientSendUnregistrationConfirm(pGkClient, + punregistrationRequest->requestSeqNum); + + if(punregistrationRequest->m.endpointAliasPresent) + { + OOTRACEINFO1("Gatekeeper requested a list of aliases be unregistered\n"); + ooGkClientUpdateRegisteredAliases(pGkClient, + &punregistrationRequest->endpointAlias, FALSE); + } + else{ + + OOTRACEINFO1("Gatekeeper requested a all aliases to be unregistered\n"); + ooGkClientUpdateRegisteredAliases(pGkClient, NULL, FALSE); + /* Send a fresh Registration request and if that fails, go back to + Gatekeeper discovery. + */ + OOTRACEINFO1("Sending fresh RRQ - as unregistration request received\n"); + pGkClient->rrqRetries = 0; + pGkClient->state = GkClientDiscovered; + + iRet = ooGkClientSendRRQ(pGkClient, 0); + if(iRet != OO_OK) + { + OOTRACEERR1("Error: Failed to send RRQ message\n"); + return OO_FAILED; + } + } + + + if(pGkClient->callbacks.onReceivedUnregistrationRequest) + pGkClient->callbacks.onReceivedUnregistrationRequest( + punregistrationRequest, gH323ep.aliases); + return OO_OK; +} + +int ooGkClientSendUnregistrationConfirm(ooGkClient *pGkClient, unsigned reqNo) +{ + int iRet = OO_OK; + OOCTXT *pctxt = &pGkClient->msgCtxt; + H225RasMessage *pRasMsg=NULL; + H225UnregistrationConfirm *pUCF=NULL; + + pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage)); + pUCF = (H225UnregistrationConfirm*)memAlloc(pctxt, + sizeof(H225UnregistrationConfirm)); + if(!pRasMsg || !pUCF) + { + OOTRACEERR1("Error: Memory allocation for UCF RAS message failed\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pRasMsg->t = T_H225RasMessage_unregistrationConfirm; + pRasMsg->u.unregistrationConfirm = pUCF; + memset(pUCF, 0, sizeof(H225UnregistrationConfirm)); + + pUCF->requestSeqNum = reqNo; + + iRet = ooGkClientSendMsg(pGkClient, pRasMsg); + if(iRet != OO_OK) + { + OOTRACEERR1("Error:Failed to send UnregistrationConfirm message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + OOTRACEINFO1("Unregistration Confirm message sent for \n"); + memReset(pctxt); + + return OO_OK; +} + + + + +int ooGkClientSendAdmissionRequest + (ooGkClient *pGkClient, OOH323CallData *call, ASN1BOOL retransmit) +{ + int iRet = 0; + unsigned int x; + DListNode *pNode; + ooGkClientTimerCb *cbData=NULL; + H225RasMessage *pRasMsg=NULL; + OOCTXT* pctxt; + H225AdmissionRequest *pAdmReq=NULL; + H225TransportAddress_ipAddress *pIpAddressLocal =NULL, *pIpAddressRemote=NULL; + ooAliases *destAliases = NULL, *srcAliases=NULL; + RasCallAdmissionInfo *pCallAdmInfo=NULL; + pctxt = &pGkClient->msgCtxt; + + OOTRACEDBGA3("Building Admission Request for call (%s, %s)\n", + call->callType, call->callToken); + pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage)); + if(!pRasMsg) + { + OOTRACEERR3("Error:Memory - ooGkClientSendAdmissionRequest - " + "pRasMsg(%s, %s)\n", call->callType, call->callToken); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pRasMsg->t = T_H225RasMessage_admissionRequest; + pAdmReq = (H225AdmissionRequest*) memAlloc(pctxt, + sizeof(H225AdmissionRequest)); + if(!pAdmReq) + { + OOTRACEERR3("Error:Memory - ooGkClientSendAdmissionRequest - " + "pAdmReq(%s, %s)\n", call->callType, call->callToken); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memset(pAdmReq, 0, sizeof(H225AdmissionRequest)); + pRasMsg->u.admissionRequest = pAdmReq; + + /* Populate call signalling addresses */ + pIpAddressLocal = (H225TransportAddress_ipAddress*)memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + if(!ooUtilsIsStrEmpty(call->remoteIP)) + pIpAddressRemote = (H225TransportAddress_ipAddress*)memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + + if(!pIpAddressLocal || (!ooUtilsIsStrEmpty(call->remoteIP) && (!pIpAddressRemote))) + { + OOTRACEERR1("Error:Failed to allocate memory for Call Signalling " + "Addresses of ARQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + ooSocketConvertIpToNwAddr(pGkClient->localRASIP, pIpAddressLocal->ip.data); + + pIpAddressLocal->ip.numocts = 4; + pIpAddressLocal->port = gH323ep.listenPort; + + if(!ooUtilsIsStrEmpty(call->remoteIP)) + { + ooSocketConvertIpToNwAddr(call->remoteIP, pIpAddressRemote->ip.data); + pIpAddressRemote->ip.numocts = 4; + pIpAddressRemote->port = call->remotePort; + } + + if(!strcmp(call->callType, "incoming")) + { + pAdmReq->m.destCallSignalAddressPresent = TRUE; + pAdmReq->destCallSignalAddress.t = T_H225TransportAddress_ipAddress; + pAdmReq->destCallSignalAddress.u.ipAddress = pIpAddressLocal; + if(!ooUtilsIsStrEmpty(call->remoteIP)) + { + pAdmReq->m.srcCallSignalAddressPresent = TRUE; + pAdmReq->srcCallSignalAddress.t = T_H225TransportAddress_ipAddress; + pAdmReq->srcCallSignalAddress.u.ipAddress = pIpAddressRemote; + } + } + else { + pAdmReq->m.srcCallSignalAddressPresent = TRUE; + pAdmReq->srcCallSignalAddress.t = T_H225TransportAddress_ipAddress; + pAdmReq->srcCallSignalAddress.u.ipAddress = pIpAddressLocal; + if(!ooUtilsIsStrEmpty(call->remoteIP)) + { + pAdmReq->m.destCallSignalAddressPresent = TRUE; + pAdmReq->destCallSignalAddress.t = T_H225TransportAddress_ipAddress; + pAdmReq->destCallSignalAddress.u.ipAddress = pIpAddressRemote; + } + } + + /* Populate seq number */ + pAdmReq->requestSeqNum = pGkClient->requestSeqNum++; + if(!pAdmReq->requestSeqNum) + pAdmReq->requestSeqNum = pGkClient->requestSeqNum++; + + /* Populate call type - For now only PointToPoint supported*/ + pAdmReq->callType.t = T_H225CallType_pointToPoint; + + /* Add call model to message*/ + pAdmReq->m.callModelPresent = 1; + if(OO_TESTFLAG(call->flags, OO_M_GKROUTED)) + pAdmReq->callModel.t = T_H225CallModel_gatekeeperRouted; + else + pAdmReq->callModel.t = T_H225CallModel_direct; + + /* Populate Endpoint Identifier */ + pAdmReq->endpointIdentifier.nchars = pGkClient->endpointId.nchars; + pAdmReq->endpointIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt, + sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars); + if(!pAdmReq->endpointIdentifier.data) + { + OOTRACEERR3("Error:Memory - ooGkClientSendAdmissionRequest - " + "endpointIdentifier.data(%s, %s)\n", call->callType, + call->callToken); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memcpy((void*)pAdmReq->endpointIdentifier.data, + (void*)pGkClient->endpointId.data, + sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars); + + /* Get Destination And source aliases for call - */ + if(!strcmp(call->callType, "incoming")) + { + if(call->ourAliases) + destAliases = call->ourAliases; + else + destAliases = gH323ep.aliases; + + srcAliases = call->remoteAliases; + } + else { + if(call->ourAliases) + srcAliases = call->ourAliases; + else + srcAliases = gH323ep.aliases; + + destAliases = call->remoteAliases; + } + + /* Populate destination info */ + if(destAliases) + { + pAdmReq->m.destinationInfoPresent = 1; + if(OO_OK != ooPopulateAliasList(&pGkClient->msgCtxt, destAliases, + &pAdmReq->destinationInfo)) + { + OOTRACEERR1("Error:Failed to populate destination aliases - " + "ARQ message\n"); + pGkClient->state = GkClientFailed; + memReset(pctxt); + return OO_FAILED; + } + } + + /* Populate Source Info */ + if(srcAliases) + { + iRet = ooPopulateAliasList(&pGkClient->msgCtxt, srcAliases, + &pAdmReq->srcInfo); + if(OO_OK != iRet) + { + OOTRACEERR1("Error:Failed to populate source aliases -ARQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + } + + /* Populate bandwidth*/ + pAdmReq->bandWidth = DEFAULT_BW_REQUEST; + /* Populate call Reference */ + pAdmReq->callReferenceValue = call->callReference; + + /* populate conferenceID */ + memcpy((void*)&pAdmReq->conferenceID, (void*)&call->confIdentifier, + sizeof(H225ConferenceIdentifier)); + /*populate answerCall */ + if(!strcmp(call->callType, "incoming")) + pAdmReq->answerCall = TRUE; + else + pAdmReq->answerCall = FALSE; + + /* Populate CanMapAlias */ + pAdmReq->m.canMapAliasPresent = TRUE; + pAdmReq->canMapAlias = FALSE; + + /* Populate call identifier */ + pAdmReq->m.callIdentifierPresent = TRUE; + memcpy((void*)&pAdmReq->callIdentifier, (void*)&call->callIdentifier, + sizeof(H225CallIdentifier)); + + /* Populate Gatekeeper Id */ + pAdmReq->m.gatekeeperIdentifierPresent = TRUE; + pAdmReq->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars; + pAdmReq->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt, + sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars); + if(!pAdmReq->gatekeeperIdentifier.data) + { + OOTRACEERR1("Error:Failed to allocate memory for GKID of ARQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memcpy((void*)pAdmReq->gatekeeperIdentifier.data, + (void*)pGkClient->gkId.data, + sizeof(ASN116BITCHAR)*pGkClient->gkId.nchars); + + pAdmReq->m.willSupplyUUIEsPresent = 1; + pAdmReq->willSupplyUUIEs = FALSE; + + /* Create RasCallAdmissionInfo */ + if(!retransmit) + { + pCallAdmInfo = (RasCallAdmissionInfo*)memAlloc(&pGkClient->ctxt, + sizeof(RasCallAdmissionInfo)); + if(!pCallAdmInfo) + { + OOTRACEERR1("Error: Failed to allocate memory for new CallAdmission" + " Info entry\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + pCallAdmInfo->call = call; + pCallAdmInfo->retries = 0; + pCallAdmInfo->requestSeqNum = pAdmReq->requestSeqNum; + dListAppend(&pGkClient->ctxt, &pGkClient->callsPendingList,pCallAdmInfo); + } + else{ + for(x=0; xcallsPendingList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->callsPendingList, x); + pCallAdmInfo = (RasCallAdmissionInfo*)pNode->data; + if(pCallAdmInfo->call->callReference == call->callReference) + { + pCallAdmInfo->requestSeqNum = pAdmReq->requestSeqNum; + break; + } + } + } + + iRet = ooGkClientSendMsg(pGkClient, pRasMsg); + if(iRet != OO_OK) + { + OOTRACEERR1("Error:Failed to send AdmissionRequest message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + OOTRACEINFO3("Admission Request message sent for (%s, %s)\n", + call->callType, call->callToken); + memReset(pctxt); + + /* Add ARQ timer */ + cbData = (ooGkClientTimerCb*) memAlloc + (&pGkClient->ctxt, sizeof(ooGkClientTimerCb)); + if(!cbData) + { + OOTRACEERR1("Error:Failed to allocate memory for Regisration timer." + "\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + cbData->timerType = OO_ARQ_TIMER; + cbData->pGkClient = pGkClient; + cbData->pAdmInfo = pCallAdmInfo; + if(!ooTimerCreate(&pGkClient->ctxt, &pGkClient->timerList, + &ooGkClientARQTimerExpired, pGkClient->arqTimeout, + cbData, FALSE)) + { + OOTRACEERR1("Error:Unable to create ARQ timer.\n "); + memFreePtr(&pGkClient->ctxt, cbData); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + return OO_OK; +} + +/** + * Manage incoming ACF message. + */ + +int ooGkClientHandleAdmissionConfirm + (ooGkClient *pGkClient, H225AdmissionConfirm *pAdmissionConfirm) +{ + RasCallAdmissionInfo* pCallAdmInfo=NULL; + unsigned int x, y; + DListNode *pNode, *pNode1=NULL; + H225TransportAddress_ipAddress * ipAddress=NULL; + OOTimer *pTimer = NULL; + char ip[20]; + + /* Search call in pending calls list */ + for(x=0 ; xcallsPendingList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->callsPendingList, x); + pCallAdmInfo = (RasCallAdmissionInfo*) pNode->data; + if(pCallAdmInfo->requestSeqNum == pAdmissionConfirm->requestSeqNum) + { + OOTRACEDBGC3("Found Pending call(%s, %s)\n", + pCallAdmInfo->call->callType, + pCallAdmInfo->call->callToken); + /* Populate Remote IP */ + if(pAdmissionConfirm->destCallSignalAddress.t != + T_H225TransportAddress_ipAddress) + { + OOTRACEERR1("Error:Destination Call Signal Address provided by" + "Gatekeeper is not an IPv4 address\n"); + OOTRACEINFO1("Ignoring ACF, will wait for timeout and retransmit " + "ARQ\n"); + return OO_FAILED; + } + ipAddress = pAdmissionConfirm->destCallSignalAddress.u.ipAddress; + + sprintf(ip, "%d.%d.%d.%d", ipAddress->ip.data[0], + ipAddress->ip.data[1], + ipAddress->ip.data[2], + ipAddress->ip.data[3]); + if(strcmp(ip, "0.0.0.0")) + strcpy(pCallAdmInfo->call->remoteIP, ip); + pCallAdmInfo->call->remotePort = ipAddress->port; + /* Update call model */ + if(pAdmissionConfirm->callModel.t == T_H225CallModel_direct) + { + if(OO_TESTFLAG(pCallAdmInfo->call->flags, OO_M_GKROUTED)) + { + OOTRACEINFO3("Gatekeeper changed call model from GkRouted to " + "direct. (%s, %s)\n", pCallAdmInfo->call->callType, + pCallAdmInfo->call->callToken); + OO_CLRFLAG(pCallAdmInfo->call->flags, OO_M_GKROUTED); + } + } + + if(pAdmissionConfirm->callModel.t == T_H225CallModel_gatekeeperRouted) + { + if(!OO_TESTFLAG(pCallAdmInfo->call->flags, OO_M_GKROUTED)) + { + OOTRACEINFO3("Gatekeeper changed call model from direct to " + "GkRouted. (%s, %s)\n", + pCallAdmInfo->call->callType, + pCallAdmInfo->call->callToken); + OO_SETFLAG(pCallAdmInfo->call->flags, OO_M_GKROUTED); + } + } + + /* Delete ARQ timer */ + for(y=0; ytimerList.count; y++) + { + pNode1 = dListFindByIndex(&pGkClient->timerList, y); + pTimer = (OOTimer*)pNode1->data; + if(((ooGkClientTimerCb*)pTimer->cbData)->timerType & OO_ARQ_TIMER) + { + if(((ooGkClientTimerCb*)pTimer->cbData)->pAdmInfo == + pCallAdmInfo) + { + memFreePtr(&pGkClient->ctxt, pTimer->cbData); + ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, + pTimer); + OOTRACEDBGA1("Deleted ARQ Timer.\n"); + break; + } + } + } + OOTRACEINFO3("Admission Confirm message received for (%s, %s)\n", + pCallAdmInfo->call->callType, + pCallAdmInfo->call->callToken); + ooH323CallAdmitted( pCallAdmInfo->call); + dListRemove(&pGkClient->callsPendingList, pNode); + dListAppend(&pGkClient->ctxt, &pGkClient->callsAdmittedList, + pNode->data); + memFreePtr(&pGkClient->ctxt, pNode); + return OO_OK; + break; + } + else + { + pNode = pNode->next; + } + } + OOTRACEERR1("Error: Failed to process ACF as there is no corresponding " + "pending call\n"); + return OO_OK; +} + + +int ooGkClientHandleAdmissionReject + (ooGkClient *pGkClient, H225AdmissionReject *pAdmissionReject) +{ + RasCallAdmissionInfo* pCallAdmInfo=NULL; + unsigned int x; + DListNode *pNode=NULL; + OOH323CallData *call=NULL; + + /* Search call in pending calls list */ + for(x=0 ; xcallsPendingList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->callsPendingList, x); + pCallAdmInfo = (RasCallAdmissionInfo*) pNode->data; + if(pCallAdmInfo->requestSeqNum == pAdmissionReject->requestSeqNum) + break; + pNode = NULL; + pCallAdmInfo = NULL; + } + + if(!pCallAdmInfo) + { + OOTRACEWARN2("Received admission reject with request number %d can not" + " be matched with any pending call.\n", + pAdmissionReject->requestSeqNum); + return OO_OK; + } + else{ + call = pCallAdmInfo->call; + dListRemove(&pGkClient->callsPendingList, pNode); + memFreePtr(&pGkClient->ctxt, pCallAdmInfo); + memFreePtr(&pGkClient->ctxt, pNode); + } + + OOTRACEINFO4("Admission Reject message received with reason code %d for " + "(%s, %s)\n", pAdmissionReject->rejectReason.t, call->callType, + call->callToken); + + call->callState = OO_CALL_CLEAR; + + switch(pAdmissionReject->rejectReason.t) + { + case T_H225AdmissionRejectReason_calledPartyNotRegistered: + call->callEndReason = OO_REASON_GK_NOCALLEDUSER; + break; + case T_H225AdmissionRejectReason_invalidPermission: + case T_H225AdmissionRejectReason_requestDenied: + case T_H225AdmissionRejectReason_undefinedReason: + call->callEndReason = OO_REASON_GK_CLEARED; + break; + case T_H225AdmissionRejectReason_callerNotRegistered: + call->callEndReason = OO_REASON_GK_NOCALLERUSER; + break; + case T_H225AdmissionRejectReason_exceedsCallCapacity: + case T_H225AdmissionRejectReason_resourceUnavailable: + call->callEndReason = OO_REASON_GK_NORESOURCES; + break; + case T_H225AdmissionRejectReason_noRouteToDestination: + case T_H225AdmissionRejectReason_unallocatedNumber: + call->callEndReason = OO_REASON_GK_UNREACHABLE; + break; + case T_H225AdmissionRejectReason_routeCallToGatekeeper: + case T_H225AdmissionRejectReason_invalidEndpointIdentifier: + case T_H225AdmissionRejectReason_securityDenial: + case T_H225AdmissionRejectReason_qosControlNotSupported: + case T_H225AdmissionRejectReason_incompleteAddress: + case T_H225AdmissionRejectReason_aliasesInconsistent: + case T_H225AdmissionRejectReason_routeCallToSCN: + case T_H225AdmissionRejectReason_collectDestination: + case T_H225AdmissionRejectReason_collectPIN: + case T_H225AdmissionRejectReason_genericDataReason: + case T_H225AdmissionRejectReason_neededFeatureNotSupported: + case T_H225AdmissionRejectReason_securityErrors: + case T_H225AdmissionRejectReason_securityDHmismatch: + case T_H225AdmissionRejectReason_extElem1: + call->callEndReason = OO_REASON_GK_CLEARED; + break; + } + + return OO_OK; +} + +/** + * This function is invoked to request call disengage to gatekeeper. + * + * @param szCallToken Call token. + * + * @return Completion status - 0 on success, -1 on failure + */ + +int ooGkClientSendDisengageRequest(ooGkClient *pGkClient, OOH323CallData *call) +{ + int iRet = 0; + unsigned int x; + H225RasMessage *pRasMsg=NULL; + OOCTXT *pctxt = NULL; + DListNode *pNode = NULL; + H225DisengageRequest * pDRQ = NULL; + RasCallAdmissionInfo* pCallAdmInfo=NULL; + pctxt = &pGkClient->msgCtxt; + + OOTRACEINFO3("Sending disengage Request for call. (%s, %s)\n", + call->callType, call->callToken); + + pRasMsg = (H225RasMessage*)memAlloc(pctxt, sizeof(H225RasMessage)); + if(!pRasMsg) + { + OOTRACEERR1("Error: Memory allocation for DRQ RAS message failed\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + pRasMsg->t = T_H225RasMessage_disengageRequest; + pDRQ = (H225DisengageRequest*) memAlloc(pctxt, + sizeof(H225DisengageRequest)); + if(!pDRQ) + { + OOTRACEERR1("Error: Failed to allocate memory for DRQ message\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + + memset(pDRQ, 0, sizeof(H225DisengageRequest)); + pRasMsg->u.disengageRequest = pDRQ; + + pDRQ->requestSeqNum = pGkClient->requestSeqNum++; + if(!pDRQ->requestSeqNum ) + pDRQ->requestSeqNum = pGkClient->requestSeqNum++; + + + pDRQ->endpointIdentifier.nchars = pGkClient->endpointId.nchars; + pDRQ->endpointIdentifier.data = (ASN116BITCHAR*)memAlloc(pctxt, + sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars); + if(!pDRQ->endpointIdentifier.data) + { + OOTRACEERR1("Error: Failed to allocate memory for EndPoint Id in DRQ " + "message.\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memcpy((void*)pDRQ->endpointIdentifier.data, + (void*)pGkClient->endpointId.data, + sizeof(ASN116BITCHAR)*pGkClient->endpointId.nchars); + + memcpy((void*)&pDRQ->conferenceID, (void*)&call->confIdentifier, + sizeof(H225ConferenceIdentifier)); + + pDRQ->callReferenceValue = call->callReference; + + pDRQ->disengageReason.t = T_H225DisengageReason_normalDrop; + + pDRQ->m.answeredCallPresent = 1; + if(!strcmp(call->callType, "incoming")) + pDRQ->answeredCall = 1; + else + pDRQ->answeredCall = 0; + + pDRQ->m.callIdentifierPresent = 1; + memcpy((void*)&pDRQ->callIdentifier, (void*)&call->callIdentifier, + sizeof(H225CallIdentifier)); + pDRQ->m.gatekeeperIdentifierPresent = 1; + pDRQ->gatekeeperIdentifier.nchars = pGkClient->gkId.nchars; + pDRQ->gatekeeperIdentifier.data = (ASN116BITCHAR*)memAlloc + (pctxt, pGkClient->gkId.nchars*sizeof(ASN116BITCHAR)); + if(!pDRQ->gatekeeperIdentifier.data) + { + OOTRACEERR1("Error:Failed to allocate memory for GKId in DRQ.\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + memcpy(pDRQ->gatekeeperIdentifier.data, pGkClient->gkId.data, + pGkClient->gkId.nchars*sizeof(ASN116BITCHAR)); + + pDRQ->m.terminationCausePresent = 1; + pDRQ->terminationCause.t = T_H225CallTerminationCause_releaseCompleteCauseIE; + pDRQ->terminationCause.u.releaseCompleteCauseIE = + (H225CallTerminationCause_releaseCompleteCauseIE*)memAlloc(pctxt, + sizeof(H225CallTerminationCause_releaseCompleteCauseIE)); + if(!pDRQ->terminationCause.u.releaseCompleteCauseIE) + { + OOTRACEERR1("Error: Failed to allocate memory for cause ie in DRQ.\n"); + memReset(pctxt); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pDRQ->terminationCause.u.releaseCompleteCauseIE->numocts = + strlen("Call Ended"); + strcpy(pDRQ->terminationCause.u.releaseCompleteCauseIE->data, "Call Ended"); + + iRet = ooGkClientSendMsg(pGkClient, pRasMsg); + if(iRet != OO_OK) + { + OOTRACEERR1("Error: Failed to send DRQ message\n"); + pGkClient->state = GkClientFailed; + } + + + + /* Search call in admitted calls list */ + for(x=0 ; xcallsAdmittedList.count ; x++) + { + pNode = (DListNode*)dListFindByIndex(&pGkClient->callsAdmittedList, x); + pCallAdmInfo = (RasCallAdmissionInfo*) pNode->data; + if(pCallAdmInfo->call->callReference == call->callReference) + { + dListRemove( &pGkClient->callsAdmittedList, pNode); + memFreePtr(&pGkClient->ctxt, pNode->data); + memFreePtr(&pGkClient->ctxt, pNode); + break; + } + } + return iRet; +} + +int ooGkClientHandleDisengageConfirm + (ooGkClient *pGkClient, H225DisengageConfirm *pDCF) +{ + OOTRACEINFO1("Received disengage confirm\n"); + return OO_OK; +} + +int ooGkClientRRQTimerExpired(void*pdata) +{ + int ret=0; + ooGkClientTimerCb *cbData = (ooGkClientTimerCb*)pdata; + ooGkClient *pGkClient = cbData->pGkClient; + OOTRACEDBGA1("Gatekeeper client RRQ timer expired.\n"); + + if(pGkClient->rrqRetries < OO_MAX_RRQ_RETRIES) + { + ret = ooGkClientSendRRQ(pGkClient, 0); + if(ret != OO_OK) + { + OOTRACEERR1("Error:Failed to send RRQ message\n"); + + return OO_FAILED; + } + pGkClient->rrqRetries++; + memFreePtr(&pGkClient->ctxt, cbData); + return OO_OK; + } + memFreePtr(&pGkClient->ctxt, cbData); + OOTRACEERR1("Error:Failed to register with gatekeeper\n"); + pGkClient->state = GkClientGkErr; + return OO_FAILED; +} + +int ooGkClientGRQTimerExpired(void* pdata) +{ + int ret=0; + ooGkClientTimerCb *cbData = (ooGkClientTimerCb*)pdata; + ooGkClient *pGkClient = cbData->pGkClient; + + OOTRACEDBGA1("Gatekeeper client GRQ timer expired.\n"); + + memFreePtr(&pGkClient->ctxt, cbData); + + if(pGkClient->grqRetries < OO_MAX_GRQ_RETRIES) + { + ret = ooGkClientSendGRQ(pGkClient); + if(ret != OO_OK) + { + OOTRACEERR1("Error:Failed to send GRQ message\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + pGkClient->grqRetries++; + return OO_OK; + } + + OOTRACEERR1("Error:Gatekeeper could not be found\n"); + pGkClient->state = GkClientGkErr; + return OO_FAILED; +} + +int ooGkClientREGTimerExpired(void *pdata) +{ + int ret=0; + ooGkClientTimerCb *cbData = (ooGkClientTimerCb*)pdata; + ooGkClient *pGkClient = cbData->pGkClient; + OOTRACEDBGA1("Gatekeeper client additive registration timer expired\n"); + memFreePtr(&pGkClient->ctxt, cbData); + ret = ooGkClientSendRRQ(pGkClient, TRUE); + if(ret != OO_OK) + { + OOTRACEERR1("Error:Failed to send Additive RRQ message\n"); + pGkClient->state = GkClientFailed; + return OO_FAILED; + } + return OO_OK; +} + +int ooGkClientARQTimerExpired(void* pdata) +{ + int ret=0; + ooGkClientTimerCb *cbData = (ooGkClientTimerCb*)pdata; + ooGkClient *pGkClient = cbData->pGkClient; + RasCallAdmissionInfo *pAdmInfo = cbData->pAdmInfo; + + OOTRACEDBGA1("Gatekeeper client ARQ timer expired.\n"); + memFreePtr(&pGkClient->ctxt, cbData); + + if(pAdmInfo->retries < OO_MAX_ARQ_RETRIES) + { + ret = ooGkClientSendAdmissionRequest(pGkClient, pAdmInfo->call, TRUE); + if(ret != OO_OK) + { + OOTRACEERR1("Error:Failed to send ARQ message\n"); + return OO_FAILED; + } + pAdmInfo->retries++; + return OO_OK; + } + + OOTRACEERR1("Error:Gatekeeper not responding to ARQ\n"); + pGkClient->state = GkClientGkErr; + return OO_FAILED; +} + +int ooGkClientCleanCall(ooGkClient *pGkClient, OOH323CallData *call) +{ + unsigned int x=0; + DListNode *pNode=NULL; + OOTimer *pTimer; + ooGkClientTimerCb *cbData=NULL; + RasCallAdmissionInfo *pAdmInfo = NULL; + + + for(x=0; xcallsAdmittedList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->callsAdmittedList, x); + pAdmInfo = (RasCallAdmissionInfo*)pNode->data; + if(pAdmInfo->call->callReference == call->callReference) + { + dListRemove(&pGkClient->callsAdmittedList, pNode); + memFreePtr(&pGkClient->ctxt, pAdmInfo); + memFreePtr(&pGkClient->ctxt, pNode); + return OO_OK; + } + } + + + for(x=0; xtimerList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->timerList, x); + pTimer = (OOTimer*)pNode->data; + cbData = (ooGkClientTimerCb*)pTimer->cbData; + if(cbData->timerType & OO_ARQ_TIMER && + cbData->pAdmInfo->call->callReference == call->callReference) + { + memFreePtr(&pGkClient->ctxt, pTimer->cbData); + ooTimerDelete(&pGkClient->ctxt, &pGkClient->timerList, pTimer); + break; + } + } + + for(x=0; xcallsPendingList.count; x++) + { + pNode = dListFindByIndex(&pGkClient->callsPendingList, x); + pAdmInfo = (RasCallAdmissionInfo*)pNode->data; + if(pAdmInfo->call->callReference == call->callReference) + { + dListRemove(&pGkClient->callsPendingList, pNode); + memFreePtr(&pGkClient->ctxt, pAdmInfo); + memFreePtr(&pGkClient->ctxt, pNode); + return OO_OK; + } + } + + return OO_OK; +} + +/* + * TODO: In case of GkErr, if GkMode is DiscoverGatekeeper, + * need to cleanup gkrouted calls, and discover another + * gatekeeper. + * Note: This function returns OO_FAILED, when we can not recover from + * the failure. + */ +int ooGkClientHandleClientOrGkFailure(ooGkClient *pGkClient) +{ + if(pGkClient->state == GkClientFailed) + { + OOTRACEERR1("Error: Internal Failure in GkClient. Closing " + "GkClient\n"); + ooGkClientDestroy(); + return OO_FAILED; + } + else if(pGkClient->state == GkClientGkErr) { + OOTRACEERR1("Error: Gatekeeper error. Either Gk not responding or " + "Gk sending invalid messages\n"); + if(pGkClient->gkMode == RasUseSpecificGatekeeper) + { + OOTRACEERR1("Error: Gatekeeper error detected. Closing GkClient as " + "Gk mode is UseSpecifcGatekeeper\n"); + ooGkClientDestroy(); + return OO_FAILED; + } + else{ + OOTRACEERR1("Error: Gatekeeper error detected. Closing GkClient. NEED" + " to implement recovery by rediscovering another gk\n"); + ooGkClientDestroy(); + return OO_FAILED; + } + } + + return OO_FAILED; +} + +/** + * TODO: This fuction might not work properly in case of additive registrations + * For example we registrered 10 aliases and gatekeeper accepted 8 of them. + * Now we want to register another two new aliases(not out of those first 10). + * Gk responds with RCF with empty terminalAlias field thus indicating both + * the aliases were accepted. If this function is called, it will even mark + * the earlier two unregistered aliases as registered. We will have to + * maintain a separete list of aliases being sent in RRQ for this. + */ +int ooGkClientUpdateRegisteredAliases + (ooGkClient *pGkClient, H225_SeqOfH225AliasAddress *pAddresses, + OOBOOL registered) +{ + int i=0, j, k; + DListNode* pNode=NULL; + ooAliases *pAlias=NULL; + H225AliasAddress *pAliasAddress=NULL; + H225TransportAddress *pTransportAddrss=NULL; + char value[MAXFILENAME]; + OOBOOL bAdd = FALSE; + + if(!pAddresses) + { + /* All aliases registered/unregistsred */ + pAlias = gH323ep.aliases; + + while(pAlias) + { + pAlias->registered = registered?TRUE:FALSE; + pAlias = pAlias->next; + } + return OO_OK; + } + + /* Mark aliases as registered/unregistered*/ + if(pAddresses->count<=0) + return OO_FAILED; + + for(i=0; i<(int)pAddresses->count; i++) + { + pNode = dListFindByIndex (pAddresses, i); + if(!pNode) + { + OOTRACEERR1("Error:Invalid alias list passed to " + "ooGkClientUpdateRegisteredAliases\n"); + continue; + } + pAliasAddress = (H225AliasAddress*)pNode->data; + + if(!pAliasAddress){ + OOTRACEERR1("Error:Invalid alias list passed to " + "ooGkClientUpdateRegisteredAliases\n"); + continue; + } + + switch(pAliasAddress->t) + { + case T_H225AliasAddress_dialedDigits: + pAlias = ooH323GetAliasFromList(gH323ep.aliases, + T_H225AliasAddress_dialedDigits, + (char*)pAliasAddress->u.dialedDigits); + if(pAlias) + { + pAlias->registered = registered?TRUE:FALSE; + } + else{ + bAdd = registered?TRUE:FALSE; + } + break; + case T_H225AliasAddress_h323_ID: + for(j=0, k=0; j<(int)pAliasAddress->u.h323_ID.nchars && (ku.h323_ID.data[j] < 256) + { + value[k++] = (char) pAliasAddress->u.h323_ID.data[j]; + } + } + value[k] = '\0'; + pAlias = ooH323GetAliasFromList(gH323ep.aliases, + T_H225AliasAddress_h323_ID, + value); + if(pAlias) + { + pAlias->registered = registered?TRUE:FALSE; + } + else{ + bAdd = registered?TRUE:FALSE; + } + break; + case T_H225AliasAddress_url_ID: + pAlias = ooH323GetAliasFromList(gH323ep.aliases, + T_H225AliasAddress_url_ID, + (char*)pAliasAddress->u.url_ID); + if(pAlias) + { + pAlias->registered = registered?TRUE:FALSE; + } + else{ + bAdd = registered?TRUE:FALSE; + } + break; + case T_H225AliasAddress_transportID: + pTransportAddrss = pAliasAddress->u.transportID; + if(pTransportAddrss->t != T_H225TransportAddress_ipAddress) + { + OOTRACEERR1("Error:Alias transportID not IP address\n"); + break; + } + + sprintf(value, "%d.%d.%d.%d:%d", + pTransportAddrss->u.ipAddress->ip.data[0], + pTransportAddrss->u.ipAddress->ip.data[1], + pTransportAddrss->u.ipAddress->ip.data[2], + pTransportAddrss->u.ipAddress->ip.data[3], + pTransportAddrss->u.ipAddress->port); + + pAlias = ooH323GetAliasFromList(gH323ep.aliases, + T_H225AliasAddress_transportID, + value); + if(pAlias) + { + pAlias->registered = registered?TRUE:FALSE; + } + else{ + bAdd = registered?TRUE:FALSE; + } + break; + case T_H225AliasAddress_email_ID: + pAlias = ooH323GetAliasFromList(gH323ep.aliases, + T_H225AliasAddress_email_ID, + (char*) pAliasAddress->u.email_ID); + if(pAlias) + { + pAlias->registered = registered?TRUE:FALSE; + } + else{ + bAdd = registered?TRUE:FALSE; + } + break; + default: + OOTRACEERR1("Error:Unhandled alias type found in registered " + "aliases\n"); + } + if(bAdd) + { + pAlias = ooH323AddAliasToList(&gH323ep.aliases, + &gH323ep.ctxt, pAliasAddress); + if(pAlias){ + pAlias->registered = registered?TRUE:FALSE; + } + else{ + OOTRACEERR2("Warning:Could not add registered alias of " + "type %d to list.\n", pAliasAddress->t); + } + bAdd = FALSE; + } + pAlias = NULL; + } + return OO_OK; +} diff --git a/addons/ooh323c/src/ooGkClient.h b/addons/ooh323c/src/ooGkClient.h new file mode 100644 index 000000000..fa52f3e92 --- /dev/null +++ b/addons/ooh323c/src/ooGkClient.h @@ -0,0 +1,560 @@ +/* + * Copyright (C) 2005 by Page Iberica, S.A. + * Copyright (C) 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. + * + *****************************************************************************/ + +/** + * @file ooGkClient.h + * This file contains functions to support RAS protocol. + * + * + */ +#ifndef _OOGKCLIENT_H_ +#define _OOGKCLIENT_H_ + +#include "ooasn1.h" +#include "ootypes.h" +#include "H323-MESSAGES.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* _WIN32 */ +#endif /* EXTERN */ + + +/*-------------------------------------------------------------------*/ +/* Public definitions */ +/*-------------------------------------------------------------------*/ + + + +#define MAX_IP_LEN 15 +#define DEFAULT_GKPORT 1719 +#define MULTICAST_GKADDRESS "224.0.1.41" +#define MULTICAST_GKPORT 1718 +#define DEFAULT_BW_REQUEST 100000 + +/* Various timeouts in seconds */ +#define DEFAULT_REG_TTL 300 +#define DEFAULT_TTL_OFFSET 20 +#define DEFAULT_ARQ_TIMEOUT 5 +#define DEFAULT_DRQ_TIMEOUT 5 +#define DEFAULT_GRQ_TIMEOUT 15 +#define DEFAULT_RRQ_TIMEOUT 10 + +/* Number of retries before giving up */ +#define OO_MAX_GRQ_RETRIES 3 +#define OO_MAX_RRQ_RETRIES 3 +#define OO_MAX_ARQ_RETRIES 3 + +/* Gk Client timers */ +#define OO_GRQ_TIMER (1<<0) +#define OO_RRQ_TIMER (1<<1) +#define OO_REG_TIMER (1<<2) +#define OO_ARQ_TIMER (1<<3) +#define OO_DRQ_TIMER (1<<4) + +/** + * @defgroup gkclient Gatekeeper client + * @{ + */ + +struct OOH323CallData; +struct ooGkClient; +struct RasCallAdmissionInfo; + +typedef struct ooGkClientTimerCb{ + int timerType; + struct ooGkClient *pGkClient; + struct RasCallAdmissionInfo *pAdmInfo; +}ooGkClientTimerCb; + +enum RasGatekeeperMode { + RasNoGatekeeper = 0, + RasDiscoverGatekeeper = 1, + RasUseSpecificGatekeeper = 2, +}; + +enum RasCallType{ + RasPointToPoint =0, + RasOneToN, + RasnToOne, + RasnToN, +}; + + +enum OOGkClientState { + GkClientIdle = 0, + GkClientDiscovered, /* Gk Discovery is complete */ + GkClientRegistered, /* registered with gk */ + GkClientUnregistered, + GkClientGkErr,/*Gk is not responding, in discover mode can look for new GK*/ + GkClientFailed +}; + + +typedef struct RasGatekeeperInfo +{ + ASN1BOOL willRespondToIRR; + H225UUIEsRequested uuiesRequested; + H225BandWidth bw; + H225RegistrationConfirm_preGrantedARQ preGrantedARQ; +}RasGatekeeperInfo; + +/** + * Call Admission Information + */ +typedef struct RasCallAdmissionInfo +{ + struct OOH323CallData *call; + unsigned int retries; + unsigned short requestSeqNum; + ASN1USINT irrFrequency; +} RasCallAdmissionInfo; + +struct OOAliases; + +/** + * NOTE- This functionality is not yet fully completed. + * This is a callback function which is triggered when registration confirm + * message is received from the gatekeeper. The first parameter is the message + * received. The second parameter provides updated list of aliases after the + * message was processed by the stack. + * @param rcf Handle to the received registration confirm message + */ +typedef int (*cb_OnReceivedRegistrationConfirm) + (H225RegistrationConfirm *rcf, struct OOAliases *aliases); + + +/** + * NOTE- This functionality is not yet fully completed. + * This is a callback function which is triggered when unregistration confirm + * message is received. The first parameter is the message received. The second + * parameter provides updated list of aliases after the message was processed + * by the stack. + */ +typedef int (*cb_OnReceivedUnregistrationConfirm) + (H225UnregistrationConfirm *ucf, struct OOAliases *aliases); + +/** + * NOTE- This functionality is not yet fully completed. + * This is a callback function which is triggered when unregistration request + * message is received. The first parameter is the message received. The second + * parameter provides the list of aliases requested to be unregistered. + */ +typedef int (*cb_OnReceivedUnregistrationRequest) + (H225UnregistrationRequest *urq, struct OOAliases *aliases); + +typedef struct OOGKCLIENTCALLBACKS{ + cb_OnReceivedRegistrationConfirm onReceivedRegistrationConfirm; + cb_OnReceivedUnregistrationConfirm onReceivedUnregistrationConfirm; + cb_OnReceivedUnregistrationRequest onReceivedUnregistrationRequest; +}OOGKCLIENTCALLBACKS; + +/** + * Structure to store all the configuration information for the gatekeeper + * client. Gatekeeper client is responsible for all the communication with + * a gatekeeper. + */ +typedef struct ooGkClient{ + ASN1BOOL discoveryComplete; + OOCTXT ctxt; + OOCTXT msgCtxt; + OOSOCKET rasSocket; + int localRASPort; + char localRASIP[20]; + char gkRasIP[20]; + char gkCallSignallingIP[20]; + RasGatekeeperInfo gkInfo; + int gkRasPort; + int gkCallSignallingPort; + unsigned short requestSeqNum; + enum RasGatekeeperMode gkMode; /* Current Gk mode */ + struct timeval registrationTime; + H225GatekeeperIdentifier gkId; + H225EndpointIdentifier endpointId; + DList callsPendingList; + DList callsAdmittedList; + DList timerList; + OOGKCLIENTCALLBACKS callbacks; + ASN1UINT grqRetries; + ASN1UINT rrqRetries; + ASN1UINT grqTimeout; + ASN1UINT rrqTimeout; + ASN1UINT regTimeout; + ASN1UINT arqTimeout; + ASN1UINT drqTimeout; + enum OOGkClientState state; +} ooGkClient; + +struct OOAliases; +struct OOH323CallData; + +/** + * This function is used to initialize the Gatekeeper client.If an application + * wants to use gatekeeper services, it should call this function immediately + * after initializing the H323 EndPoint. + * @param eGkMode Gatekeeper mode. + * @param szGkAddr Dotted gk ip address, if gk has to be specified. + * @param iGkPort Gk port. + * + * @return OO_OK, on success. OO_FAILED, on failure. + * + */ +EXTERN int ooGkClientInit + (enum RasGatekeeperMode eGkMode, char *szGkAddr, int iGkPort ); + +/** + * This function is used to print the gatekeeper client configuration + * information to log. + * @param pGkClient Handle to gatekeeper client. + */ +EXTERN void ooGkClientPrintConfig(ooGkClient *pGkClient); + +/** + * This function is used to destroy Gatekeeper client. It releases all the + * associated memory. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientDestroy(void); + +/** + * This function is used to start the Gatekeeper client functionality. + * @param pGkClient Pointer to the Gatekeeper Client. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientStart(ooGkClient *pGkClient); + +/** + * This function is invoked to set a gatekeeper mode. + * @param pGkClient Handle to gatekeeper client. + * @param eGkMode Gatekeeper mode selected. One of the following: + * - RasNoGatekeeper (DEFAULT), No Gatekeeper. + * - RasDiscoverGatekeeper, to discover a gatekeeper + * automatically. + * - RasUseSpecificGatekeeper, to use a specific gatekeeper. + * @param szGkAddr Gatekeeper address (only when using specific gatekeeper). + * @param iGkPort Gatekeeper RAS port + * + * @return Completion status - OO_OK on success, OO_FAILED on failure + */ +EXTERN int ooGkClientSetGkMode(ooGkClient *pGkClient, + enum RasGatekeeperMode eGkMode, char *szGkAddr, + int iGkPort ); + +/** + * This function is used to create a RAS channel for the gatekeeper. + * @param pGkClient Pointer to the Gatekeeper client for which RAS channel + * has to be created. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientCreateChannel(ooGkClient *pGkClient); + +/** + * This function is used to close a RAS channel of the gatekeeper client. + * @param pGkClient Pointer to the gatekeeper client. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientCloseChannel(ooGkClient *pGkClient); + + +/** + * This function is used to fill endpoint's vendor information into vendor + * identifier. + * @param pGkClient Pointer to gatekeeper client. + * @param psVendor Pointer to vendor identifier to be filled. + * + */ +EXTERN void ooGkClientRasFillVendor + (ooGkClient *pGkClient, H225VendorIdentifier *psVendor); + + +/** + * This function is invoked to receive data on Gatekeeper client's RAS channel. + * @param pGkClient Handle to Gatekeeper client for which message has to be + * received. + * + * @return Completion status - OO_OK on success, OO_FAILED on + * failure + */ +EXTERN int ooGkClientReceive(ooGkClient *pGkClient); + + +/** + * This function is used to handle a received RAS message by a gatekeeper + * client. + * @param pGkClient Handle to gatekeeper client. + * @param pRasMsg Handle to received Ras message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientHandleRASMessage + (ooGkClient *pGkClient, H225RasMessage *pRasMsg); + + +/** + * This function is used to send a message on Gatekeeper clien't RAS channel. + * @param pGkClient Handle to the gatekeeper client. + * @param pRasMsg Handle to Ras message to be sent. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientSendMsg(ooGkClient *pGkClient, H225RasMessage *pRasMsg); + + +/** + * This function is used to send Gatekeeper request message. + * @param pGkClient Handle to gatekeeper client for which GRQ message has to + * be sent. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientSendGRQ(ooGkClient *pGkClient); + + +/** + * This function is used to handle a received gatekeeper reject message. + * @param pGkClient Handle to gatekeeper client. + * @param pGatekeeperReject Handle to received reject message. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientHandleGatekeeperReject + (ooGkClient *pGkClient, H225GatekeeperReject *pGatekeeperReject); + +/** + * This function is used to handle a received gatekeeper confirm message. + * @param pGkClient Handle to gatekeeper client. + * @param pGatekeeperConfirm Handle to received confirmed message. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientHandleGatekeeperConfirm + (ooGkClient *pGkClient, H225GatekeeperConfirm *pGatekeeperConfirm); + + +/** + * This function is used to send Registration request message. + * @param pGkClient Handle to gatekeeper client for which RRQ message has to + * be sent. + * @param keepAlive Indicates whether keepalive lightweight registration has + * to be sent. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientSendRRQ(ooGkClient *pGkClient, ASN1BOOL keepAlive); + +/** + * This function is used to handle a received registration confirm message. + * @param pGkClient Handle to gatekeeper client. + * @param pRegistrationConfirm Handle to received confirmed message. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientHandleRegistrationConfirm + (ooGkClient *pGkClient, H225RegistrationConfirm *pRegistrationConfirm); + +/** + * This function is used to handle a received registration reject message. + * @param pGkClient Handle to gatekeeper client. + * @param pRegistrationReject Handle to received reject message. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientHandleRegistrationReject + (ooGkClient *pGkClient, H225RegistrationReject *pRegistrationReject); + + +/** + * This function is used to send UnRegistration request message. + * @param pGkClient Handle to gatekeeper client for which URQ message has to + * be sent. + * @param aliases List of aliases to be unregistered. NULL, if all the + * aliases have to be unregistered. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientSendURQ(ooGkClient *pGkClient, struct OOAliases *aliases); + +/** + * This function is used to handle a received Unregistration request message. + * @param pGkClient Handle to gatekeeper client. + * @param punregistrationRequest Handle to received unregistration request. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientHandleUnregistrationRequest + (ooGkClient *pGkClient, H225UnregistrationRequest *punregistrationRequest); + + +/** + * This function is used to send an unregistration confirm messsage to + * gatekeeper. + * @param pGkClient Handle to gatekeeper client. + * @param reqNo Request Sequence number for the confirm message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientSendUnregistrationConfirm(ooGkClient *pGkClient, + unsigned reqNo); + +/** + * This function is invoked to request bandwith admission for a call. + * @param pGkClient Gatekeeper client to be used + * @param call Handle to the call. + * @param retransmit Indicates whether new call or retransmitting for + * existing call. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientSendAdmissionRequest + (ooGkClient *pGkClient, struct OOH323CallData *call, ASN1BOOL retransmit); + +/** + * This function is used to handle a received Admission confirm message. + * @param pGkClient Handle to gatekeeper client. + * @param pAdmissionConfirm Handle to received confirmed message. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientHandleAdmissionConfirm + (ooGkClient *pGkClient, H225AdmissionConfirm *pAdmissionConfirm); + + +/** + * This function is used to handle a received Admission Reject message. It + * finds the associated call and marks it for cleaning with appropriate + * call end reason code. + * @param pGkClient Handle to Gatekeeper client. + * @param pAdmissionReject Handle to received admission reject message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientHandleAdmissionReject + (ooGkClient *pGkClient, H225AdmissionReject *pAdmissionReject); + +/** + * This function is invoked to request call disengage to gatekeeper. + * @param pGkClient Gatekeeper client to be used. + * @param call Call Handle + * + * @return Completion status - OO_OK on success, OO_FAILED on failure + */ +EXTERN int ooGkClientSendDisengageRequest + (ooGkClient *pGkClient, struct OOH323CallData *call); + +/** + * This function is used to handle a received disengage confirm message. + * @param pGkClient Handle to gatekeeper client. + * @param pDCF Handle to received confirmed message. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooGkClientHandleDisengageConfirm + (ooGkClient *pGkClient, H225DisengageConfirm *pDCF); + +/** + * This function is used to handle an expired registration request timer. + * @param pdata Handle to callback data + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientRRQTimerExpired(void*pdata); + +/** + * This function is used to handle an expired gatekeeper request timer. + * @param pdata Handle to callback data + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientGRQTimerExpired(void* pdata); + +/** + * This function is used to handle an expired registration time-to-live timer. + * @param pdata Handle to callback data + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientREGTimerExpired(void *pdata); + +/** + * This function is used to handle an expired admission request timer. + * @param pdata Handle to callback data + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientARQTimerExpired(void* pdata); + +/** + * This function is used to clean call related data from gatekeeper client. + * @param pGkClient Handle to the gatekeeper client. + * @param call Handle to the call to be cleaned. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientCleanCall(ooGkClient *pGkClient, struct OOH323CallData *call); + +/** + * This function is used to handle gatekeeper client failure or gatekeeper + * failure which can be detected by unresponsiveness of gk. + * @param pGkClient Handle to gatekeeper client. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientHandleClientOrGkFailure(ooGkClient *pGkClient); + +/** + * This function is used to update the registration status of aliases. + * @param pGkClient Handle to the GK client. + * @param pAddresses List of newly registered addresses. NULL means all + * aliases have been successfully registered. + * @param registered Indicates whether aliases are registered or unregistered. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGkClientUpdateRegisteredAliases + (ooGkClient *pGkClient, H225_SeqOfH225AliasAddress *pAddresses, + OOBOOL registered); + +/** + * This function is used internally to set Gatekeeper Clients callbacks. + * Note: This functionality is not yet fully supported + * @param pGkClient Handle to the GK client. + * @param callbacks Callback structure contatining various gatekeeper client + * callbacks. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooGkClientSetCallbacks + (ooGkClient *pGkClient, OOGKCLIENTCALLBACKS callbacks); +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif /* __GKCLIENT_H */ diff --git a/addons/ooh323c/src/ooLogChan.c b/addons/ooh323c/src/ooLogChan.c new file mode 100644 index 000000000..86c8844c7 --- /dev/null +++ b/addons/ooh323c/src/ooLogChan.c @@ -0,0 +1,372 @@ +/* + * 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 "ooCalls.h" +#include "ooh323ep.h" + +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + +OOLogicalChannel* ooAddNewLogicalChannel(OOH323CallData *call, int channelNo, + int sessionID, char *dir, + ooH323EpCapability *epCap) +{ + OOLogicalChannel *pNewChannel=NULL, *pChannel=NULL; + OOMediaInfo *pMediaInfo = NULL; + OOTRACEDBGC5("Adding new media channel for cap %d dir %s (%s, %s)\n", + epCap->cap, dir, call->callType, call->callToken); + /* Create a new logical channel entry */ + pNewChannel = (OOLogicalChannel*)memAlloc(call->pctxt, + sizeof(OOLogicalChannel)); + if(!pNewChannel) + { + OOTRACEERR3("ERROR:Memory - ooAddNewLogicalChannel - pNewChannel " + "(%s, %s)\n", call->callType, call->callToken); + return NULL; + } + + memset(pNewChannel, 0, sizeof(OOLogicalChannel)); + pNewChannel->channelNo = channelNo; + pNewChannel->sessionID = sessionID; + pNewChannel->state = OO_LOGICALCHAN_IDLE; + pNewChannel->type = epCap->capType; + /* strcpy(pNewChannel->type, type);*/ + strcpy(pNewChannel->dir, dir); + + pNewChannel->chanCap = epCap; + OOTRACEDBGC4("Adding new channel with cap %d (%s, %s)\n", epCap->cap, + call->callType, call->callToken); + /* As per standards, media control port should be same for all + proposed channels with same session ID. However, most applications + use same media port for transmit and receive of audio streams. Infact, + testing of OpenH323 based asterisk assumed that same ports are used. + Hence we first search for existing media ports for same session and use + them. This should take care of all cases. + */ + if(call->mediaInfo) + { + pMediaInfo = call->mediaInfo; + while(pMediaInfo) + { + if(!strcmp(pMediaInfo->dir, dir) && + (pMediaInfo->cap == epCap->cap)) + { + break; + } + pMediaInfo = pMediaInfo->next; + } + } + + if(pMediaInfo) + { + OOTRACEDBGC3("Using configured media info (%s, %s)\n", call->callType, + call->callToken); + pNewChannel->localRtpPort = pMediaInfo->lMediaPort; + pNewChannel->localRtcpPort = pMediaInfo->lMediaCntrlPort; + /* If user application has not specified a specific ip and is using + multihomed mode, substitute appropriate ip. + */ + if(!strcmp(pMediaInfo->lMediaIP, "0.0.0.0")) + strcpy(pNewChannel->localIP, call->localIP); + else + strcpy(pNewChannel->localIP, pMediaInfo->lMediaIP); + } + else{ + OOTRACEDBGC3("Using default media info (%s, %s)\n", call->callType, + call->callToken); + pNewChannel->localRtpPort = ooGetNextPort (OORTP); + + /* Ensures that RTP port is an even one */ + if((pNewChannel->localRtpPort & 1) == 1) + pNewChannel->localRtpPort = ooGetNextPort (OORTP); + + pNewChannel->localRtcpPort = ooGetNextPort (OORTP); + strcpy(pNewChannel->localIP, call->localIP); + } + + /* Add new channel to the list */ + pNewChannel->next = NULL; + if(!call->logicalChans) { + call->logicalChans = pNewChannel; + } + else{ + pChannel = call->logicalChans; + while(pChannel->next) pChannel = pChannel->next; + pChannel->next = pNewChannel; + } + + /* increment logical channels */ + call->noOfLogicalChannels++; + OOTRACEINFO3("Created new logical channel entry (%s, %s)\n", call->callType, + call->callToken); + return pNewChannel; +} + +OOLogicalChannel* ooFindLogicalChannelByLogicalChannelNo(OOH323CallData *call, + int ChannelNo) +{ + OOLogicalChannel *pLogicalChannel=NULL; + if(!call->logicalChans) + { + OOTRACEERR3("ERROR: No Open LogicalChannels - Failed " + "FindLogicalChannelByChannelNo (%s, %s\n", call->callType, + call->callToken); + return NULL; + } + pLogicalChannel = call->logicalChans; + while(pLogicalChannel) + { + if(pLogicalChannel->channelNo == ChannelNo) + break; + else + pLogicalChannel = pLogicalChannel->next; + } + + return pLogicalChannel; +} + +OOLogicalChannel * ooFindLogicalChannelByOLC(OOH323CallData *call, + H245OpenLogicalChannel *olc) +{ + H245DataType * psDataType=NULL; + H245H2250LogicalChannelParameters * pslcp=NULL; + OOTRACEDBGC4("ooFindLogicalChannel by olc %d (%s, %s)\n", + olc->forwardLogicalChannelNumber, call->callType, call->callToken); + if(olc->m.reverseLogicalChannelParametersPresent) + { + OOTRACEDBGC3("Finding receive channel (%s,%s)\n", call->callType, + call->callToken); + psDataType = &olc->reverseLogicalChannelParameters.dataType; + /* Only H2250LogicalChannelParameters are supported */ + if(olc->reverseLogicalChannelParameters.multiplexParameters.t != + T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters){ + OOTRACEERR4("Error:Invalid olc %d received (%s, %s)\n", + olc->forwardLogicalChannelNumber, call->callType, call->callToken); + return NULL; + } + pslcp = olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters; + + return ooFindLogicalChannel(call, pslcp->sessionID, "receive", psDataType); + } + else{ + OOTRACEDBGC3("Finding transmit channel (%s, %s)\n", call->callType, + call->callToken); + psDataType = &olc->forwardLogicalChannelParameters.dataType; + /* Only H2250LogicalChannelParameters are supported */ + if(olc->forwardLogicalChannelParameters.multiplexParameters.t != + T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters) + { + OOTRACEERR4("Error:Invalid olc %d received (%s, %s)\n", + olc->forwardLogicalChannelNumber, call->callType, call->callToken); + return NULL; + } + pslcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters; + return ooFindLogicalChannel(call, pslcp->sessionID, "transmit", psDataType); + } +} + +OOLogicalChannel * ooFindLogicalChannel(OOH323CallData *call, int sessionID, + char *dir, H245DataType * dataType) +{ + OOLogicalChannel * pChannel = NULL; + pChannel = call->logicalChans; + while(pChannel) + { + OOTRACEDBGC3("ooFindLogicalChannel, checking channel: %d:%s\n", + pChannel->sessionID, pChannel->dir); + if(pChannel->sessionID == sessionID) + { + if(!strcmp(pChannel->dir, dir)) + { + OOTRACEDBGC3("ooFindLogicalChannel, comparing channel: %d:%s\n", + pChannel->channelNo, pChannel->dir); + if(!strcmp(dir, "receive")) + { + if(ooCapabilityCheckCompatibility(call, pChannel->chanCap, + dataType, OORX)) { + return pChannel; + } + } + else if(!strcmp(dir, "transmit")) + { + if(ooCapabilityCheckCompatibility(call, pChannel->chanCap, + dataType, OOTX)) { + return pChannel; + } + } + } + } + pChannel = pChannel->next; + } + return NULL; +} + +/* This function is used to get a logical channel with a particular session ID */ +OOLogicalChannel* ooGetLogicalChannel + (OOH323CallData *call, int sessionID, char *dir) +{ + OOLogicalChannel * pChannel = NULL; + pChannel = call->logicalChans; + while(pChannel) + { + if(pChannel->sessionID == sessionID && !strcmp(pChannel->dir, dir)) + return pChannel; + else + pChannel = pChannel->next; + } + return NULL; +} + +int ooClearAllLogicalChannels(OOH323CallData *call) +{ + OOLogicalChannel * temp = NULL, *prev = NULL; + + OOTRACEINFO3("Clearing all logical channels (%s, %s)\n", call->callType, + call->callToken); + + temp = call->logicalChans; + while(temp) + { + prev = temp; + temp = temp->next; + ooClearLogicalChannel(call, prev->channelNo);/* TODO: efficiency - This causes re-search + of of logical channel in the list. Can be + easily improved.*/ + } + call->logicalChans = NULL; + return OO_OK; +} + +int ooClearLogicalChannel(OOH323CallData *call, int channelNo) +{ + + OOLogicalChannel *pLogicalChannel = NULL; + ooH323EpCapability *epCap=NULL; + + OOTRACEDBGC4("Clearing logical channel number %d. (%s, %s)\n", channelNo, + call->callType, call->callToken); + + pLogicalChannel = ooFindLogicalChannelByLogicalChannelNo(call,channelNo); + if(!pLogicalChannel) + { + OOTRACEWARN4("Logical Channel %d doesn't exist, in clearLogicalChannel." + " (%s, %s)\n", + channelNo, call->callType, call->callToken); + return OO_OK; + } + + epCap = (ooH323EpCapability*) pLogicalChannel->chanCap; + if(!strcmp(pLogicalChannel->dir, "receive")) + { + if(epCap->stopReceiveChannel) + { + epCap->stopReceiveChannel(call, pLogicalChannel); + OOTRACEINFO4("Stopped Receive channel %d (%s, %s)\n", + channelNo, call->callType, call->callToken); + } + else{ + OOTRACEERR4("ERROR:No callback registered for stopReceiveChannel %d " + "(%s, %s)\n", channelNo, call->callType, call->callToken); + } + } + else + { + if(pLogicalChannel->state == OO_LOGICALCHAN_ESTABLISHED) + { + if(epCap->stopTransmitChannel) + { + epCap->stopTransmitChannel(call, pLogicalChannel); + OOTRACEINFO4("Stopped Transmit channel %d (%s, %s)\n", + channelNo, call->callType, call->callToken); + } + else{ + OOTRACEERR4("ERROR:No callback registered for stopTransmitChannel" + " %d (%s, %s)\n", channelNo, call->callType, + call->callToken); + } + } + } + ooRemoveLogicalChannel(call, channelNo);/* TODO: efficiency - This causes re-search of + of logical channel in the list. Can be + easily improved.*/ + return OO_OK; +} + +int ooRemoveLogicalChannel(OOH323CallData *call, int ChannelNo) +{ + OOLogicalChannel * temp = NULL, *prev=NULL; + if(!call->logicalChans) + { + OOTRACEERR4("ERROR:Remove Logical Channel - Channel %d not found " + "Empty channel List(%s, %s)\n", ChannelNo, call->callType, + call->callToken); + return OO_FAILED; + } + + temp = call->logicalChans; + while(temp) + { + if(temp->channelNo == ChannelNo) + { + if(!prev) call->logicalChans = temp->next; + else prev->next = temp->next; + memFreePtr(call->pctxt, temp->chanCap); + memFreePtr(call->pctxt, temp); + OOTRACEDBGC4("Removed logical channel %d (%s, %s)\n", ChannelNo, + call->callType, call->callToken); + call->noOfLogicalChannels--; + return OO_OK; + } + prev = temp; + temp = temp->next; + } + + OOTRACEERR4("ERROR:Remove Logical Channel - Channel %d not found " + "(%s, %s)\n", ChannelNo, call->callType, call->callToken); + return OO_FAILED; +} + +/* +Change the state of the channel as established and close all other +channels with same session IDs. This is useful for handling fastStart, +as the endpoint can open multiple logical channels for same sessionID. +Once the remote endpoint confirms it's selection, all other channels for +the same sessionID must be closed. +*/ +int ooOnLogicalChannelEstablished + (OOH323CallData *call, OOLogicalChannel * pChannel) +{ + OOLogicalChannel * temp = NULL, *prev=NULL; + OOTRACEDBGC3("In ooOnLogicalChannelEstablished (%s, %s)\n", + call->callType, call->callToken); + pChannel->state = OO_LOGICALCHAN_ESTABLISHED; + temp = call->logicalChans; + while(temp) + { + if(temp->channelNo != pChannel->channelNo && + temp->sessionID == pChannel->sessionID && + !strcmp(temp->dir, pChannel->dir) ) + { + prev = temp; + temp = temp->next; + ooClearLogicalChannel(call, prev->channelNo); + } + else + temp = temp->next; + } + return OO_OK; +} + diff --git a/addons/ooh323c/src/ooLogChan.h b/addons/ooh323c/src/ooLogChan.h new file mode 100644 index 000000000..eeb0f772e --- /dev/null +++ b/addons/ooh323c/src/ooLogChan.h @@ -0,0 +1,190 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * @file ooLogChan.h + * This file contains structures and functions for maintaining information + * on logical channels within the stack. + */ +#ifndef _OOLOGCHAN_H_ +#define _OOLOGCHAN_H_ + +#include "ootypes.h" +#include "ooCapability.h" +#ifdef __cplusplus +extern "C" { +#endif + +/** + * @defgroup logchan H.245 logical channel management + * @{ + */ +struct ooH323EpCapability; +struct OOH323CallData; + +/** + * Logical channel states. + */ +typedef enum { + OO_LOGICAL_CHAN_UNKNOWN, + OO_LOGICALCHAN_IDLE, + OO_LOGICALCHAN_PROPOSED, + OO_LOGICALCHAN_ESTABLISHED +} OOLogicalChannelState; + +/** + * Structure to store information on logical channels for a call. + */ +typedef struct OOLogicalChannel { + int channelNo; + int sessionID; + enum OOCapType type; + char dir[10]; /* receive/transmit */ + char remoteIP[20]; + int remoteMediaPort; + int remoteMediaControlPort; + int localRtpPort; + int localRtcpPort; + char localIP[20]; + OOLogicalChannelState state; + struct ooH323EpCapability *chanCap; + struct OOLogicalChannel *next; +} OOLogicalChannel; + +#define ooLogicalChannel OOLogicalChannel + +/** + * This function is used to add a new logical channel entry into the list + * of currently active logical channels. + * @param call Pointer to the call for which new logical channel + * entry has to be created. + * @param channelNo Channel number for the new channel entry. + * @param sessionID Session identifier for the new channel. + * @param dir Direction of the channel(transmit/receive) + * @param epCap Capability to be used for the new channel. + * + * @return Pointer to logical channel, on success. NULL, on failure + */ +EXTERN ooLogicalChannel* ooAddNewLogicalChannel + (struct OOH323CallData *call, int channelNo, int sessionID, + char *dir, ooH323EpCapability *epCap); + +/** + * This function is used to find a logical channel using the logical + * channel number as a key. + * @param call Pointer to the call for which logical channel is + * required. + * @param channelNo Forward Logical Channel number for the logical channel + * + * @return Pointer to the logical channel if found, NULL + * otherwise. + */ +EXTERN ooLogicalChannel* ooFindLogicalChannelByLogicalChannelNo +(struct OOH323CallData *call, int channelNo); + +/** + * This function is called when a new logical channel is established. It is + * particularly useful in case of faststart. When the remote endpoint selects + * one of the proposed alternatives, other channels for the same session type + * need to be closed. This function is used for that. + * + * @param call Handle to the call which owns the logical channel. + * @param pChannel Handle to the newly established logical channel. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnLogicalChannelEstablished +(struct OOH323CallData *call, OOLogicalChannel * pChannel); + +/** + * This function is used to retrieve a logical channel with a particular + * sessionID. Note that there can be two entries of logical channel, one in + * each direction. This function will return the first channel which has the + * same session ID. + * @param call Handle to the call which owns the channels to be searched. + * @param sessionID Session id of the session which is to be searched for. + * @param dir Direction of the channel.(transmit/receive) + * + * @return Returns a pointer to the logical channel if found, NULL + * otherwise. + */ +EXTERN ooLogicalChannel* ooGetLogicalChannel +(struct OOH323CallData *call, int sessionID, char *dir); + +/** + * This function is used to remove a logical channel from the list of + * channels within the call structure. + * @param call Pointer to the call from which logical channel has + * to be removed. + * @param ChannelNo Forward logical channel number of the channel to be + * removed. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooRemoveLogicalChannel (struct OOH323CallData *call, int ChannelNo); + +/** + * This function is used to cleanup a logical channel. It first stops media if + * it is still active and then removes the channel from the list, freeing up + * all the associated memory. + * @param call Handle to the call which owns the logical channel. + * @param channelNo Channel number identifying the channel. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooClearLogicalChannel (struct OOH323CallData *call, int channelNo); + +/** + * This function is used to cleanup all the logical channels associated with + * the call. + * @param call Handle to the call which owns the channels. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooClearAllLogicalChannels (struct OOH323CallData *call); + +/** + * This function is used to find a logical channel from a received + * H.245 Open Logical Channel (OLC) message. + * @param call Handle to the related call. + * @param olc Handle to the received OLC. + * + * @return Returns the corresponding logical channel if found, + * else returns NULL. + */ +EXTERN OOLogicalChannel * ooFindLogicalChannelByOLC +(struct OOH323CallData *call, H245OpenLogicalChannel *olc); + +/** + * This function is used to find a logical channel based on session Id, + * direction of channel and datatype. + * @param call Handle to the call + * @param sessionID Session ID for the channel to be searched. + * @param dir Direction of the channel wrt local endpoint. + * (transmit/receive) + * @param dataType Handle to the data type for the channel. + * + * @return Logical channel, if found, NULL otherwise. + */ +EXTERN OOLogicalChannel * ooFindLogicalChannel +(struct OOH323CallData* call, int sessionID, char *dir, H245DataType* dataType); + +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/ooSocket.c b/addons/ooh323c/src/ooSocket.c new file mode 100644 index 000000000..181cf6792 --- /dev/null +++ b/addons/ooh323c/src/ooSocket.c @@ -0,0 +1,723 @@ +/* + * Copyright (C) 1997-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 "ooSocket.h" +#include "ootrace.h" +#if defined(_WIN32_WCE) +static int inited = 0; +#define SEND_FLAGS 0 +#define SHUTDOWN_FLAGS 0 +#elif defined (_WIN32) +static LPFN_SEND send; +static LPFN_SOCKET socket; +static LPFN_SETSOCKOPT setsockopt; +static LPFN_BIND bind; +static LPFN_HTONL htonl; +static LPFN_HTONS htons; +static LPFN_CONNECT connect; +static LPFN_INET_ADDR inet_addr; +static LPFN_LISTEN listen; +static LPFN_ACCEPT accept; +static LPFN_NTOHL ntohl; +static LPFN_NTOHS ntohs; +static LPFN_RECV recv; +static LPFN_SHUTDOWN shutdown; + + +static LPFN_IOCTLSOCKET ioctlsocket; +static LPFN_SENDTO sendto; +static LPFN_INET_NTOA inet_ntoa; +static LPFN_RECVFROM recvfrom; +static LPFN_SELECT select; +static LPFN_GETHOSTNAME gethostname; +static LPFN_GETHOSTBYNAME gethostbyname; +static LPFN_WSAGETLASTERROR WSAGetLastError; +static LPFN_WSACLEANUP WSACleanup; +static LPFN_CLOSESOCKET closesocket; +static LPFN_GETSOCKNAME getsockname; +static HMODULE ws32 = 0; +#define SEND_FLAGS 0 +#define SHUTDOWN_FLAGS SD_BOTH +#else +#define SEND_FLAGS 0 +#define SHUTDOWN_FLAGS SHUT_RDWR +#define closesocket close +#endif + + + +int ooSocketsInit () +{ +#if defined(_WIN32_WCE) + WORD wVersionRequested; + WSADATA wsaData; + int err; + + if (inited) return ASN_OK; + + wVersionRequested = MAKEWORD( 1, 1 ); + + err = WSAStartup (wVersionRequested, &wsaData); + if ( err != 0 ) { + /* Tell the user that we could not find a usable */ + /* WinSock DLL. */ + return ASN_E_NOTINIT; + } + inited = 1; + +#elif defined (_WIN32) + LPFN_WSASTARTUP wsaStartup = NULL; + WSADATA wsaData; + + if (ws32 != 0) return ASN_OK; + +// ws32 = LoadLibrary ("WSOCK32.DLL"); + ws32 = LoadLibrary ("WS2_32.DLL"); + if (ws32 == NULL) return ASN_E_NOTINIT; + + wsaStartup = (LPFN_WSASTARTUP) GetProcAddress (ws32, "WSAStartup"); + if (wsaStartup == NULL) return ASN_E_NOTINIT; + + send = (LPFN_SEND) GetProcAddress (ws32, "send"); + if (send == NULL) return ASN_E_NOTINIT; + + socket = (LPFN_SOCKET) GetProcAddress (ws32, "socket"); + if (socket == NULL) return ASN_E_NOTINIT; + + setsockopt = (LPFN_SETSOCKOPT) GetProcAddress (ws32, "setsockopt"); + if (setsockopt == NULL) return ASN_E_NOTINIT; + + bind = (LPFN_BIND) GetProcAddress (ws32, "bind"); + if (bind == NULL) return ASN_E_NOTINIT; + + htonl = (LPFN_HTONL) GetProcAddress (ws32, "htonl"); + if (htonl == NULL) return ASN_E_NOTINIT; + + htons = (LPFN_HTONS) GetProcAddress (ws32, "htons"); + if (htons == NULL) return ASN_E_NOTINIT; + + connect = (LPFN_CONNECT) GetProcAddress (ws32, "connect"); + if (connect == NULL) return ASN_E_NOTINIT; + + listen = (LPFN_LISTEN) GetProcAddress (ws32, "listen"); + if (listen == NULL) return ASN_E_NOTINIT; + + accept = (LPFN_ACCEPT) GetProcAddress (ws32, "accept"); + if (accept == NULL) return ASN_E_NOTINIT; + + inet_addr = (LPFN_INET_ADDR) GetProcAddress (ws32, "inet_addr"); + if (inet_addr == NULL) return ASN_E_NOTINIT; + + ntohl = (LPFN_NTOHL) GetProcAddress (ws32, "ntohl"); + if (ntohl == NULL) return ASN_E_NOTINIT; + + ntohs = (LPFN_NTOHS) GetProcAddress (ws32, "ntohs"); + if (ntohs == NULL) return ASN_E_NOTINIT; + + recv = (LPFN_RECV) GetProcAddress (ws32, "recv"); + if (recv == NULL) return ASN_E_NOTINIT; + + shutdown = (LPFN_SHUTDOWN) GetProcAddress (ws32, "shutdown"); + if (shutdown == NULL) return ASN_E_NOTINIT; + + closesocket = (LPFN_CLOSESOCKET) GetProcAddress (ws32, "closesocket"); + if (closesocket == NULL) return ASN_E_NOTINIT; + + getsockname = (LPFN_GETSOCKNAME) GetProcAddress (ws32, "getsockname"); + if (getsockname == NULL) return ASN_E_NOTINIT; + + ioctlsocket = (LPFN_IOCTLSOCKET) GetProcAddress(ws32, "ioctlsocket"); + if(ioctlsocket == NULL) return ASN_E_NOTINIT; + + sendto = (LPFN_SENDTO) GetProcAddress (ws32, "sendto"); + if (sendto == NULL) return ASN_E_NOTINIT; + + inet_ntoa = (LPFN_INET_NTOA) GetProcAddress (ws32, "inet_ntoa"); + if (inet_ntoa == NULL) return ASN_E_NOTINIT; + + recvfrom = (LPFN_RECVFROM) GetProcAddress (ws32, "recvfrom"); + if (recvfrom == NULL) return ASN_E_NOTINIT; + + select = (LPFN_SELECT) GetProcAddress (ws32, "select"); + if (select == NULL) return ASN_E_NOTINIT; + + gethostname = (LPFN_GETHOSTNAME) GetProcAddress (ws32, "gethostname"); + if (gethostname == NULL) return ASN_E_NOTINIT; + + gethostbyname = (LPFN_GETHOSTBYNAME) GetProcAddress (ws32, "gethostbyname"); + if (gethostbyname == NULL) return ASN_E_NOTINIT; + + WSAGetLastError = (LPFN_WSAGETLASTERROR) GetProcAddress (ws32, + "WSAGetLastError"); + if (WSAGetLastError == NULL) return ASN_E_NOTINIT; + + WSACleanup = (LPFN_WSACLEANUP) GetProcAddress (ws32, "WSACleanup"); + if (WSACleanup == NULL) return ASN_E_NOTINIT; + + + if (wsaStartup (MAKEWORD(1, 1), &wsaData) == -1) return ASN_E_NOTINIT; +#endif + return ASN_OK; +} + +#if defined (_WIN32) || \ +defined(_HP_UX) || defined(__hpux) || defined(_HPUX_SOURCE) +typedef int OOSOCKLEN; +#else +typedef size_t OOSOCKLEN; +#endif + +int ooSocketCreate (OOSOCKET* psocket) +{ + int on; + + struct linger linger; + OOSOCKET sock = socket (AF_INET, + SOCK_STREAM, + 0); + + if (sock == OOSOCKET_INVALID){ + OOTRACEERR1("Error:Failed to create TCP socket\n"); + return ASN_E_INVSOCKET; + } + + on = 1; + if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, + (const char* ) &on, sizeof (on)) == -1) + { + OOTRACEERR1("Error:Failed to set socket option SO_REUSEADDR\n"); + return ASN_E_INVSOCKET; + } + linger.l_onoff = 1; + linger.l_linger = 0; + if (setsockopt (sock, SOL_SOCKET, SO_LINGER, + (const char* ) &linger, sizeof (linger)) == -1) + { + OOTRACEERR1("Error:Failed to set socket option linger\n"); + return ASN_E_INVSOCKET; + } + *psocket = sock; + return ASN_OK; +} + +int ooSocketCreateUDP (OOSOCKET* psocket) +{ + int on; + struct linger linger; + + OOSOCKET sock = socket (AF_INET, + SOCK_DGRAM, + 0); + + if (sock == OOSOCKET_INVALID){ + OOTRACEERR1("Error:Failed to create UDP socket\n"); + return ASN_E_INVSOCKET; + } + + on = 1; + if (setsockopt (sock, SOL_SOCKET, SO_REUSEADDR, + (const char* ) &on, sizeof (on)) == -1) + { + OOTRACEERR1("Error:Failed to set socket option SO_REUSEADDR\n"); + return ASN_E_INVSOCKET; + } + linger.l_onoff = 1; + linger.l_linger = 0; + /*if (setsockopt (sock, SOL_SOCKET, SO_LINGER, + (const char* ) &linger, sizeof (linger)) == -1) + return ASN_E_INVSOCKET; + */ + *psocket = sock; + return ASN_OK; +} + +int ooSocketClose (OOSOCKET socket) +{ + shutdown (socket, SHUTDOWN_FLAGS); + if (closesocket (socket) == -1) + return ASN_E_INVSOCKET; + return ASN_OK; +} + +int ooSocketBind (OOSOCKET socket, OOIPADDR addr, int port) +{ + struct sockaddr_in m_addr; + + if (socket == OOSOCKET_INVALID) + { + OOTRACEERR1("Error:Invalid socket passed to bind\n"); + return ASN_E_INVSOCKET; + } + + memset (&m_addr, 0, sizeof (m_addr)); + m_addr.sin_family = AF_INET; + m_addr.sin_addr.s_addr = (addr == 0) ? INADDR_ANY : htonl (addr); + m_addr.sin_port = htons ((unsigned short)port); + + if (bind (socket, (struct sockaddr *) (void*) &m_addr, + sizeof (m_addr)) == -1) + { + perror ("bind"); + OOTRACEERR1("Error:Bind failed\n"); + return ASN_E_INVSOCKET; + } + + return ASN_OK; +} + + +int ooSocketGetSockName(OOSOCKET socket, struct sockaddr_in *name, int *size) +{ + int ret; + ret = getsockname(socket, (struct sockaddr*)name, size); + if(ret == 0) + return ASN_OK; + else{ + OOTRACEERR1("Error:ooSocketGetSockName - getsockname\n"); + return ASN_E_INVSOCKET; + } +} + +int ooSocketGetIpAndPort(OOSOCKET socket, char *ip, int len, int *port) +{ + int ret=ASN_OK, size; + struct sockaddr_in addr; + char *host=NULL; + + size = sizeof(addr); + + ret = ooSocketGetSockName(socket, &addr, &size); + if(ret != 0) + return ASN_E_INVSOCKET; + + host = inet_ntoa(addr.sin_addr); + + if(host && strlen(host) < (unsigned)len) + strcpy(ip, host); + else{ + OOTRACEERR1("Error:Insufficient buffer for ip address - " + "ooSocketGetIpAndPort\n"); + return -1; + } + + *port = addr.sin_port; + + return ASN_OK; +} + +int ooSocketListen (OOSOCKET socket, int maxConnection) +{ + if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET; + + if (listen (socket, maxConnection) == -1) + return ASN_E_INVSOCKET; + + return ASN_OK; +} + +int ooSocketAccept (OOSOCKET socket, OOSOCKET *pNewSocket, + OOIPADDR* destAddr, int* destPort) +{ + struct sockaddr_in m_addr; + OOSOCKLEN addr_length = sizeof (m_addr); + + if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET; + if (pNewSocket == 0) return ASN_E_INVPARAM; + + *pNewSocket = accept (socket, (struct sockaddr *) (void*) &m_addr, + (socklen_t *) &addr_length); + if (*pNewSocket <= 0) return ASN_E_INVSOCKET; + + if (destAddr != 0) + *destAddr = ntohl (m_addr.sin_addr.s_addr); + if (destPort != 0) + *destPort = ntohs (m_addr.sin_port); + + return ASN_OK; +} + +int ooSocketConnect (OOSOCKET socket, const char* host, int port) +{ + struct sockaddr_in m_addr; + + if (socket == OOSOCKET_INVALID) + { + return ASN_E_INVSOCKET; + } + + memset (&m_addr, 0, sizeof (m_addr)); + + m_addr.sin_family = AF_INET; + m_addr.sin_port = htons ((unsigned short)port); + m_addr.sin_addr.s_addr = inet_addr (host); + + if (connect (socket, (struct sockaddr *) (void*) &m_addr, + sizeof (struct sockaddr_in)) == -1) + { + return ASN_E_INVSOCKET; + } + return ASN_OK; +} +/* +// **Need to add check whether complete data was sent by checking the return +// **value of send and if complete data is not sent then add mechanism to +// **send remaining bytes. This will make ooSocketSend call atomic. +*/ +int ooSocketSend (OOSOCKET socket, const ASN1OCTET* pdata, ASN1UINT size) +{ + if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET; + + if (send (socket, (const char*) pdata, size, SEND_FLAGS) == -1) + return ASN_E_INVSOCKET; + return ASN_OK; +} + +int ooSocketSendTo(OOSOCKET socket, const ASN1OCTET* pdata, ASN1UINT size, + const char* host, int port) +{ + struct sockaddr_in m_addr; + if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET; + + memset (&m_addr, 0, sizeof (m_addr)); + + m_addr.sin_family = AF_INET; + m_addr.sin_port = htons ((unsigned short)port); + m_addr.sin_addr.s_addr = inet_addr (host); + if (sendto (socket, (const char*) pdata, size, SEND_FLAGS, + (const struct sockaddr*)&m_addr, + sizeof(m_addr)) == -1) + return ASN_E_INVSOCKET; + return ASN_OK; +} + +int ooSocketRecvPeek(OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize) +{ + int len; + int flags = MSG_PEEK; + + if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET; + + if ((len = recv (socket, (char*) pbuf, bufsize, flags)) == -1) + return ASN_E_INVSOCKET; + return len; +} + +int ooSocketRecv (OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize) +{ + int len; + if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET; + + if ((len = recv (socket, (char*) pbuf, bufsize, 0)) == -1) + return ASN_E_INVSOCKET; + return len; +} + +int ooSocketRecvFrom (OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize, + char* remotehost, ASN1UINT hostBufLen, int * remoteport) +{ + struct sockaddr_in m_addr; + int len, addrlen; + char * host=NULL; + if (socket == OOSOCKET_INVALID) return ASN_E_INVSOCKET; + addrlen = sizeof(m_addr); + + memset (&m_addr, 0, sizeof (m_addr)); + + if ((len = recvfrom (socket, (char*) pbuf, bufsize, 0, + (struct sockaddr*)&m_addr, &addrlen)) == -1) + return ASN_E_INVSOCKET; + + if(remoteport) + *remoteport = ntohs(m_addr.sin_port); + if(remotehost) + { + host = inet_ntoa(m_addr.sin_addr); + if(strlen(host) < (hostBufLen-1)) + strcpy(remotehost, host); + else + return -1; + } + return len; +} + +int ooSocketSelect(int nfds, fd_set *readfds, fd_set *writefds, + fd_set *exceptfds, struct timeval * timeout) +{ + int ret; +#if defined (_WIN32) + ret = select(nfds, readfds, writefds, exceptfds, + (const struct timeval *) timeout); +#else + ret = select(nfds, readfds, writefds, exceptfds, timeout); +#endif + return ret; +} + +int ooGetLocalIPAddress(char * pIPAddrs) +{ + int ret; + struct hostent *phost; + struct in_addr addr; + char hostname[100]; + + if(pIPAddrs == NULL) + return -1; /* Need to find suitable return value */ + ret = gethostname(hostname, 100); + if(ret == 0) + { + phost = gethostbyname(hostname); + if(phost == NULL) + return -1; /* Need to define a return value if made part of rtsrc */ + memcpy(&addr, phost->h_addr_list[0], sizeof(struct in_addr)); + strcpy(pIPAddrs, inet_ntoa(addr)); + + } + else{ + return -1; + } + return ASN_OK; +} + +int ooSocketStrToAddr (const char* pIPAddrStr, OOIPADDR* pIPAddr) +{ + int b1, b2, b3, b4; + int rv = sscanf (pIPAddrStr, "%d.%d.%d.%d", &b1, &b2, &b3, &b4); + if (rv != 4 || + (b1 < 0 || b1 > 256) || (b2 < 0 || b2 > 256) || + (b3 < 0 || b3 > 256) || (b4 < 0 || b4 > 256)) + return ASN_E_INVPARAM; + *pIPAddr = ((b1 & 0xFF) << 24) | ((b2 & 0xFF) << 16) | + ((b3 & 0xFF) << 8) | (b4 & 0xFF); + return ASN_OK; +} + +int ooSocketConvertIpToNwAddr(char *inetIp, char *netIp) +{ + + struct sockaddr_in sin = {0}; +#ifdef _WIN32 + sin.sin_addr.s_addr = inet_addr(inetIp); + if(sin.sin_addr.s_addr == INADDR_NONE) + { + OOTRACEERR1("Error:Failed to convert address\n"); + return -1; + } +#else + if(!inet_aton(inetIp, &sin.sin_addr)) + { + OOTRACEERR1("Error:Failed to convert address\n"); + return -1; + } + +#endif + + memcpy(netIp, (char*)&sin.sin_addr.s_addr, sizeof(unsigned long)); + return ASN_OK; +} + +int ooSocketAddrToStr (OOIPADDR ipAddr, char* pbuf, int bufsize) +{ + char buf1[5], buf2[5], buf3[5], buf4[5]; + int cnt = 0; + + if (bufsize < 8) + return ASN_E_BUFOVFLW; + + cnt += sprintf (buf1, "%lu", (ipAddr >> 24) & 0xFF); + cnt += sprintf (buf2, "%lu", (ipAddr >> 16) & 0xFF); + cnt += sprintf (buf3, "%lu", (ipAddr >> 8) & 0xFF); + cnt += sprintf (buf4, "%lu", ipAddr & 0xFF); + if (bufsize < cnt + 4) + return ASN_E_BUFOVFLW; + sprintf (pbuf, "%s.%s.%s.%s", buf1, buf2, buf3, buf4); + return ASN_OK; +} + +int ooSocketsCleanup (void) +{ +#ifdef _WIN32 + int ret = WSACleanup(); + if(ret == 0) + return ASN_OK; + else + return ret; +#endif + return ASN_OK; +} + +long ooSocketHTONL(long val) +{ + return htonl(val); +} + +short ooSocketHTONS(short val) +{ + return htons(val); +} + +#ifndef _WIN32 +int ooSocketGetInterfaceList(OOCTXT *pctxt, OOInterface **ifList) +{ + OOSOCKET sock; + struct ifconf ifc; + int ifNum; + OOInterface *pIf=NULL; + + OOTRACEDBGA1("Retrieving local interfaces\n"); + if(ooSocketCreateUDP(&sock)!= ASN_OK) + { + OOTRACEERR1("Error:Failed to create udp socket - " + "ooSocketGetInterfaceList\n"); + return -1; + } +#ifdef SIOCGIFNUM + if(ioctl(sock, SIOCGIFNUM, &ifNum) >= 0) + { + OOTRACEERR1("Error: ioctl for ifNum failed\n"); + return -1; + } +#else + ifNum = 50; +#endif + + ifc.ifc_len = ifNum * sizeof(struct ifreq); + ifc.ifc_req = (struct ifreq *)memAlloc(pctxt, ifNum *sizeof(struct ifreq)); + if(!ifc.ifc_req) + { + OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - ifc.ifc_req\n"); + return -1; + } + + if (ioctl(sock, SIOCGIFCONF, &ifc) >= 0) { + void * ifEndList = (char *)ifc.ifc_req + ifc.ifc_len; + struct ifreq *ifName; + struct ifreq ifReq; + int flags; + for (ifName = ifc.ifc_req; (void*)ifName < ifEndList; ifName++) { + char *pName=NULL; + char addr[50]; +#ifdef ifr_netmask + char mask[50]; +#endif + + pIf = (struct OOInterface*)memAlloc(pctxt, sizeof(struct OOInterface)); + pName = (char*)memAlloc(pctxt, strlen(ifName->ifr_name)+1); + if(!pIf) + { + OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - " + "pIf/pName\n"); + return -1; + } + OOTRACEDBGA2("\tInterface name: %s\n", ifName->ifr_name); + + + strcpy(ifReq.ifr_name, ifName->ifr_name); + strcpy(pName, ifName->ifr_name); + pIf->name = pName; + + /* Check whether the interface is up*/ + if (ioctl(sock, SIOCGIFFLAGS, &ifReq) < 0) { + OOTRACEERR2("Error:Unable to determine status of interface %s\n", + pName); + memFreePtr(pctxt, pIf->name); + memFreePtr(pctxt, pIf); + continue; + } + flags = ifReq.ifr_flags; + if (!(flags & IFF_UP)) { + OOTRACEWARN2("Warn:Interface %s is not up\n", pName); + memFreePtr(pctxt, pIf->name); + memFreePtr(pctxt, pIf); + continue; + } + + /* Retrieve interface address */ + if (ioctl(sock, SIOCGIFADDR, &ifReq) < 0) + { + OOTRACEWARN2("Warn:Unable to determine address of interface %s\n", + pName); + memFreePtr(pctxt, pIf->name); + memFreePtr(pctxt, pIf); + continue; + } + strcpy(addr, inet_ntoa(((struct sockaddr_in*)&ifReq.ifr_addr)->sin_addr)); + OOTRACEDBGA2("\tIP address is %s\n", addr); + pIf->addr = (char*)memAlloc(pctxt, strlen(addr)+1); + if(!pIf->addr) + { + OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - " + "pIf->addr\n"); + memFreePtr(pctxt, pIf->name); + memFreePtr(pctxt, pIf); + return -1; + } + strcpy(pIf->addr, addr); + +#ifdef ifr_netmask + if (ioctl(sock, SIOCGIFNETMASK, &ifReq) < 0) + { + OOTRACEWARN2("Warn:Unable to determine mask for interface %s\n", + pName); + memFreePtr(pctxt, pIf->name); + memFreePtr(pctxt, pIf->addr); + memFreePtr(pctxt, pIf); + continue; + } + strcpy(mask, inet_ntoa(((struct sockaddr_in *)&ifReq.ifr_netmask)->sin_addr)); + OOTRACEDBGA2("\tMask is %s\n", mask); + pIf->mask = (char*)memAlloc(pctxt, strlen(mask)+1); + if(!pIf->mask) + { + OOTRACEERR1("Error:Memory - ooSocketGetInterfaceList - " + "pIf->mask\n"); + memFreePtr(pctxt, pIf->name); + memFreePtr(pctxt, pIf->addr); + memFreePtr(pctxt, pIf); + return -1; + } + strcpy(pIf->mask, mask); +#endif + pIf->next = NULL; + + /* Add to the list */ + if(!*ifList) + { + *ifList = pIf; + pIf = NULL; + } + else{ + pIf->next = *ifList; + *ifList = pIf; + pIf=NULL; + } +/* +#if defined(OO_FREEBSD) || defined(OO_OPENBSD) || defined(OO_NETBSD) || defined(OO_MACOSX) || defined(OO_VXWORKS) || defined(OO_RTEMS) || defined(OO_QNX) +#ifndef _SIZEOF_ADDR_IFREQ +#define _SIZEOF_ADDR_IFREQ(ifr) \ + ((ifr).ifr_addr.sa_len > sizeof(struct sockaddr) ? \ + (sizeof(struct ifreq) - sizeof(struct sockaddr) + \ + (ifr).ifr_addr.sa_len) : sizeof(struct ifreq)) +#endif + ifName = (struct ifreq *)((char *)ifName + _SIZEOF_ADDR_IFREQ(*ifName)); +#else + ifName++; +*/ + } + + } + return ASN_OK; +} +#endif diff --git a/addons/ooh323c/src/ooSocket.h b/addons/ooh323c/src/ooSocket.h new file mode 100644 index 000000000..6a28ef3ac --- /dev/null +++ b/addons/ooh323c/src/ooSocket.h @@ -0,0 +1,403 @@ +/* + * Copyright (C) 1997-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. + * + *****************************************************************************/ + +/** + * @file ooSocket.h + * Common runtime constants, data structure definitions, and run-time functions + * to support the sockets' operations. + */ +#ifndef _OOSOCKET_H_ +#define _OOSOCKET_H_ + +#ifdef _WIN32_WCE +#include +#elif defined(_WIN32) || defined(_WIN64) +#include +#define INCL_WINSOCK_API_TYPEDEFS 1 +#define INCL_WINSOCK_API_PROTOTYPES 0 +#include +#else +#include +#include "sys/time.h" +#include +#include +#include +#include +#include +#include +#include +#endif + +#include "ooasn1.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#elif defined (USEASN1DLL) +#define EXTERN __declspec(dllimport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +/** + * @defgroup sockets Socket Layer + * @{ + */ +#if defined (_WIN64) +typedef unsigned __int64 OOSOCKET; /**< Socket's handle */ +#elif defined (_WIN32) +typedef unsigned int OOSOCKET; /**< Socket's handle */ +#else +typedef int OOSOCKET; /**< Socket's handle */ +#endif + +#define OOSOCKET_INVALID ((OOSOCKET)-1) + + +/** + * The IP address represented as unsigned long value. The most significant 8 + * bits in this unsigned long value represent the first number of the IP + * address. The least significant 8 bits represent the last number of the IP + * address. + */ +typedef unsigned long OOIPADDR; + +#define OOIPADDR_ANY ((OOIPADDR)0) +#define OOIPADDR_LOCAL ((OOIPADDR)0x7f000001UL) /* 127.0.0.1 */ + +typedef struct OOInterface{ + char *name; + char *addr; + char *mask; + struct OOInterface *next; +}OOInterface; + + + +/** + * This function permits an incoming connection attempt on a socket. It + * extracts the first connection on the queue of pending connections on socket. + * It then creates a new socket and returns a handle to the new socket. The + * newly created socket is the socket that will handle the actual connection + * and has the same properties as original socket. See description of 'accept' + * socket function for further details. + * + * @param socket The socket's handle created by call to ::rtSocketCreate + * function. + * @param pNewSocket The pointer to variable to receive the new socket's + * handle. + * @param destAddr Optional pointer to a buffer that receives the IP + * address of the connecting entity. It may be NULL. + * @param destPort Optional pointer to a buffer that receives the port of + * the connecting entity. It may be NULL. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketAccept (OOSOCKET socket, OOSOCKET *pNewSocket, + OOIPADDR* destAddr, int* destPort); + +/** + * This function converts an IP address to its string representation. + * + * @param ipAddr The IP address to be converted. + * @param pbuf Pointer to the buffer to receive a string with the IP + * address. + * @param bufsize Size of the buffer. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketAddrToStr (OOIPADDR ipAddr, char* pbuf, int bufsize); + +/** + * This function associates a local address with a socket. It is used on an + * unconnected socket before subsequent calls to the ::rtSocketConnect or + * ::rtSocketListen functions. See description of 'bind' socket function for + * further details. + * + * @param socket The socket's handle created by call to ::rtSocketCreate + * function. + * @param addr The local IP address to assign to the socket. + * @param port The local port number to assign to the socket. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketBind (OOSOCKET socket, OOIPADDR addr, int port); + +/** + * This function closes an existing socket. + * + * @param socket The socket's handle created by call to ::rtSocketCreate + * or ::rtSocketAccept function. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketClose (OOSOCKET socket); + +/** + * This function establishes a connection to a specified socket. It is used to + * create a connection to the specified destination. When the socket call + * completes successfully, the socket is ready to send and receive data. See + * description of 'connect' socket function for further details. + * + * @param socket The socket's handle created by call to ::rtSocketCreate + * function. + * @param host The null-terminated string with the IP address in the + * following format: "NNN.NNN.NNN.NNN", where NNN is a + * number in the range (0..255). + * @param port The destination port to connect. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketConnect (OOSOCKET socket, const char* host, int port); + +/** + * This function creates a socket. The only streaming TCP/IP sockets are + * supported at the moment. + * + * @param psocket The pointer to the socket's handle variable to receive + * the handle of new socket. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketCreate (OOSOCKET* psocket); + +/** + * This function creates a UDP datagram socket. + * + * @param psocket The pointer to the socket's handle variable to receive + * the handle of new socket. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketCreateUDP (OOSOCKET* psocket); + +/** + * This function initiates use of sockets by an application. This function must + * be called first before use sockets. + * + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketsInit (void); + +/** + * This function terminates use of sockets by an application. This function + * must be called after done with sockets. + * + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketsCleanup (void); + +/** + * This function places a socket a state where it is listening for an incoming + * connection. To accept connections, a socket is first created with the + * ::rtSocketCreate function and bound to a local address with the + * ::rtSocketBind function, a maxConnection for incoming connections is + * specified with ::rtSocketListen, and then the connections are accepted with + * the ::rtSocketAccept function. See description of 'listen' socket function + * for further details. + * + * @param socket The socket's handle created by call to + * ::rtSocketCreate function. + * @param maxConnection Maximum length of the queue of pending connections. + * @return Completion status of operation: 0 (ASN_OK) = + * success, negative return value is error. + */ +EXTERN int ooSocketListen (OOSOCKET socket, int maxConnection); + + +/** + * This function is used to peek at the received data without actually removing + * it from the receive socket buffer. A receive call after this will get the + * same data from the socket. + * @param socket The socket's handle created by call to ::rtSocketCreate + * or ::rtSocketAccept function. + * @param pbuf Pointer to the buffer for the incoming data. + * @param bufsize Length of the buffer. + * @return If no error occurs, returns the number of bytes + * received. Otherwise, the negative value is error code. + */ +EXTERN int ooSocketRecvPeek + (OOSOCKET socket, ASN1OCTET* pbuf, ASN1UINT bufsize); + +/** + * This function receives data from a connected socket. It is used to read + * incoming data on sockets. The socket must be connected before calling this + * function. See description of 'recv' socket function for further details. + * + * @param socket The socket's handle created by call to ::rtSocketCreate + * or ::rtSocketAccept function. + * @param pbuf Pointer to the buffer for the incoming data. + * @param bufsize Length of the buffer. + * @return If no error occurs, returns the number of bytes + * received. Otherwise, the negative value is error code. + */ +EXTERN int ooSocketRecv (OOSOCKET socket, ASN1OCTET* pbuf, + ASN1UINT bufsize); + +/** + * This function receives data from a connected/unconnected socket. It is used + * to read incoming data on sockets. It populates the remotehost and + * remoteport parameters with information of remote host. See description of + * 'recvfrom' socket function for further details. + * + * @param socket The socket's handle created by call to ooSocketCreate + * + * @param pbuf Pointer to the buffer for the incoming data. + * @param bufsize Length of the buffer. + * @param remotehost Pointer to a buffer in which remote ip address + * will be returned. + * @param hostBufLen Length of the buffer passed for remote ip address. + * @param remoteport Pointer to an int in which remote port number + * will be returned. + * + * @return If no error occurs, returns the number of bytes + * received. Otherwise, negative value. + */ +EXTERN int ooSocketRecvFrom (OOSOCKET socket, ASN1OCTET* pbuf, + ASN1UINT bufsize, char * remotehost, + ASN1UINT hostBufLen, int * remoteport); +/** + * This function sends data on a connected socket. It is used to write outgoing + * data on a connected socket. See description of 'send' socket function for + * further details. + * + * @param socket The socket's handle created by call to ::rtSocketCreate + * or ::rtSocketAccept function. + * @param pdata Buffer containing the data to be transmitted. + * @param size Length of the data in pdata. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketSend (OOSOCKET socket, const ASN1OCTET* pdata, + ASN1UINT size); + +/** + * This function sends data on a connected or unconnected socket. See + * description of 'sendto' socket function for further details. + * + * @param socket The socket's handle created by call to ::rtSocketCreate + * or ::rtSocketAccept function. + * @param pdata Buffer containing the data to be transmitted. + * @param size Length of the data in pdata. + * @param remotehost Remote host ip address to which data has to + * be sent. + * @param remoteport Remote port ip address to which data has to + * be sent. + * + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketSendTo(OOSOCKET socket, const ASN1OCTET* pdata, + ASN1UINT size, const char* remotehost, + int remoteport); + +/** + * This function is used for synchronous monitoring of multiple sockets. + * For more information refer to documnetation of "select" system call. + * + * @param nfds The highest numbered descriptor to be monitored + * plus one. + * @param readfds The descriptors listed in readfds will be watched for + * whether read would block on them. + * @param writefds The descriptors listed in writefds will be watched for + * whether write would block on them. + * @param exceptfds The descriptors listed in exceptfds will be watched for + * exceptions. + * @param timeout Upper bound on amout of time elapsed before select + * returns. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketSelect(int nfds, fd_set *readfds, fd_set *writefds, + fd_set *exceptfds, struct timeval * timeout); + +/** + * This function converts the string with IP address to a double word + * representation. The converted address may be used with the ::rtSocketBind + * function. + * + * @param pIPAddrStr The null-terminated string with the IP address in the + * following format: "NNN.NNN.NNN.NNN", where NNN is a + * number in the range (0..255). + * @param pIPAddr Pointer to the converted IP address. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketStrToAddr (const char* pIPAddrStr, OOIPADDR* pIPAddr); + +/** + * This function converts an internet dotted ip address to network address + * + * @param inetIp The null-terminated string with the IP address in the + * following format: "NNN.NNN.NNN.NNN", where NNN is a + * number in the range (0..255). + * @param netIp Buffer in which the converted address will be returned. + + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooSocketConvertIpToNwAddr(char *inetIp, char *netIp); + +/** + * This function retrives the IP address of the local host. + * + * @param pIPAddrs Pointer to a char buffer in which local IP address will be + * returned. + * @return Completion status of operation: 0 (ASN_OK) = success, + * negative return value is error. + */ +EXTERN int ooGetLocalIPAddress(char * pIPAddrs); + + +EXTERN int ooSocketGetSockName(OOSOCKET socket, struct sockaddr_in *name, + int *size); + + +EXTERN long ooSocketHTONL(long val); + +EXTERN short ooSocketHTONS(short val); + +/** + * This function is used to retrieve the ip and port number used by the socket + * passed as parameter. It internally uses getsockname system call for this + * purpose. + * @param socket Socket for which ip and port has to be determined. + * @param ip Buffer in which ip address will be returned. + * @param len Length of the ip address buffer. + * @param port Pointer to integer in which port number will be returned. + * + * @return ASN_OK, on success; -ve on failed. + */ +EXTERN int ooSocketGetIpAndPort(OOSOCKET socket, char *ip, int len, int *port); + + +EXTERN int ooSocketGetInterfaceList(OOCTXT *pctxt, OOInterface **ifList); +/** + * @} + */ +#ifdef __cplusplus +} +#endif + +#endif /* _OOSOCKET_H_ */ + diff --git a/addons/ooh323c/src/ooStackCmds.c b/addons/ooh323c/src/ooStackCmds.c new file mode 100644 index 000000000..a75a33cb0 --- /dev/null +++ b/addons/ooh323c/src/ooStackCmds.c @@ -0,0 +1,339 @@ +/* + * 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 "ooStackCmds.h" +#include "ooh323ep.h" +#include "ooCalls.h" +#include "ooCmdChannel.h" + +extern OOSOCKET gCmdChan; + +int ooGenerateOutgoingCallToken (char *callToken, size_t size) +{ + static int counter = 1; + char aCallToken[200]; + int ret = 0; + + + sprintf (aCallToken, "ooh323c_o_%d", counter++); + + if (counter > OO_MAX_CALL_TOKEN) + counter = 1; + + if ((strlen(aCallToken)+1) < size) + strcpy (callToken, aCallToken); + else { + ret = OO_FAILED; + } + + return ret; +} + + +OOStkCmdStat ooMakeCall + (const char* dest, char* callToken, size_t bufsiz, ooCallOptions *opts) +{ + OOStackCommand cmd; + + if(!callToken) + return OO_STKCMD_INVALIDPARAM; + + + /* Generate call token*/ + if (ooGenerateOutgoingCallToken (callToken, bufsiz) != OO_OK){ + return OO_STKCMD_INVALIDPARAM; + } + + if(gCmdChan == 0) + { + if(ooCreateCmdConnection() != OO_OK) + return OO_STKCMD_CONNECTIONERR; + } + + memset(&cmd, 0, sizeof(OOStackCommand)); + cmd.type = OO_CMD_MAKECALL; + cmd.param1 = (void*) malloc(strlen(dest)+1); + if(!cmd.param1) + { + return OO_STKCMD_MEMERR; + } + strcpy((char*)cmd.param1, dest); + + + cmd.param2 = (void*) malloc(strlen(callToken)+1); + if(!cmd.param2) + { + free(cmd.param1); + return OO_STKCMD_MEMERR; + } + + strcpy((char*)cmd.param2, callToken); + + if(!opts) + { + cmd.param3 = 0; + } + else { + cmd.param3 = (void*) malloc(sizeof(ooCallOptions)); + if(!cmd.param3) + { + free(cmd.param1); + free(cmd.param2); + return OO_STKCMD_MEMERR; + } + memcpy((void*)cmd.param3, opts, sizeof(ooCallOptions)); + } + + if(ooWriteStackCommand(&cmd) != OO_OK) + { + free(cmd.param1); + free(cmd.param2); + if(cmd.param3) free(cmd.param3); + return OO_STKCMD_WRITEERR; + } + + return OO_STKCMD_SUCCESS; +} + + +OOStkCmdStat ooManualRingback(const char *callToken) +{ + OOStackCommand cmd; + if(!callToken) + { + return OO_STKCMD_INVALIDPARAM; + } + + if(gCmdChan == 0) + { + if(ooCreateCmdConnection() != OO_OK) + return OO_STKCMD_CONNECTIONERR; + } + + memset(&cmd, 0, sizeof(OOStackCommand)); + cmd.type = OO_CMD_MANUALRINGBACK; + cmd.param1 = (void*) malloc(strlen(callToken)+1); + if(!cmd.param1) + { + return OO_STKCMD_MEMERR; + } + strcpy((char*)cmd.param1, callToken); + + if(ooWriteStackCommand(&cmd) != OO_OK) + { + free(cmd.param1); + return OO_STKCMD_WRITEERR; + } + + return OO_STKCMD_SUCCESS; +} + +OOStkCmdStat ooAnswerCall(const char *callToken) +{ + OOStackCommand cmd; + + if(!callToken) + { + return OO_STKCMD_INVALIDPARAM; + } + + if(gCmdChan == 0) + { + if(ooCreateCmdConnection() != OO_OK) + return OO_STKCMD_CONNECTIONERR; + } + + memset(&cmd, 0, sizeof(OOStackCommand)); + cmd.type = OO_CMD_ANSCALL; + + cmd.param1 = (void*) malloc(strlen(callToken)+1); + if(!cmd.param1) + { + return OO_STKCMD_MEMERR; + } + strcpy((char*)cmd.param1, callToken); + + if(ooWriteStackCommand(&cmd) != OO_OK) + { + free(cmd.param1); + return OO_STKCMD_WRITEERR; + } + + return OO_STKCMD_SUCCESS; +} + +OOStkCmdStat ooForwardCall(const char* callToken, char *dest) +{ + OOStackCommand cmd; + + if(!callToken || !dest) + { + return OO_STKCMD_INVALIDPARAM; + } + + if(gCmdChan == 0) + { + if(ooCreateCmdConnection() != OO_OK) + return OO_STKCMD_CONNECTIONERR; + } + + memset(&cmd, 0, sizeof(OOStackCommand)); + cmd.type = OO_CMD_FWDCALL; + + cmd.param1 = (void*) malloc(strlen(callToken)+1); + cmd.param2 = (void*) malloc(strlen(dest)+1); + if(!cmd.param1 || !cmd.param2) + { + if(cmd.param1) free(cmd.param1); /* Release memory */ + if(cmd.param2) free(cmd.param2); + return OO_STKCMD_MEMERR; + } + strcpy((char*)cmd.param1, callToken); + strcpy((char*)cmd.param2, dest); + + if(ooWriteStackCommand(&cmd) != OO_OK) + { + free(cmd.param1); + free(cmd.param2); + return OO_STKCMD_WRITEERR; + } + + return OO_STKCMD_SUCCESS; +} + + +OOStkCmdStat ooHangCall(const char* callToken, OOCallClearReason reason) +{ + OOStackCommand cmd; + + if(!callToken) + { + return OO_STKCMD_INVALIDPARAM; + } + + if(gCmdChan == 0) + { + if(ooCreateCmdConnection() != OO_OK) + return OO_STKCMD_CONNECTIONERR; + } + + memset(&cmd, 0, sizeof(OOStackCommand)); + cmd.type = OO_CMD_HANGCALL; + cmd.param1 = (void*) malloc(strlen(callToken)+1); + cmd.param2 = (void*) malloc(sizeof(OOCallClearReason)); + if(!cmd.param1 || !cmd.param2) + { + if(cmd.param1) free(cmd.param1); /* Release memory */ + if(cmd.param2) free(cmd.param2); + return OO_STKCMD_MEMERR; + } + strcpy((char*)cmd.param1, callToken); + *((OOCallClearReason*)cmd.param2) = reason; + + if(ooWriteStackCommand(&cmd) != OO_OK) + { + free(cmd.param1); + free(cmd.param2); + return OO_STKCMD_WRITEERR; + } + + return OO_STKCMD_SUCCESS; +} + + +OOStkCmdStat ooStopMonitor() +{ + OOStackCommand cmd; + + if(gCmdChan == 0) + { + if(ooCreateCmdConnection() != OO_OK) + return OO_STKCMD_CONNECTIONERR; + } + + memset(&cmd, 0, sizeof(OOStackCommand)); + cmd.type = OO_CMD_STOPMONITOR; + + if(ooWriteStackCommand(&cmd) != OO_OK) + return OO_STKCMD_WRITEERR; + + return OO_STKCMD_SUCCESS; +} + +OOStkCmdStat ooSendDTMFDigit(const char *callToken, const char* dtmf) +{ + OOStackCommand cmd; + + if(!callToken) + { + return OO_STKCMD_INVALIDPARAM; + } + + if(gCmdChan == 0) + { + if(ooCreateCmdConnection() != OO_OK) + return OO_STKCMD_CONNECTIONERR; + } + + memset(&cmd, 0, sizeof(OOStackCommand)); + cmd.type = OO_CMD_SENDDIGIT; + + cmd.param1 = (void*) malloc(strlen(callToken)+1); + cmd.param2 = (void*) malloc(strlen(dtmf)+1); + if(!cmd.param1 || !cmd.param2) + { + if(cmd.param1) free(cmd.param1); /* Release memory */ + if(cmd.param2) free(cmd.param2); + return OO_STKCMD_MEMERR; + } + strcpy((char*)cmd.param1, callToken); + strcpy((char*)cmd.param2, dtmf); + + if(ooWriteStackCommand(&cmd) != OO_OK) + { + free(cmd.param1); + free(cmd.param2); + return OO_STKCMD_WRITEERR; + } + + return OO_STKCMD_SUCCESS; +} + + +const char* ooGetStkCmdStatusCodeTxt(OOStkCmdStat stat) +{ + switch(stat) + { + case OO_STKCMD_SUCCESS: + return "Stack command - successfully issued"; + + case OO_STKCMD_MEMERR: + return "Stack command - Memory allocation error"; + + case OO_STKCMD_INVALIDPARAM: + return "Stack command - Invalid parameter"; + + case OO_STKCMD_WRITEERR: + return "Stack command - write error"; + + case OO_STKCMD_CONNECTIONERR: + return "Stack command - Failed to create command channel"; + + default: + return "Invalid status code"; + } +} + diff --git a/addons/ooh323c/src/ooStackCmds.h b/addons/ooh323c/src/ooStackCmds.h new file mode 100644 index 000000000..7ba9d7226 --- /dev/null +++ b/addons/ooh323c/src/ooStackCmds.h @@ -0,0 +1,171 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * @file ooStackCmds.h + * This file contains stack commands which an user application can use to make + * call, hang call etc. + */ + +#ifndef OO_STACKCMDS_H +#define OO_STACKCMDS_H + +#include "ootypes.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#if defined (MAKE_DLL) +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + + + +/** + * @defgroup stackcmds Stack Control Commands + * @{ + */ + +/** + * This is an enumeration of Stack Command return codes. + */ +typedef enum OOStkCmdStat{ + OO_STKCMD_SUCCESS, + OO_STKCMD_MEMERR, + OO_STKCMD_INVALIDPARAM, + OO_STKCMD_WRITEERR, + OO_STKCMD_CONNECTIONERR +}OOStkCmdStat; + +/** + * This is an enumeration of stack command codes. + */ +typedef enum OOStackCmdID { + OO_CMD_NOOP, + OO_CMD_MAKECALL, /*!< Make call */ + OO_CMD_ANSCALL, /*!< Answer call */ + OO_CMD_FWDCALL, /*!< Forward call */ + OO_CMD_HANGCALL, /*!< Terminate call */ + OO_CMD_SENDDIGIT, /*!< Send dtmf */ + OO_CMD_MANUALRINGBACK, /*!< Send Alerting - ringback */ + OO_CMD_STOPMONITOR /*!< Stop the event monitor */ + +} OOStackCmdID; + +/** + * This structure is used to queue a stack command for processing in + * the event handler loop. + */ +typedef struct OOStackCommand { + OOStackCmdID type; + void* param1; + void* param2; + void* param3; +} OOStackCommand; + +#define ooCommand OOStackCommand; + +/** + * This function is used by an application to place a call. + * @param dest Call Destination - IP:port / alias + * @param callToken Pointer to a buffer in which callToken will be returned + * @param bufsiz Size of the callToken buffer passed. + * @param opts These are call specific options and if passed a non-null + * value, will override global endpoint options. + * + * @return Returns OOStkCmdStat value indication success or failure. + */ +EXTERN OOStkCmdStat ooMakeCall + (const char* dest, char *callToken, size_t bufsiz, ooCallOptions *opts); + + + +/** + * This function is used to send a manual ringback message (alerting message) + * for a call. Effective only when manual-ringback is enabled. + * @param callToken Unique token for the call. + * + * @return Returns OOStkCmdStat value indication success or failure. + */ +EXTERN OOStkCmdStat ooManualRingback(const char *callToken); + +/** + * This function is used to answer a call + * @param callToken Unique token for the call + * + * @return Returns OOStkCmdStat value indication success or failure. + */ +EXTERN OOStkCmdStat ooAnswerCall(const char *callToken); + +/** + * This function is used to forward an existing call to third party. + * @param callToken Unique token for the call. + * @param dest Address to which the call has to be forwarded. Can be + * IP:PORT or alias. + * + * @return Returns OOStkCmdStat value indication success or failure. + */ +EXTERN OOStkCmdStat ooForwardCall(const char* callToken, char *dest); + +/** + * This function is used by an user application to terminate a call. + * @param callToken The uinque token for the call. + * @param reason Reason for hanging call. + * + * @return Returns OOStkCmdStat value indication success or failure. + */ +EXTERN OOStkCmdStat ooHangCall(const char* callToken, OOCallClearReason reason); + +/** + * This command function can be used by an user application to send a DTMF + * sequence using H.245 UserInputIndication message. + * @param callToken Unique token for the call + * @param alpha Alphanumeric string reperesenting dtmf sequence + * + * @return Returns OOStkCmdStat value indication success or failure. + */ +EXTERN OOStkCmdStat ooSendDTMFDigit(const char *callToken, const char* alpha); + + +/** + * This function is used by the user application to stop stack thread. + * + * @return Returns OOStkCmdStat value indication success or failure. + */ +EXTERN OOStkCmdStat ooStopMonitor(void); + + +/** + * This function is used by application to obtain the text description for + * failure of tsack command. + * @param stat Status code returned by stack command api. + * + * @return Text description corresponding to the code. + */ +EXTERN const char* ooGetStkCmdStatusCodeTxt(OOStkCmdStat stat); +/** + * @} + */ + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/ooTimer.c b/addons/ooh323c/src/ooTimer.c new file mode 100644 index 000000000..c91ec9ee3 --- /dev/null +++ b/addons/ooh323c/src/ooTimer.c @@ -0,0 +1,193 @@ +/* + * 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 LICENSE.txt 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 "ooDateTime.h" +#include "ooTimer.h" +#include "ootrace.h" + +#define USECS_IN_SECS 1000000 +#define NSECS_IN_USECS 1000 + +#ifndef MICROSEC +#define MICROSEC USECS_IN_SECS +#endif + +/** + * This is a timer list used by test application chansetup only. + */ + +DList g_TimerList; + +OOTimer* ooTimerCreate +(OOCTXT* pctxt, DList *pList, OOTimerCbFunc cb, OOUINT32 deltaSecs, void *data, + OOBOOL reRegister) +{ + OOTimer* pTimer = (OOTimer*) memAlloc (pctxt, sizeof(OOTimer)); + if (0 == pTimer) return 0; + + memset (pTimer, 0, (sizeof(OOTimer))); + pTimer->timeoutCB = cb; + pTimer->cbData = data; + pTimer->reRegister = reRegister; + pTimer->timeout.tv_sec = deltaSecs; + pTimer->timeout.tv_usec = 0; + + /* Compute the absolute time at which this timer should expire */ + + ooTimerComputeExpireTime (pTimer); + + /* Insert this timer into the complete list */ + if(pList) + ooTimerInsertEntry (pctxt, pList, pTimer); + else + ooTimerInsertEntry (pctxt, &g_TimerList, pTimer); + + return pTimer; +} + +void ooTimerComputeExpireTime (OOTimer* pTimer) +{ + struct timeval tv; + ooGetTimeOfDay (&tv, 0); + + /* Compute delta time to expiration */ + + pTimer->expireTime.tv_usec = tv.tv_usec + pTimer->timeout.tv_usec; + pTimer->expireTime.tv_sec = tv.tv_sec + pTimer->timeout.tv_sec; + + while (pTimer->expireTime.tv_usec >= MICROSEC) { + pTimer->expireTime.tv_usec -= MICROSEC; + pTimer->expireTime.tv_sec++; + } +} + +void ooTimerDelete (OOCTXT* pctxt, DList *pList, OOTimer* pTimer) +{ + dListFindAndRemove (pList, pTimer); + memFreePtr (pctxt, pTimer); +} + +OOBOOL ooTimerExpired (OOTimer* pTimer) +{ + struct timeval tvstr; + ooGetTimeOfDay (&tvstr, 0); + + if (tvstr.tv_sec > pTimer->expireTime.tv_sec) + return TRUE; + + if ((tvstr.tv_sec == pTimer->expireTime.tv_sec) && + (tvstr.tv_usec > pTimer->expireTime.tv_usec)) + return TRUE; + + return FALSE; +} + +void ooTimerFireExpired (OOCTXT* pctxt, DList *pList) +{ + OOTimer* pTimer; + int stat; + + while (pList->count > 0) { + pTimer = (OOTimer*) pList->head->data; + + if (ooTimerExpired (pTimer)) { + /* + * Re-register before calling callback function in case it is + * a long duration callback. + */ + if (pTimer->reRegister) ooTimerReset (pctxt, pList, pTimer); + + stat = (*pTimer->timeoutCB)(pTimer->cbData); + + if (0 != stat || !pTimer->reRegister) { + ooTimerDelete (pctxt, pList, pTimer); + } + } + else break; + } +} + +int ooTimerInsertEntry (OOCTXT* pctxt, DList *pList, OOTimer* pTimer) +{ DListNode* pNode; + OOTimer* p; + int i = 0; + + for (pNode = pList->head; pNode != 0; pNode = pNode->next) { + p = (OOTimer*) pNode->data; + if (pTimer->expireTime.tv_sec < p->expireTime.tv_sec) break; + if (pTimer->expireTime.tv_sec == p->expireTime.tv_sec && + pTimer->expireTime.tv_usec <= p->expireTime.tv_usec) break; + i++; + } + + dListInsertBefore (pctxt, pList, pNode, pTimer); + + return i; +} + +struct timeval* ooTimerNextTimeout (DList *pList, struct timeval* ptimeout) +{ + OOTimer* ptimer; + struct timeval tvstr; + + if (pList->count == 0) return 0; + ptimer = (OOTimer*) pList->head->data; + + ooGetTimeOfDay (&tvstr, 0); + + ptimeout->tv_sec = + OOMAX ((int) 0, (int) (ptimer->expireTime.tv_sec - tvstr.tv_sec)); + + ptimeout->tv_usec = ptimer->expireTime.tv_usec - tvstr.tv_usec; + + while (ptimeout->tv_usec < 0) { + ptimeout->tv_sec--; + ptimeout->tv_usec += USECS_IN_SECS; + } + + if (ptimeout->tv_sec < 0) + ptimeout->tv_sec = ptimeout->tv_usec = 0; + + return (ptimeout); +} + +/* + * Reregister a timer entry. This function is responsible for moving + * the current pointer in the timer list to the next element to be + * processed.. + */ +void ooTimerReset (OOCTXT* pctxt, DList *pList, OOTimer* pTimer) +{ + if (pTimer->reRegister) { + dListFindAndRemove (pList, pTimer); + ooTimerComputeExpireTime (pTimer); + ooTimerInsertEntry (pctxt, pList, pTimer); + } + else + ooTimerDelete (pctxt, pList, pTimer); +} + +int ooCompareTimeouts(struct timeval *to1, struct timeval *to2) +{ + + if(to1->tv_sec > to2->tv_sec) return 1; + if(to1->tv_sec < to2->tv_sec) return -1; + + if(to1->tv_usec > to2->tv_usec) return 1; + if(to1->tv_usec < to2->tv_usec) return -1; + + return 0; +} diff --git a/addons/ooh323c/src/ooTimer.h b/addons/ooh323c/src/ooTimer.h new file mode 100644 index 000000000..2283ba4d9 --- /dev/null +++ b/addons/ooh323c/src/ooTimer.h @@ -0,0 +1,128 @@ +/* + * 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 LICENSE.txt 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. + * + *****************************************************************************/ +/** + * @file ooTimer.h + * Timer structures and functions. + */ +#ifndef _OOTIMER_H_ +#define _OOTIMER_H_ + +#include "ooasn1.h" +#include "ooSocket.h" /* needed for timeval */ + +struct _OOTimer; + +typedef int (*OOTimerCbFunc)(void *data); + +typedef struct _OOTimer { + struct timeval expireTime, timeout; + void* cbData; + OOBOOL reRegister; + + /* Callback functions */ + OOTimerCbFunc timeoutCB; +} OOTimer; + +#ifdef __cplusplus +extern "C" { +#endif + +/** + * This function computes the relative expiration time from the current + * time for the given timer object. + * + * @param pTimer Pointer to timer object. + */ +EXTERN void ooTimerComputeExpireTime (OOTimer* pTimer); + +/** + * This function creates and initializes a new timer object. + * @param pctxt OOCTXT structure used for timer memory allocation. + * @param pList Pointer to timer list in which newly created timer will + * be inserted. + * @param cb Timer callback function. + * @param deltaSecs Time in seconds to timer expiration. + * @param data Callback user data argument. + * @param reRegister Should timer be re-registered after it expires? + * @return Pointer to created timer object. + */ +EXTERN OOTimer* ooTimerCreate +(OOCTXT* pctxt, DList *pList, OOTimerCbFunc cb, OOUINT32 deltaSecs, void *data, + OOBOOL reRegister); + +/** + * This function deletes the given timer object. + * @param pctxt Handle to OOCTXT structure used for timer memory. + * @param pList timer list to operate on + * @param pTimer Pointer to timer object. + */ +EXTERN void ooTimerDelete (OOCTXT* pctxt, DList* pList, OOTimer* pTimer); + +/** + * This function checks a timer to determine if it is expired. + * + * @param pTimer Pointer to timer object. + * @return True if timer expired, false if not. + */ +EXTERN OOBOOL ooTimerExpired (OOTimer* pTimer); + +/** + * This function loops through the global timer list and fires all + * expired timers by calling the registered callback functions. + */ +EXTERN void ooTimerFireExpired (OOCTXT* pctxt, DList* pList); + +/** + * This function inserts the given timer object into the correct + * chronological position in the global timer list. + * @param pctxt Pointer to OOCTXT structure used for memory allocation. + * @param pList List in which timer has to be inserted. + * @param pTimer Pointer to timer object. + * @return Index to position where inserted in list. + */ +EXTERN int ooTimerInsertEntry (OOCTXT* pctxt, DList* pList, OOTimer* pTimer); + +/** + * This function calculates the relative time from the current time + * that the first timer in global timer list will expire. + * @param pList Handle to timer list + * @param ptimeout timeval structure to receive timeout value. + * @return ptimeout + */ +EXTERN struct timeval* ooTimerNextTimeout (DList* pList, struct timeval* ptimeout); + +/** + * This function resets the given timer object if its reregister flag + * is set. Otherwise, it is deleted. + * @param pctxt Pointer to OOCTXT structre used for memory allocation. + * @param pList Pointer to timer list. + * @param pTimer Pointer to timer object. + */ +EXTERN void ooTimerReset (OOCTXT* pctxt, DList* pList, OOTimer* pTimer); + + +/** + * This function is used to compare two timeout values. + * @param to1 First timeout value. + * @param to2 Second timeout value. + * + * @return 1, if to1 > to2; 0, if to1 == to2; -1, if to1 < to2 + */ +int ooCompareTimeouts(struct timeval *to1, struct timeval *to2); +#ifdef __cplusplus +} +#endif +#endif diff --git a/addons/ooh323c/src/ooUtils.c b/addons/ooh323c/src/ooUtils.c new file mode 100644 index 000000000..71b285f62 --- /dev/null +++ b/addons/ooh323c/src/ooUtils.c @@ -0,0 +1,40 @@ +/* + * 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 "ooUtils.h" + +const char* ooUtilsGetText (OOUINT32 idx, const char** table, size_t tabsiz) +{ + return (idx < tabsiz) ? table[idx] : "?"; +} + +OOBOOL ooUtilsIsStrEmpty (const char* str) +{ + return (str == NULL || *str =='\0'); +} + + +OOBOOL ooIsDailedDigit(const char* str) +{ + if(str == NULL || *str =='\0') { return FALSE; } + while(*str != '\0') + { + if(!isdigit(*str) && + *str != '#' && *str != '*' && *str != ',') { return FALSE; } + str++; + } + return TRUE; +} diff --git a/addons/ooh323c/src/ooUtils.h b/addons/ooh323c/src/ooUtils.h new file mode 100644 index 000000000..1a84dd42e --- /dev/null +++ b/addons/ooh323c/src/ooUtils.h @@ -0,0 +1,53 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * @file ooUtils.h + * This file contains general utility functions. + */ +#ifndef _OOUTILS_H_ +#define _OOUTILS_H_ +#include "ootypes.h" + +/** + * Get text from a text table for a given enumeration index. + * + * @param idx Index of item in table + * @param table The table containing the text items + * @param tabsiz Number of items in the table + * @return Text for item or '?' if idx outside bounds of table + */ +EXTERN const char* ooUtilsGetText +(OOUINT32 idx, const char** table, size_t tabsiz); + +/** + * Test if given string value is empty. String is considered to empty + * if value is NULL or there are no characters in string (strlen == 0). + * + * @param str String to test + * @return TRUE if string empty; FALSE otherwise + */ +EXTERN OOBOOL ooUtilsIsStrEmpty (const char * str); + + +/** + * Test if given string value is digit string. + * + * @param str String to test + * @return TRUE if string contains all digits; FALSE otherwise + */ +EXTERN OOBOOL ooIsDailedDigit(const char* str); + +#endif diff --git a/addons/ooh323c/src/ooasn1.h b/addons/ooh323c/src/ooasn1.h new file mode 100644 index 000000000..47219fac2 --- /dev/null +++ b/addons/ooh323c/src/ooasn1.h @@ -0,0 +1,1814 @@ +/* + * Copyright (C) 1997-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. + * + *****************************************************************************/ +/** + * @file ooasn1.h + * Common ASN.1 runtime constants, data structure definitions, and run-time + * functions to support ASN.1 PER encoding/decoding as defined in the + * ITU-T standards. + */ +#ifndef _OOASN1_H_ +#define _OOASN1_H_ + +#include +#include +#include +#include +#include "dlist.h" +#include "ootrace.h" +/** + * @defgroup cruntime C Runtime Common Functions + * @{ + */ + +/* Error Code Constants */ + +#define ASN_OK 0 /* normal completion status */ +#define ASN_OK_FRAG 2 /* message fragment detected */ +#define ASN_E_BUFOVFLW -1 /* encode buffer overflow */ +#define ASN_E_ENDOFBUF -2 /* unexpected end of buffer on decode */ +#define ASN_E_IDNOTFOU -3 /* identifer not found */ +#define ASN_E_INVOBJID -4 /* invalid object identifier */ +#define ASN_E_INVLEN -5 /* invalid field length */ +#define ASN_E_INVENUM -6 /* enumerated value not in defined set */ +#define ASN_E_SETDUPL -7 /* duplicate element in set */ +#define ASN_E_SETMISRQ -8 /* missing required element in set */ +#define ASN_E_NOTINSET -9 /* element not part of set */ +#define ASN_E_SEQOVFLW -10 /* sequence of field overflow */ +#define ASN_E_INVOPT -11 /* invalid option encountered in choice */ +#define ASN_E_NOMEM -12 /* no dynamic memory available */ +#define ASN_E_INVHEXS -14 /* invalid hex string */ +#define ASN_E_INVBINS -15 /* invalid binary string */ +#define ASN_E_INVREAL -16 /* invalid real value */ +#define ASN_E_STROVFLW -17 /* octet or bit string field overflow */ +#define ASN_E_BADVALUE -18 /* invalid value specification */ +#define ASN_E_UNDEFVAL -19 /* no def found for ref'd defined value */ +#define ASN_E_UNDEFTYP -20 /* no def found for ref'd defined type */ +#define ASN_E_BADTAG -21 /* invalid tag value */ +#define ASN_E_TOODEEP -22 /* nesting level is too deep */ +#define ASN_E_CONSVIO -23 /* value constraint violation */ +#define ASN_E_RANGERR -24 /* invalid range (lower > upper) */ +#define ASN_E_ENDOFFILE -25 /* end of file on file decode */ +#define ASN_E_INVUTF8 -26 /* invalid UTF-8 encoding */ +#define ASN_E_CONCMODF -27 /* Concurrent list modification */ +#define ASN_E_ILLSTATE -28 /* Illegal state error */ +#define ASN_E_OUTOFBND -29 /* out of bounds (of array, etc) */ +#define ASN_E_INVPARAM -30 /* invalid parameter */ +#define ASN_E_INVFORMAT -31 /* invalid time string format */ +#define ASN_E_NOTINIT -32 /* not initialized */ +#define ASN_E_TOOBIG -33 /* value is too big for given data type */ +#define ASN_E_INVCHAR -34 /* invalid character (not in char set) */ +#define ASN_E_XMLSTATE -35 /* XML state error */ +#define ASN_E_XMLPARSE -36 /* XML parse error */ +#define ASN_E_SEQORDER -37 /* SEQUENCE elements not in order */ +#define ASN_E_INVINDEX -38 /* invalid index for TC id */ +#define ASN_E_INVTCVAL -39 /* invalid value for TC field */ +#define ASN_E_FILNOTFOU -40 /* file not found */ +#define ASN_E_FILEREAD -41 /* error occurred reading file */ +#define ASN_E_FILEWRITE -42 /* error occurred writing file */ +#define ASN_E_INVBASE64 -43 /* invalid base64 encoding */ +#define ASN_E_INVSOCKET -44 /* invalid socket operation */ +#define ASN_E_XMLLIBNFOU -45 /* XML library is not found */ +#define ASN_E_XMLLIBINV -46 /* XML library is invalid */ +#define ASN_E_NOTSUPP -99 /* non-supported ASN construct */ +#define ASN_K_INDEFLEN -9999 /* indefinite length message indicator */ + +/* universal built-in type ID code value constants */ + +#define ASN_ID_EOC 0 /* end of contents */ +#define ASN_ID_BOOL 1 /* boolean */ +#define ASN_ID_INT 2 /* integer */ +#define ASN_ID_BITSTR 3 /* bit string */ +#define ASN_ID_OCTSTR 4 /* byte (octet) string */ +#define ASN_ID_NULL 5 /* null */ +#define ASN_ID_OBJID 6 /* object ID */ +#define ASN_ID_OBJDSC 7 /* object descriptor */ +#define ASN_ID_EXTERN 8 /* external type */ +#define ASN_ID_REAL 9 /* real */ +#define ASN_ID_ENUM 10 /* enumerated value */ +#define ASN_ID_EPDV 11 /* EmbeddedPDV type */ +#define ASN_ID_RELOID 13 /* relative object ID */ +#define ASN_ID_SEQ 16 /* sequence, sequence of */ +#define ASN_ID_SET 17 /* set, set of */ + +#define ASN_SEQ_TAG 0x30 /* SEQUENCE universal tag byte */ +#define ASN_SET_TAG 0x31 /* SET universal tag byte */ + +/* Restricted character string type ID's */ + +#define ASN_ID_NumericString 18 +#define ASN_ID_PrintableString 19 +#define ASN_ID_TeletexString 20 +#define ASN_ID_T61String ASN_ID_TeletexString +#define ASN_ID_VideotexString 21 +#define ASN_ID_IA5String 22 +#define ASN_ID_UTCTime 23 +#define ASN_ID_GeneralTime 24 +#define ASN_ID_GraphicString 25 +#define ASN_ID_VisibleString 26 +#define ASN_ID_GeneralString 27 +#define ASN_ID_UniversalString 28 +#define ASN_ID_BMPString 30 + +/* flag mask values */ + +#define XM_SEEK 0x01 /* seek match until found or end-of-buf */ +#define XM_ADVANCE 0x02 /* advance pointer to contents on match */ +#define XM_DYNAMIC 0x04 /* alloc dyn mem for decoded variable */ +#define XM_SKIP 0x08 /* skip to next field after parsing tag */ + +/* Sizing Constants */ + +#define ASN_K_MAXDEPTH 32 /* maximum nesting depth for messages */ +#define ASN_K_MAXSUBIDS 128 /* maximum sub-id's in an object ID */ +#define ASN_K_MAXENUM 100 /* maximum enum values in an enum type */ +#define ASN_K_MAXERRP 5 /* maximum error parameters */ +#define ASN_K_MAXERRSTK 8 /* maximum levels on error ctxt stack */ +#define ASN_K_ENCBUFSIZ 2*1024 /* dynamic encode buffer extent size */ +#define ASN_K_MEMBUFSEG 1024 /* memory buffer extent size */ + +/* Canonical character set definitions */ + +#define NUM_ABITS 4 +#define NUM_UBITS 4 +#define NUM_CANSET \ +" 0123456789" + +#define PRN_ABITS 8 +#define PRN_UBITS 7 +#define PRN_CANSET \ +" '()+,-./0123456789:=?ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz" + +#define VIS_ABITS 8 +#define VIS_UBITS 7 +#define VIS_CANSET \ +" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]"\ +"^_`abcdefghijklmnopqrstuvwxyz{|}~" + +#define T61_ABITS 8 +#define T61_UBITS 7 +#define T61_CANSET \ +" !\"%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[]"\ +"_abcdefghijklmnopqrstuvwxyz" + +#define IA5_ABITS 8 +#define IA5_UBITS 7 +#define IA5_CANSET \ +"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"\ +"\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"\ +" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]"\ +"^_`abcdefghijklmnopqrstuvwxyz{|}~" + +#define IA5_RANGE1_LOWER 0 +#define IA5_RANGE2_LOWER 0x5f + +#define GEN_ABITS 8 +#define GEN_UBITS 7 +#define GEN_CANSET \ +"\000\001\002\003\004\005\006\007\010\011\012\013\014\015\016\017"\ +"\020\021\022\023\024\025\026\027\030\031\032\033\034\035\036\037"\ +" !\"#$%&'()*+,-./0123456789:;<=>?@ABCDEFGHIJKLMNOPQRSTUVWXYZ[\\]^_"\ +"`abcdefghijklmnopqrstuvwxyz{|}~\177\200\201\202\203\204\205\206\207"\ +"\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237"\ +"\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257"\ +"\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277"\ +"\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317"\ +"\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337"\ +"\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357"\ +"\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377" + +#define BMP_ABITS 16 +#define BMP_UBITS 16 +#define BMP_FIRST 0 +#define BMP_LAST 0xffff + +#define UCS_ABITS 32 +#define UCS_UBITS 32 +#define UCS_FIRST 0 +#define UCS_LAST 0xfffffffful + +/* ASN.1 Primitive Type Definitions */ + +typedef char ASN1CHAR; +typedef unsigned char ASN1OCTET; +typedef ASN1OCTET ASN1BOOL; +typedef signed char ASN1INT8; +typedef unsigned char ASN1UINT8; +typedef int ASN1INT; +typedef unsigned int ASN1UINT; +typedef ASN1INT ASN1ENUM; +typedef double ASN1REAL; + +typedef short ASN1SINT; +typedef unsigned short ASN1USINT; +typedef ASN1UINT ASN1TAG; +#define ASN1TAG_LSHIFT 24 +typedef ASN1USINT ASN116BITCHAR; +typedef ASN1UINT ASN132BITCHAR; +typedef void* ASN1ANY; + +#define ASN1UINT_MAX 4294967295U +#define ASN1INT_MAX ((ASN1INT)2147483647L) +#define ASN1INT_MIN ((ASN1INT)(-ASN1INT_MAX-1)) + +#define ASN1UINTCNT(val) val##u + + +#ifndef ASN1INT64 + +#if defined(_MSC_VER) || defined(__BORLANDC__) || defined(__WATCOMC__) || \ +defined(_WIN32) +#define ASN1INT64 __int64 + +#elif defined(__IBMC__) || defined(__GNUC__) || defined(__SUNPRO_C) || \ +defined(__SUNPRO_CC) || defined(__CC_ARM) || \ +defined(__HPUX_CC__) || defined(__HP_aCC) +#define ASN1INT64 long long + +#else /* !MSC_VER && !__IBMC__ etc */ +#define ASN1INT64 long + +#endif +#endif /* ASN1INT64 */ + +#ifndef FALSE +#define FALSE 0 +#define TRUE 1 +#endif + +typedef struct { /* object identifier */ + ASN1UINT numids; + ASN1UINT subid[ASN_K_MAXSUBIDS]; +} ASN1OBJID; + +typedef struct { /* generic octet string structure */ + ASN1UINT numocts; + ASN1OCTET data[1]; +} ASN1OctStr; + +typedef struct { /* generic octet string structure (dynamic) */ + ASN1UINT numocts; + const ASN1OCTET* data; +} ASN1DynOctStr; + +typedef struct { /* generic bit string structure (dynamic) */ + ASN1UINT numbits; + const ASN1OCTET* data; +} ASN1DynBitStr; + +typedef struct { /* generic sequence of structure */ + ASN1UINT n; + void* elem; +} ASN1SeqOf; + +typedef struct { /* sequence of OCTET STRING */ + ASN1UINT n; + ASN1DynOctStr* elem; +} ASN1SeqOfOctStr; + +typedef struct { /* generic open type data structure */ + ASN1UINT numocts; + const ASN1OCTET* data; +} ASN1OpenType; + +/* ASN.1 useful type definitions */ + +typedef struct { + ASN1UINT nchars; + ASN116BITCHAR* data; +} Asn116BitCharString; + +typedef struct { + ASN1UINT nchars; + ASN132BITCHAR* data; +} Asn132BitCharString; + +typedef const char* ASN1GeneralizedTime; +typedef const char* ASN1GeneralString; +typedef const char* ASN1GraphicString; +typedef const char* ASN1IA5String; +typedef const char* ASN1ISO646String; +typedef const char* ASN1NumericString; +typedef const char* ASN1ObjectDescriptor; +typedef const char* ASN1PrintableString; +typedef const char* ASN1TeletexString; +typedef const char* ASN1T61String; +typedef const char* ASN1UTCTime; +typedef const char* ASN1UTF8String; +typedef const char* ASN1VideotexString; +typedef const char* ASN1VisibleString; + +typedef Asn116BitCharString ASN1BMPString; +typedef Asn132BitCharString ASN1UniversalString; + +/* ASN.1 constrained string structures */ + +typedef struct { + int nchars; + char data[255]; +} Asn1CharArray; + +typedef struct { + Asn1CharArray charSet; + const char* canonicalSet; + int canonicalSetSize; + unsigned canonicalSetBits; + unsigned charSetUnalignedBits; + unsigned charSetAlignedBits; +} Asn1CharSet; + +typedef struct { + Asn116BitCharString charSet; + ASN1USINT firstChar, lastChar; + unsigned unalignedBits; + unsigned alignedBits; +} Asn116BitCharSet; + +/* ASN.1 size constraint structure */ + +typedef struct _Asn1SizeCnst { + ASN1BOOL extended; + ASN1UINT lower; + ASN1UINT upper; + struct _Asn1SizeCnst* next; +} Asn1SizeCnst; + +/* ASN.1 encode/decode buffer info structure */ + +typedef struct { + ASN1OCTET* data; /* pointer to start of data buffer */ + ASN1UINT byteIndex; /* byte index */ + ASN1UINT size; /* current buffer size */ + ASN1SINT bitOffset; /* current bit offset (8 - 1) */ + ASN1BOOL dynamic; /* is buffer dynamic? */ +} ASN1BUFFER; + +/* This structure is used to save the current state of the buffer */ + +typedef struct { + ASN1UINT byteIndex; /* byte index */ + ASN1SINT bitOffset; /* current bit offset (8 - 1) */ + ASN1USINT flags; /* flag bits */ +} ASN1BUFSAVE; + +/* ASN.1 run-time error info structures */ + +typedef struct { + const char* module; + int lineno; +} ASN1ErrLocn; + +typedef struct { + ASN1ErrLocn stack[ASN_K_MAXERRSTK]; + int stkx; + int status; + int parmcnt; + const char* parms[ASN_K_MAXERRP]; +} ASN1ErrInfo; + +#define XM_K_MEMBLKSIZ (4*1024) + +/* Flag mask constant values */ + +#define ASN1DYNCTXT 0x8000 +#define ASN1INDEFLEN 0x4000 +#define ASN1TRACE 0x2000 +#define ASN1LASTEOC 0x1000 +#define ASN1FASTCOPY 0x0800 /* turns on the "fast copy" mode */ +#define ASN1CONSTAG 0x0400 /* form of last parsed tag */ +#define ASN1CANXER 0x0200 /* canonical XER */ +#define ASN1SAVEBUF 0x0100 /* do not free dynamic encode buffer */ +#define ASN1OPENTYPE 0x0080 /* item is an open type field */ + +/* ASN.1 encode/decode context block structure */ + +struct EventHandler; + +typedef struct OOCTXT { /* context block */ + void* pMsgMemHeap; /* internal message memory heap */ + void* pTypeMemHeap; /* memory heap */ + ASN1BUFFER buffer; /* data buffer */ + ASN1ErrInfo errInfo; /* run-time error info */ + Asn1SizeCnst* pSizeConstraint; /* Size constraint list */ + const char* pCharSet; /* String of permitted characters */ + struct EventHandler* pEventHandler; /* event handler object */ + ASN1USINT flags; /* flag bits */ + ASN1OCTET spare[2]; +} OOCTXT; + +/* macros and function prototypes */ + +#ifndef ASN1MAX +#define ASN1MAX(a,b) (((a)>(b))?(a):(b)) +#endif + +#ifndef ASN1MIN +#define ASN1MIN(a,b) (((a)<(b))?(a):(b)) +#endif + +/** + * @defgroup mem Memory Allocation Macros and Functions + * @ingroup cruntime + * + * Memory allocation functions and macros handle memory management for the + * ASN1C run-time. Special algorithms are used for allocation and deallocation + * of memory to improve the run-time performance. @{ + */ +/** + * Allocate a dynamic array. This macro allocates a dynamic array of records of + * the given type. This version of the macro will return the ASN_E_NOMEM error + * status if the memory request cannot be fulfilled. + * + * @param pctxt - Pointer to a context block + * @param pseqof - Pointer to a generated SEQUENCE OF array structure. + * The n member variable must be set to the number + * of records to allocate. + * @param type - Data type of an array record + */ +#define ALLOC_ASN1ARRAY(pctxt,pseqof,type) do {\ +if (sizeof(type)*(pseqof)->n < (pseqof)->n) return ASN_E_NOMEM; \ +if (((pseqof)->elem = (type*) memHeapAlloc \ +(&(pctxt)->pTypeMemHeap, sizeof(type)*(pseqof)->n)) == 0) return ASN_E_NOMEM; \ +} while (0) + +/** + * Allocate and zero an ASN.1 element. This macro allocates and zeros a single + * element of the given type. + * + * @param pctxt - Pointer to a context block + * @param type - Data type of record to allocate + */ +#define ALLOC_ASN1ELEM(pctxt,type) \ +(type*) memHeapAllocZ (&(pctxt)->pTypeMemHeap, sizeof(type)) + +/** + * Allocate memory. This macro allocates the given number of bytes. It is + * similar to the C \c malloc run-time function. + * + * @param pctxt - Pointer to a context block + * @param nbytes - Number of bytes of memory to allocate + * @return - Void pointer to allocated memory or NULL if + * insufficient memory was available to fulfill the + * request. + */ +#define ASN1MALLOC(pctxt,nbytes) \ +memHeapAlloc(&(pctxt)->pTypeMemHeap, nbytes) + +/** + * Free memory associated with a context. This macro frees all memory held + * within a context. This is all memory allocated using the ASN1MALLOC (and + * similar macros) and the mem memory allocation functions using the given + * context variable. + * + * @param pctxt - Pointer to a context block + */ +#define ASN1MEMFREE(pctxt) \ +memHeapFreeAll(&(pctxt)->pTypeMemHeap) + +/** + * Free memory pointer. This macro frees memory at the given pointer. The + * memory must have been allocated using the ASN1MALLOC (or similar) macros or + * the mem memory allocation functions. This macro is similar to the C \c + * free function. + * + * @param pctxt - Pointer to a context block + * @param pmem - Pointer to memory block to free. This must have been + * allocated using the ASN1MALLOC macro or the + * memHeapAlloc function. + */ +#define ASN1MEMFREEPTR(pctxt,pmem) \ +memHeapFreePtr(&(pctxt)->pTypeMemHeap, (void*)pmem) + +/** + * @} + */ +#define ASN1BUFCUR(cp) (cp)->buffer.data[(cp)->buffer.byteIndex] +#define ASN1BUFPTR(cp) &(cp)->buffer.data[(cp)->buffer.byteIndex] + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#elif defined (USEASN1DLL) +#define EXTERN __declspec(dllimport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +#ifndef _NO_MALLOC +#define ASN1CRTMALLOC0(nbytes) malloc(nbytes) +#define ASN1CRTFREE0(ptr) free(ptr) +#else + +#ifdef _NO_THREADS +extern EXTERN OOCTXT g_ctxt; + +#define ASN1CRTMALLOC0(nbytes) memAlloc(&g_ctxt,(nbytes)) +#define ASN1CRTFREE0(ptr) memFreePtr(&g_ctxt,(ptr)) +#else +#define ASN1CRTMALLOC0(nbytes) (void*)0 +#define ASN1CRTFREE0(ptr) (void*)0 + +#endif /* _NO_THREADS */ +#endif /* _NO_MALLOC */ + +#define ASN1CRTMALLOC memHeapAlloc +#define ASN1CRTFREE ASN1MEMFREEPTR + +/* Function prototypes */ + +#define DE_INCRBITIDX(pctxt) \ +((--(pctxt)->buffer.bitOffset < 0) ? \ +((++(pctxt)->buffer.byteIndex >= (pctxt)->buffer.size) ? ASN_E_ENDOFBUF : \ +((pctxt)->buffer.bitOffset = 7, ASN_OK)) : ASN_OK) + + +#define DE_BIT(pctxt,pvalue) \ +((DE_INCRBITIDX (pctxt) != ASN_OK) ? ASN_E_ENDOFBUF : ((pvalue) ? \ +((*(pvalue) = (((pctxt)->buffer.data[(pctxt)->buffer.byteIndex]) & \ +(1 << (pctxt)->buffer.bitOffset)) != 0), ASN_OK) : ASN_OK )) + + +#define encodeIA5String(pctxt,value,permCharSet) \ +encodeConstrainedStringEx (pctxt, value, permCharSet, 8, 7, 7) + +#define encodeGeneralizedTime encodeIA5String + +#define decodeIA5String(pctxt,pvalue,permCharSet) \ +decodeConstrainedStringEx (pctxt, pvalue, permCharSet, 8, 7, 7) + +#define decodeGeneralizedTime decodeIA5String + +/* run-time error and diagnostic functions */ + +/* Context management functions */ + +/** + * @defgroup cmfun Context Management Functions + * @{ + * + * Context initialization functions handle the allocation, initialization, and + * destruction of ASN.1 context variables (variables of type OOCTXT). These + * variables hold all of the working data used during the process of encoding + * or decoding a message. The context provides thread safe operation by + * isolating what would otherwise be global variables within this structure. + * The context variable is passed from function to function as a message is + * encoded or decoded and maintains state information on the encoding or + * decoding process. + */ + +/** + * This function assigns a buffer to a context block. The block should have + * been previously initialized by initContext. + * + * @param pctxt The pointer to the context structure variable to be + * initialized. + * @param bufaddr For encoding, the address of a memory buffer to receive + * and encode a message. For decoding the address of a + * buffer that contains the message data to be decoded. + * This address will be stored within the context + * structure. For encoding it might be zero, the dynamic + * buffer will be used in this case. + * @param bufsiz The size of the memory buffer. For encoding, it might be + * zero; the dynamic buffer will be used in this case. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int initContextBuffer +(OOCTXT* pctxt, const ASN1OCTET* bufaddr, ASN1UINT bufsiz); + +/** + * This function initializes a context block. It makes sure that if the block + * was not previosly initialized, that all key working parameters are set to + * thier correct initial state values (i.e. declared within a function as a + * normal working variable), it is required that they invoke this function + * before using it. + * + * @param pctxt The pointer to the context structure variable to be + * initialized. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int initContext (OOCTXT* pctxt); + +/** + * This function frees all dynamic memory associated with a context. This + * includes all memory inside the block (in particular, the list of memory + * blocks used by the mem functions). + * + * @param pctxt A pointer to a context structure. + */ +EXTERN void freeContext (OOCTXT* pctxt); + +/** + * This function allocates a new OOCTXT block and initializes it. Although + * the block is allocated from the standard heap, it should not be freed using + * free. The freeContext function should be used because this frees items + * allocated within the block before freeing the block itself. + * + * @return Pointer to newly created context + */ +EXTERN OOCTXT* newContext (void); + +EXTERN void copyContext (OOCTXT* pdest, OOCTXT* psrc); +EXTERN int initSubContext (OOCTXT* pctxt, OOCTXT* psrc); +EXTERN void setCtxtFlag (OOCTXT* pctxt, ASN1USINT mask); +EXTERN void clearCtxtFlag (OOCTXT* pctxt, ASN1USINT mask); + +EXTERN int setPERBuffer +(OOCTXT* pctxt, ASN1OCTET* bufaddr, ASN1UINT bufsiz, ASN1BOOL aligned); + +EXTERN int setPERBufferUsingCtxt (OOCTXT* pTarget, OOCTXT* pSource); + +#define ZEROCONTEXT(pctxt) memset(pctxt,0,sizeof(OOCTXT)) +/** + * @} cmfun + */ +/** + * @defgroup errfp Error Formatting and Print Functions + * @{ + * + * Error formatting and print functions allow information about the + * encode/decode errors to be added to a context block structure and then + * printed out when the error is propagated to the top level. + */ + +/** + * This function adds an integer parameter to an error information structure. + * Parameter substitution is done in much the same way as it is done in C + * printf statments. The base error message specification that goes along with + * a particular status code may have variable fields built in using '%' + * modifiers. These would be replaced with actual parameter data. + * + * @param pErrInfo A pointer to a structure containing information on the + * error to be printed. Typically, the error info + * structure referred to is the one inside the OOCTXT + * structure. (i.e. &pctxt->errInfo). + * @param errParm The typed error parameter. + * @return The status of the operation. + */ +EXTERN int errAddIntParm (ASN1ErrInfo* pErrInfo, int errParm); + +/** + * This function adds an string parameter to an error information structure. + * Parameter substitution is done in much the same way as it is done in C + * printf statments. The base error message specification that goes along with + * a particular status code may have variable fields built in using '%' + * modifiers. These would be replaced with actual parameter data. + * + * @param pErrInfo A pointer to a structure containing information on the + * error to be printed. Typically, the error info + * structure referred to is the one inside the OOCTXT + * structure. (i.e. &pctxt->errInfo). + * @param errprm_p The typed error parameter. + * @return The status of the operation. + */ +EXTERN int errAddStrParm (ASN1ErrInfo* pErrInfo, + const char* errprm_p); + +/** + * This function adds an unsigned integer parameter to an error information + * structure. Parameter substitution is done in much the same way as it is done + * in C printf statments. The base error message specification that goes along + * with a particular status code may have variable fields built in using '%' + * modifiers. These would be replaced with actual parameter data. + * + * @param pErrInfo A pointer to a structure containing information on the + * error to be printed. Typically, the error info + * structure referred to is the one inside the OOCTXT + * structure. (i.e. &pctxt->errInfo). + * @param errParm The typed error parameter. + * @return The status of the operation. + */ +EXTERN int errAddUIntParm (ASN1ErrInfo* pErrInfo, unsigned int errParm); + + +EXTERN int errCopyData (ASN1ErrInfo* pSrcErrInfo, + ASN1ErrInfo* pDestErrInfo); + +/** + * This function frees memory associated with the storage of parameters + * associated with an error message. These parameters are maintained on an + * internal linked list maintained within the error information structure. The + * list memory must be freed when error processing is complete. This function + * is called from within errPrint after teh error has been printed out. It is + * also called in teh freeContext function. + * + * @param pErrInfo A pointer to a structure containing information on the + * error to be printed. Typically, the error info + * structure referred to is the one inside the OOCTXT + * structure. (i.e. &pctxt->errInfo). + */ +EXTERN void errFreeParms (ASN1ErrInfo* pErrInfo); + + +EXTERN char* errFmtMsg (ASN1ErrInfo* pErrInfo, char* bufp); + +/** + * This function gets the text of the error + * + * @param pctxt A pointer to a context structure. + */ +EXTERN char* errGetText (OOCTXT* pctxt); + +/** + * This function prints error information to the standard output device. The + * error information is stored in a structure of type ASN1ErrInfo. A structure + * of the this type is part f the OOCTXT structure. This is where error + * information is stored within the ASN1C generated and low-level encode/decode + * functions. + * + * @param pErrInfo A pointer to a structure containing information on the + * error to be printed. Typically, the error info + * structure referred to is the one inside the OOCTXT + * structure. (i.e. &pctxt->errInfo). + */ +EXTERN void errPrint (ASN1ErrInfo* pErrInfo); + +/** + * This function resets the error information in the error information + * sturcture. + * + * @param pErrInfo A pointer to a structure containing information on the + * error to be printed. Typically, the error info + * structure referred to is the one inside the OOCTXT + * structure. (i.e. &pctxt->errInfo). + */ +EXTERN int errReset (ASN1ErrInfo* pErrInfo); + +/** + * This function sets error information in an error information structure. The + * information set includes status code, module name, and line number. Location + * information (i.e. module name and line number) is pushed onto a stack within + * the error information structure to provide a complete stack trace when the + * information is printed out. + * + * @param pErrInfo A pointer to a structure containing information on the + * error to be printed. Typically, the error info + * structure referred to is the one inside the OOCTXT + * structure. (i.e. &pctxt->errInfo). + * @param status The error status code. This is one of the negative error + * status codes. + * @param module The name of the module (C or C++ source file) in which + * the module occurred. This is typically obtained by + * using the _FILE_ macro. + * @param lno The line number at which the error occurred. This is + * typically obtained by using the _LINE_ macro. + * @return The status value passed to the operation in the third + * argument. This makes it possible to set the error + * information and return the status value in one line of + * code. + */ +EXTERN int errSetData (ASN1ErrInfo* pErrInfo, int status, + const char* module, int lno); + +#ifndef _COMPACT +#define LOG_ASN1ERR(ctxt,stat) \ +errSetData(&(ctxt)->errInfo,stat,__FILE__,__LINE__) +#else +#define LOG_ASN1ERR(ctxt,stat) \ +((ctxt)->errInfo.status = stat, stat) +#endif + + + +#define LOG_ASN1ERR_AND_FREE(pctxt,stat,lctxt) \ +freeContext ((lctxt)), LOG_ASN1ERR(pctxt, stat) +/** + * @} + */ + +#define RT_MH_DONTKEEPFREE 0x1 + +#define OSRTMH_PROPID_DEFBLKSIZE 1 +#define OSRTMH_PROPID_SETFLAGS 2 +#define OSRTMH_PROPID_CLEARFLAGS 3 + +#define OSRTMH_PROPID_USER 10 + +/** + * @addtogroup rtmem + * @{ + */ +/** + * Allocate memory. This macro allocates the given number of bytes. It is + * similar to the C \c malloc run-time function. + * + * @param pctxt - Pointer to a context block + * @param nbytes - Number of bytes of memory to allocate + * @return - Void pointer to allocated memory or NULL if insufficient memory + * was available to fulfill the request. + */ +#define memAlloc(pctxt,nbytes) \ +memHeapAlloc(&(pctxt)->pTypeMemHeap,nbytes) + +/** + * Allocate and zero memory. This macro allocates the given number of bytes + * and then initializes the memory block to zero. + * + * @param pctxt - Pointer to a context block + * @param nbytes - Number of bytes of memory to allocate + * @return - Void pointer to allocated memory or NULL if insufficient memory + * was available to fulfill the request. + */ +#define memAllocZ(pctxt,nbytes) \ +memHeapAllocZ(&(pctxt)->pTypeMemHeap,nbytes) + +/** + * Reallocate memory. This macro reallocates a memory block (either + * expands or contracts) to the given number of bytes. It is + * similar to the C \c realloc run-time function. + * + * @param pctxt - Pointer to a context block + * @param mem_p - Pointer to memory block to reallocate. This must have been + * allocated using the memHeapAlloc macro or the memHeapAlloc function. + * @param nbytes - Number of bytes of memory to which the block is to be + * resized. + * @return - Void pointer to allocated memory or NULL if insufficient memory + * was available to fulfill the request. This may be the same as the pmem + * pointer that was passed in if the block did not need to be relocated. + */ +#define memRealloc(pctxt,mem_p,nbytes) \ +memHeapRealloc(&(pctxt)->pTypeMemHeap, (void*)mem_p, nbytes) + +/** + * Free memory pointer. This macro frees memory at the given pointer. + * The memory must have been allocated using the memHeapAlloc (or similar) + * macros or the mem memory allocation macros. This macro is + * similar to the C \c free function. + * + * @param pctxt - Pointer to a context block + * @param mem_p - Pointer to memory block to free. This must have + * been allocated using the memHeapAlloc or memAlloc macro or the + * memHeapAlloc function. + */ +#define memFreePtr(pctxt,mem_p) \ +if (memHeapCheckPtr (&(pctxt)->pTypeMemHeap, (void*)mem_p)) \ +memHeapFreePtr(&(pctxt)->pTypeMemHeap, (void*)mem_p) + +/** + * Free memory associated with a context. This macro frees all memory + * held within a context. This is all memory allocated using the + * memHeapAlloc (and similar macros) and the mem memory allocation + * functions using the given context variable. + * + * @param pctxt - Pointer to a context block + */ +#define memFree(pctxt) \ +memHeapFreeAll(&(pctxt)->pTypeMemHeap) + +/** + * Reset memory associated with a context. This macro resets all memory + * held within a context. This is all memory allocated using the memHeapAlloc + * (and similar macros) and the mem memory allocation functions using the + * given context variable. + * + *

The difference between this and the ASN1MEMFREE macro is that the + * memory blocks held within the context are not actually freed. Internal + * pointers are reset so the existing blocks can be reused. This can + * provide a performace improvement for repetitive tasks such as decoding + * messages in a loop. + * + * @param pctxt - Pointer to a context block + */ +#define memReset(pctxt) \ +memHeapReset(&(pctxt)->pTypeMemHeap) + +/* Alias for __cdecl modifier; if __cdecl keyword is not supported, + * redefine it as empty macro. */ + +#if !defined(OSCDECL) +#if defined(_MSC_VER) || defined(__BORLANDC__) +#define OSCDECL __cdecl +#else +#define OSCDECL +#endif +#endif /* OSCDECL */ + +/* Pointers to C Run-Time memory allocation functions * + * (See memSetAllocFuncs) */ + +typedef void *(OSCDECL *OSMallocFunc ) (size_t size); +typedef void *(OSCDECL *OSReallocFunc) (void *ptr, size_t size); +typedef void (OSCDECL *OSFreeFunc ) (void *ptr); + +EXTERN void memHeapAddRef (void** ppvMemHeap); +EXTERN void* memHeapAlloc (void** ppvMemHeap, int nbytes); +EXTERN void* memHeapAllocZ (void** ppvMemHeap, int nbytes); +EXTERN int memHeapCheckPtr (void** ppvMemHeap, void* mem_p); +EXTERN int memHeapCreate (void** ppvMemHeap); +EXTERN void memHeapFreeAll (void** ppvMemHeap); +EXTERN void memHeapFreePtr (void** ppvMemHeap, void* mem_p); +EXTERN void* memHeapRealloc (void** ppvMemHeap, void* mem_p, int nbytes_); +EXTERN void memHeapRelease (void** ppvMemHeap); +EXTERN void memHeapReset (void** ppvMemHeap); + +EXTERN void* memHeapMarkSaved +(void** ppvMemHeap, const void* mem_p, ASN1BOOL saved); + +EXTERN void memHeapSetProperty +(void** ppvMemHeap, ASN1UINT propId, void* pProp); + + +/** + * This function sets the pointers to standard allocation functions. These + * functions are used to allocate/reallocate/free the memory blocks. By + * default, standard C functions - 'malloc', 'realloc' and 'free' - are used. + * But if some platforms do not support these functions (or some other reasons + * exist) they can be overloaded. The functions being overloaded should have + * the same prototypes as standard ones. + * + * @param malloc_func Pointer to the memory allocation function ('malloc' by + * default). + * @param realloc_func Pointer to the memory reallocation function ('realloc' + * by default). + * @param free_func Pointer to the memory deallocation function ('free' by + * default). + */ +EXTERN void memSetAllocFuncs (OSMallocFunc malloc_func, + OSReallocFunc realloc_func, + OSFreeFunc free_func); + +EXTERN void memFreeOpenSeqExt (OOCTXT* pctxt, DList *pElemList); + +/* + * This function sets flags to a heap. May be used to control the heap's + * behavior. + * + * @param pctxt Pointer to a memory block structure that contains the + * list of dynamic memory block maintained by these + * functions. + * @param flags The flags. + */ +EXTERN void memHeapSetFlags (OOCTXT* pctxt, ASN1UINT flags); + +/* + * This function clears memory heap flags. + * + * @param pctxt Pointer to a memory block structure that contains the + * list of dynamic memory block maintained by these + * functions. + * @param flags The flags + */ +EXTERN void memHeapClearFlags (OOCTXT* pctxt, ASN1UINT flags); + +/** + * This function sets the pointer to standard allocation functions. These + * functions are used to allocate/reallocate/free the memory blocks. By + * default, standard C functions - malloc, realloc, and free - are used. But if + * some platforms do not support these functions or some other reasons exist) + * they can be overloaded. The functions being overloaded should have the same + * prototypes as standard ones. + * + * @param pctxt Pointer to a context block. + * @param blkSize The currently used minimum size and the granularity of + * memory blocks. + */ + +EXTERN void memHeapSetDefBlkSize (OOCTXT* pctxt, ASN1UINT blkSize); + +/** + * This function returns the actual granularity of memory blocks. + * + * @param pctxt Pointer to a context block. + */ +EXTERN ASN1UINT memHeapGetDefBlkSize (OOCTXT* pctxt); + +#ifdef _STATIC_HEAP +EXTERN void memSetStaticBuf (void* memHeapBuf, ASN1UINT blkSize); +#endif + +/* PER encode/decode related items */ + +#define INCRBITIDX(pctxt) \ +((--(pctxt)->buffer.bitOffset < 0) ? \ +((++(pctxt)->buffer.byteIndex >= (pctxt)->buffer.size) ? ASN_E_ENDOFBUF : \ +((pctxt)->buffer.bitOffset = 7, ASN_OK)) : ASN_OK) + +#define DECODEBIT(pctxt,pvalue) \ +((INCRBITIDX (pctxt) != ASN_OK) ? ASN_E_ENDOFBUF : ((pvalue) ? \ +((*(pvalue) = (((pctxt)->buffer.data[(pctxt)->buffer.byteIndex]) & \ +(1 << (pctxt)->buffer.bitOffset)) != 0), ASN_OK) : ASN_OK )) + +/* +#define SETCHARSET(csetvar, canset, abits, ubits) \ +csetvar.charSet.nchars = 0; \ +csetvar.canonicalSet = canset; \ +csetvar.canonicalSetSize = sizeof(canset)-1; \ +csetvar.canonicalSetBits = getUIntBitCount(csetvar.canonicalSetSize); \ +csetvar.charSetUnalignedBits = ubits; \ +csetvar.charSetAlignedBits = abits; +*/ + +/** + * This function will decode a series of multiple bits and place the results in + * an unsigned integer variable. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pvalue A pointer to an unsigned integer variable to receive the + * decoded result. + * @param nbits The number of bits to decode. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeBits +(OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT nbits); + +/** + * This function will decode a value of the ASN.1 bit string type whose maximum + * size is is known in advance. The ASN1C complier generates a call to this + * function to decode bit string productions or elements that contain a size + * constraint. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param numbits_p Pointer to an unsigned integer variable to receive + * decoded number of bits. + * @param buffer Pointer to a fixed-size or pre-allocated array of bufsiz + * octets to receive a decoded bit string. + * @param bufsiz Length (in octets) of the buffer to receive the decoded + * bit string. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeBitString +(OOCTXT* pctxt, ASN1UINT* numbits_p, ASN1OCTET* buffer, + ASN1UINT bufsiz); + +/** + * This function will decode a variable of the ASN.1 BMP character string. This + * differs from the decode routines for the character strings previously + * described in that the BMP string type is based on 16-bit characters. A + * 16-bit character string is modeled using an array of unsigned short + * integers. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pvalue Pointer to character string structure to receive the + * decoded result The structure includes a count field + * containing the number of characters and an array of + * unsigned short integers to hold the 16-bit character + * values. + * @param permCharSet A pointer to the constraining character set. This + * contains an array containing all valid characters in + * the set as well as the aligned and unaligned bit + * counts required to encode the characters. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeBMPString +(OOCTXT* pctxt, ASN1BMPString* pvalue, Asn116BitCharSet* permCharSet); + +/** + * This function will position the decode bit cursor on the next byte boundary. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeByteAlign (OOCTXT* pctxt); + +/** + * This function will decode an integer constrained either by a value or value + * range constraint. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to integer variable to receive decoded value. + * @param lower Lower range value. + * @param upper Upper range value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeConsInteger +(OOCTXT* pctxt, ASN1INT* pvalue, ASN1INT lower, ASN1INT upper); + +/** + * This function will decode an unsigned integer constrained either by a value + * or value range constraint. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to unsigned integer variable to receive decoded + * value. + * @param lower Lower range value. + * @param upper Upper range value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeConsUnsigned +(OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT lower, ASN1UINT upper); + +/** + * This function will decode an 8-bit unsigned integer constrained either by a + * value or value range constraint. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to 8-bit unsigned integer variable to receive + * decoded value. + * @param lower Lower range value. + * @param upper Upper range value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeConsUInt8 (OOCTXT* pctxt, + ASN1UINT8* pvalue, ASN1UINT lower, ASN1UINT upper); + +/** + * This function will decode a 16-bit unsigned integer constrained either by a + * value or value range constraint. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to 16-bit unsigned integer variable to receive + * decoded value. + * @param lower Lower range value. + * @param upper Upper range value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeConsUInt16 +(OOCTXT* pctxt, ASN1USINT* pvalue, ASN1UINT lower, ASN1UINT upper); + +/** + * This function decodes a constrained whole number as specified in Section + * 10.5 of the X.691 standard. + * + * @param pctxt Pointer to context block structure. + * @param padjusted_value Pointer to unsigned adjusted integer value to + * receive decoded result. To get the final value, + * this value is added to the lower boundary of the + * range. + * @param range_value Unsigned integer value specifying the total size + * of the range. This is obtained by subtracting + * the lower range value from the upper range + * value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeConsWholeNumber +(OOCTXT* pctxt, ASN1UINT* padjusted_value, ASN1UINT range_value); + +/** + * This function decodes a constrained string value. This version of the + * function allows all of the required permitted alphabet constraint parameters + * to be passed in as arguments. + * + * @param pctxt Pointer to context block structure. + * @param string Pointer to const char* to receive decoded string. Memory + * will be allocated for this variable using internal + * memory management functions. + * @param charSet String containing permitted alphabet character set. Can + * be null if no character set was specified. + * @param abits Number of bits in a character set character (aligned). + * @param ubits Number of bits in a character set character (unaligned). + * @param canSetBits Number of bits in a character from the canonical set + * representing this string. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeConstrainedStringEx +(OOCTXT* pctxt, const char** string, const char* charSet, + ASN1UINT abits, ASN1UINT ubits, ASN1UINT canSetBits); + +/** + * This function will decode a variable of thr ASN.1 BIT STRING type. This + * function allocates dynamic memory t store the decoded result. The ASN1C + * complier generates a call to this function to decode an unconstrained bit + * string production or element. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pBitStr Pointer to a dynamic bit string structure to receive the + * decoded result. This structure contains a field to + * hold the number of decoded bits and a pointer to an + * octet string to hold the decoded data. Memory is + * allocated by the decoder using the memAlloc + * function. This memory is tracked within the context + * and released when the freeContext function is + * invoked. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeDynBitString (OOCTXT* pctxt, ASN1DynBitStr* pBitStr); + +/** + * This function will decode a value of the ASN.1 octet string type whose + * maximum size is known in advance. The ASN1C complier generates a call to + * this function to decode octet string productions or elements that contain a + * size constraint. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pOctStr A pointer to a dynamic octet string to receive the + * decoded result. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeDynOctetString +(OOCTXT* pctxt, ASN1DynOctStr* pOctStr); + +/** + * This function will decode a length determinant value. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param pvalue A pointer to an unsigned integer variable to receive the + * decoded length value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeLength (OOCTXT* pctxt, ASN1UINT* pvalue); + +/** + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param bitOffset The bit offset inside the message buffer. + */ +EXTERN int moveBitCursor (OOCTXT* pctxt, int bitOffset); + +/** + * This function decodes a value of the ASN.1 object identifier type. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to value to receive decoded result. The + * ASN1OBJID structure contains an integer to hold the + * number of subidentifiers and an array to hold the + * subidentifier values. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeObjectIdentifier (OOCTXT* pctxt, ASN1OBJID* pvalue); + +/** + * This function will decode a value of the ASN.1 octet string type whose + * maximun size is known in advance. The ASN1C compiler generates a call to + * this function to decode octet string productions or elements that contain a + * size constraint. + * + * @param pctxt Pointer to a context structure. This provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param numocts_p A pointer to an unsigned buffer of bufsiz octets to + * receive decoded data. + * @param buffer A pointer to a pre-allocated buffer of size octets to + * receive the decoded data. + * @param bufsiz The size of the buffer to receive the decoded result. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeOctetString +(OOCTXT* pctxt, ASN1UINT* numocts_p, ASN1OCTET* buffer, + ASN1UINT bufsiz); + +/** + * This function will decode an ASN.1 open type. This used to be the ASN.1 ANY + * type, but now is used in a variety of applications requiring an encoding + * that can be interpreted by a decoder without prior knowledge of the type + * of the variable. + * + * @param pctxt Pointer to a context structure. This provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param numocts_p A pointer to an unsigned buffer of bufsiz octets to + * receive decoded data. + * @param object_p2 A pointer to an open type variable to receive the + * decoded data. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeOpenType +(OOCTXT* pctxt, const ASN1OCTET** object_p2, ASN1UINT* numocts_p); + +/** + * This function will decode a small non-negative whole number as specified in + * Section 10.6 of the X.691 standard. This is a number that is expected to be + * small, but whose size is potentially unlimited due to the presence of an + * extension maker. + * + * @param pctxt Pointer to a context structure. This provides a storage + * area for the function to store all workings variables + * that must be maintained between function calls. + * @param pvalue Pointer to an unsigned integer value t receive decoded + * results. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeSmallNonNegWholeNumber +(OOCTXT* pctxt, ASN1UINT* pvalue); + +/** + * This function will decode a semi-constrained integer. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to integer variable to receive decoded value. + * @param lower Lower range value, represented as signed + * integer. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeSemiConsInteger + (OOCTXT* pctxt, ASN1INT* pvalue, ASN1INT lower); + +/** + * This function will decode a semi-constrained unsigned integer. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to unsigned integer variable to receive decoded + * value. + * @param lower Lower range value, represented as unsigned + * integer. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int decodeSemiConsUnsigned + (OOCTXT* pctxt, ASN1UINT* pvalue, ASN1UINT lower); + +/** + * This function will decode an unconstrained integer. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to integer variable to receive decoded value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +#define decodeUnconsInteger(pctxt,pvalue) \ +decodeSemiConsInteger(pctxt, pvalue, ASN1INT_MIN) + +/** + * This function will decode an unconstrained unsigned integer. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to unsigned integer variable to receive decoded + * value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +#define decodeUnconsUnsigned(pctxt,pvalue) \ +decodeSemiConsUnsigned(pctxt, pvalue, 0U) + +EXTERN int decodeVarWidthCharString (OOCTXT* pctxt, const char** pvalue); + +/** + * This function will encode a variable of the ASN.1 BOOLEAN type in + * a single bit. + * + * @param pctxt Pointer to a context structure. This provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param value The BOOLEAN value to be encoded. + */ +EXTERN int encodeBit (OOCTXT* pctxt, ASN1BOOL value); + +/** + * This function encodes multiple bits. + * + * @param pctxt Pointer to context block structure. + * @param value Unsigned integer containing the bits to be encoded. + * @param nbits Number of bits in value to encode. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeBits +(OOCTXT* pctxt, ASN1UINT value, ASN1UINT nbits); + +/** + * This function will encode a value of the ASN.1 bit string type. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param numocts The number of bits n the string to be encoded. + * @param data Pointer to the bit string data to be encoded. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeBitString +(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data); + +/** + * This function will encode a variable of the ASN.1 BMP character string. This + * differs from the encode routines for the character strings previously + * described in that the BMP string type is based on 16-bit characters. A + * 16-bit character string is modeled using an array of unsigned short + * integers. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param value Character string to be encoded. This structure includes + * a count field containing the number of characters to + * encode and an array of unsigned short integers to hold + * the 16-bit characters to be encoded. + * @param permCharSet Pointer to the constraining character set. This contains + * an array containing all valid characters in the set as + * well as the aligned and unaligned bit counts required + * to encode the characters. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeBMPString +(OOCTXT* pctxt, ASN1BMPString value, Asn116BitCharSet* permCharSet); + +/** + * This function will position the encode bit cursor on the next byte boundry. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeByteAlign (OOCTXT* pctxt); + +/** + * This function will determine if the given number of bytes will fit in the + * encode buffer. If not, either the buffer is expanded (if it is a dynamic + * buffer) or an error is signaled. + * + * @param pctxt A pointer to a context structure. This provides a + * storage area for the function to store all working + * variables that must be maintained between function + * calls. + * @param nbytes Number of bytes of space required to hold the variable + * to be encoded. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeCheckBuffer (OOCTXT* pctxt, ASN1UINT nbytes); + +/** + * This function encodes a constrained string value. This version of the + * function allows all of the required permitted alphabet constraint parameters + * to be passed in as arguments. + * + * @param pctxt Pointer to context block structure. + * @param string Pointer to string to be encoded. + * @param charSet String containing permitted alphabet character set. Can + * be null if no character set was specified. + * @param abits Number of bits in a character set character (aligned). + * @param ubits Number of bits in a character set character (unaligned). + * @param canSetBits Number of bits in a character from the canonical set + * representing this string. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeConstrainedStringEx +(OOCTXT* pctxt, const char* string, const char* charSet, + ASN1UINT abits, ASN1UINT ubits, ASN1UINT canSetBits); + +/** + * This function encodes an integer constrained either by a value or value + * range constraint. + * + * @param pctxt Pointer to context block structure. + * @param value Value to be encoded. + * @param lower Lower range value. + * @param upper Upper range value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeConsInteger +(OOCTXT* pctxt, ASN1INT value, ASN1INT lower, ASN1INT upper); + +/** + * This function encodes an unsigned integer constrained either by a value or + * value range constraint. The constrained unsigned integer option is used if: + * + * 1. The lower value of the range is >= 0, and 2. The upper value of the range + * is >= MAXINT + * + * @param pctxt Pointer to context block structure. + * @param value Value to be encoded. + * @param lower Lower range value. + * @param upper Upper range value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeConsUnsigned +(OOCTXT* pctxt, ASN1UINT value, ASN1UINT lower, ASN1UINT upper); + +/** + * This function encodes a constrained whole number as specified in Section + * 10.5 of the X.691 standard. + * + * @param pctxt Pointer to context block structure. + * @param adjusted_value Unsigned adjusted integer value to be encoded. The + * adjustment is done by subtracting the lower value + * of the range from the value to be encoded. + * @param range_value Unsigned integer value specifying the total size of + * the range. This is obtained by subtracting the + * lower range value from the upper range value. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeConsWholeNumber +(OOCTXT* pctxt, ASN1UINT adjusted_value, ASN1UINT range_value); + +/** + * This function will expand the buffer to hold the given number of bytes. + * + * @param pctxt Pointer to a context structure. This provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param nbytes The number of bytes the buffer is to be expanded by. + * Note that the buffer will be expanded by + * ASN_K_ENCBIFXIZ or nbytes (whichever is larger. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeExpandBuffer (OOCTXT* pctxt, ASN1UINT nbytes); + +/** + * This function will return the message pointer and length of an encoded + * message. This function is called after a complier generated encode function + * to get the pointer and length of the message. It is normally used when + * dynamic encoding is specified because the message pointer is not known until + * encoding is complete. If static encoding is used, the message starts at the + * beginning of the specified buffer adn the encodeGetMsgLen function can be + * used to obtain the lenght of the message. + * + * @param pctxt Pointer to a context structure. This provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param pLength Pointer to variable to receive length of the encoded + * message. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN ASN1OCTET* encodeGetMsgPtr (OOCTXT* pctxt, int* pLength); + +/** + * This function will encode a length determinant value. + * + * @param pctxt Pointer to a context structure. This provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param value Length value to be encoded. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeLength (OOCTXT* pctxt, ASN1UINT value); + +/** + * This function encodes a value of the ASN.1 object identifier type. + * + * @param pctxt Pointer to context block structure. + * @param pvalue Pointer to value to be encoded. The ASN1OBJID structure + * contains a numids fields to hold the number of + * subidentifiers and an array to hold the subidentifier + * values. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeObjectIdentifier (OOCTXT* pctxt, ASN1OBJID* pvalue); + + +/** + * + * This function encodes bits from a given octet to the output buffer. + * + * @param pctxt Pointer to ASN.1 PER context structure + * @param value Value of bits to be encoded + * @param nbits Number of bits to be encoded + * + * @return Status of operation + */ +EXTERN int encodebitsFromOctet (OOCTXT* pctxt, ASN1OCTET value, ASN1UINT nbits); + +/** + * This fuction will encode an array of octets. The Octets will be encoded + * unaligned starting at the current bit offset within the encode buffer. + * + * @param pctxt A pointer to a context structure. The provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param pvalue A pointer to an array of octets to encode + * @param nbits The number of Octets to encode + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeOctets +(OOCTXT* pctxt, const ASN1OCTET* pvalue, ASN1UINT nbits); + +/** + * This function will encode a value of the ASN.1 octet string type. + * + * @param pctxt A pointer to a context structure. The provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param numocts Number of octets in the string to be encoded. + * @param data Pointer to octet string data to be encoded. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeOctetString +(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data); + +/** + * This function will encode an ASN.1 open type. This used to be the ANY type, + * but now is used in a variety of applications requiring an encoding that can + * be interpreted by a decoder without a prior knowledge of the type of the + * variable. + * + * @param pctxt A pointer to a context structure. The provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param numocts Number of octets in the string to be encoded. + * @param data Pointer to octet string data to be encoded. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeOpenType +(OOCTXT* pctxt, ASN1UINT numocts, const ASN1OCTET* data); + +/** + * This function will encode an ASN.1 open type extension. An open type + * extension field is the data that potentially resides after the ... marker in + * a version-1 message. The open type structure contains a complete encoded bit + * set including option element bits or choice index, length, and data. + * Typically, this data is populated when a version-1 system decodes a + * version-2 message. The extension fields are retained and can then be + * re-encoded if a new message is to be sent out (for example, in a store and + * forward system). + * + * @param pctxt A pointer to a context structure. The provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param pElemList A pointer to the open type to be encoded. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeOpenTypeExt +(OOCTXT* pctxt, DList* pElemList); + +EXTERN int encodeOpenTypeExtBits +(OOCTXT* pctxt, DList* pElemList); + +/** + * This function will endcode a small, non-negative whole number as specified + * in Section 10.6 of teh X.691 standard. This is a number that is expected to + * be small, but whose size is potentially unlimited due to the presence of an + * extension marker. + * + * @param pctxt A pointer to a context structure. The provides a storage + * area for the function to store all working variables + * that must be maintained between function calls. + * @param value An unsigned integer value to be encoded. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeSmallNonNegWholeNumber (OOCTXT* pctxt, ASN1UINT value); + +/** + * This function encodes a semi-constrained integer. + * + * @param pctxt Pointer to context block structure. + * @param value Value to be encoded. + * @param lower Lower range value, represented as signed + * integer. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeSemiConsInteger + (OOCTXT* pctxt, ASN1INT value, ASN1INT lower); + +/** + * This function encodes an semi-constrained unsigned integer. + * + * @param pctxt Pointer to context block structure. + * @param value Value to be encoded. + * @param lower Lower range value, represented as unsigned + * integer. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +EXTERN int encodeSemiConsUnsigned + (OOCTXT* pctxt, ASN1UINT value, ASN1UINT lower); + +/** + * This function encodes an unconstrained integer. + * + * @param pctxt Pointer to context block structure. + * @param value Value to be encoded. + * @return Completion status of operation: + * - 0 (ASN_OK) = success, + * - negative return value is error. + */ +#define encodeUnconsInteger(pctxt,value) \ +encodeSemiConsInteger(pctxt,value,ASN1INT_MIN) + +EXTERN int encodeVarWidthCharString (OOCTXT* pctxt, const char* value); + +EXTERN int addSizeConstraint (OOCTXT* pctxt, Asn1SizeCnst* pSize); + +EXTERN ASN1BOOL alignCharStr +(OOCTXT* pctxt, ASN1UINT len, ASN1UINT nbits, Asn1SizeCnst* pSize); + +EXTERN int bitAndOctetStringAlignmentTest +(Asn1SizeCnst* pSizeList, ASN1UINT itemCount, + ASN1BOOL bitStrFlag, ASN1BOOL* pAlignFlag); + +EXTERN int getPERMsgLen (OOCTXT* pctxt); + +EXTERN int addSizeConstraint (OOCTXT* pctxt, Asn1SizeCnst* pSize); + +EXTERN Asn1SizeCnst* getSizeConstraint (OOCTXT* pctxt, ASN1BOOL extbit); + +EXTERN int checkSizeConstraint(OOCTXT* pctxt, int size); +EXTERN ASN1UINT getUIntBitCount (ASN1UINT value); + +EXTERN Asn1SizeCnst* checkSize +(Asn1SizeCnst* pSizeList, ASN1UINT value, ASN1BOOL* pExtendable); + +EXTERN void init16BitCharSet +(Asn116BitCharSet* pCharSet, ASN116BITCHAR first, + ASN116BITCHAR last, ASN1UINT abits, ASN1UINT ubits); + +EXTERN ASN1BOOL isExtendableSize (Asn1SizeCnst* pSizeList); + +EXTERN void set16BitCharSet +(OOCTXT* pctxt, Asn116BitCharSet* pCharSet, Asn116BitCharSet* pAlphabet); + +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/oochannels.c b/addons/ooh323c/src/oochannels.c new file mode 100644 index 000000000..8fe8c60cd --- /dev/null +++ b/addons/ooh323c/src/oochannels.c @@ -0,0 +1,1785 @@ +/* + * 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 "ooports.h" +#include "oochannels.h" +#include "ootrace.h" +#include "ooq931.h" +#include "ooh245.h" +#include "ooh323.h" +#include "ooCalls.h" +#include "printHandler.h" +#include "ooGkClient.h" +#include "stdio.h" +#include "ooTimer.h" +#include "ooh323ep.h" +#include "ooStackCmds.h" +#include "ooCmdChannel.h" +#include "ootypes.h" + +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + +extern DList g_TimerList; + +static OOBOOL gMonitor = FALSE; + + +int ooCreateH245Listener(OOH323CallData *call) +{ + int ret=0; + OOSOCKET channelSocket=0; + OOTRACEINFO1("Creating H245 listener\n"); + if((ret=ooSocketCreate (&channelSocket))!=ASN_OK) + { + OOTRACEERR3("ERROR: Failed to create socket for H245 listener " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ret = ooBindPort (OOTCP, channelSocket, call->localIP); + if(ret == OO_FAILED) + { + OOTRACEERR3("Error:Unable to bind to a TCP port - H245 listener creation" + " (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + call->h245listenport = (int*) memAlloc(call->pctxt, sizeof(int)); + *(call->h245listenport) = ret; + call->h245listener = (OOSOCKET*)memAlloc(call->pctxt, sizeof(OOSOCKET)); + *(call->h245listener) = channelSocket; + ret = ooSocketListen(*(call->h245listener), 20); + if(ret != ASN_OK) + { + OOTRACEERR3("Error:Unable to listen on H.245 socket (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + OOTRACEINFO4("H245 listener creation - successful(port %d) (%s, %s)\n", + *(call->h245listenport),call->callType, call->callToken); + return OO_OK; +} + +int ooCreateH245Connection(OOH323CallData *call) +{ + int ret=0; + OOSOCKET channelSocket=0; + ooTimerCallback *cbData=NULL; + + OOTRACEINFO1("Creating H245 Connection\n"); + if((ret=ooSocketCreate (&channelSocket))!=ASN_OK) + { + OOTRACEERR3("ERROR:Failed to create socket for H245 connection " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + else + { + if (0 == call->pH245Channel) { + call->pH245Channel = + (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel)); + } + + /* + bind socket to a port before connecting. Thus avoiding + implicit bind done by a connect call. + */ + ret = ooBindPort(OOTCP, channelSocket, call->localIP); + if(ret == OO_FAILED) + { + OOTRACEERR3("Error:Unable to bind to a TCP port - h245 connection " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + call->pH245Channel->port = ret; + OOTRACEDBGC4("Local H.245 port is %d (%s, %s)\n", + call->pH245Channel->port, + call->callType, call->callToken); + OOTRACEINFO5("Trying to connect to remote endpoint to setup H245 " + "connection %s:%d(%s, %s)\n", call->remoteIP, + call->remoteH245Port, call->callType, call->callToken); + + if((ret=ooSocketConnect(channelSocket, call->remoteIP, + call->remoteH245Port))==ASN_OK) + { + call->pH245Channel->sock = channelSocket; + call->h245SessionState = OO_H245SESSION_ACTIVE; + + OOTRACEINFO3("H245 connection creation succesful (%s, %s)\n", + call->callType, call->callToken); + + /*Start terminal capability exchange and master slave determination */ + ret = ooSendTermCapMsg(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n", + call->callType, call->callToken); + return ret; + } + ret = ooSendMasterSlaveDetermination(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Master-slave determination message " + "(%s, %s)\n", call->callType, call->callToken); + return ret; + } + } + else + { + if(call->h245ConnectionAttempts >= 3) + { + OOTRACEERR3("Error:Failed to setup an H245 connection with remote " + "destination. (%s, %s)\n", call->callType, + call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + else{ + OOTRACEWARN4("Warn:Failed to connect to remote destination for " + "H245 connection - will retry after %d seconds" + "(%s, %s)\n", DEFAULT_H245CONNECTION_RETRYTIMEOUT, + call->callType, call->callToken); + + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer " + "callback.(%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_H245CONNECT_TIMER; + if(!ooTimerCreate(call->pctxt, &call->timerList, + &ooCallH245ConnectionRetryTimerExpired, + DEFAULT_H245CONNECTION_RETRYTIMEOUT, cbData, + FALSE)) + { + OOTRACEERR3("Error:Unable to create H245 connection retry timer" + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + return OO_OK; + } + } + } + return OO_OK; +} + +int ooSendH225Msg(OOH323CallData *call, Q931Message *msg) +{ + int iRet=0; + ASN1OCTET * encodebuf; + if(!call) + return OO_FAILED; + + encodebuf = (ASN1OCTET*) memAlloc (call->pctxt, MAXMSGLEN); + if(!encodebuf) + { + OOTRACEERR3("Error:Failed to allocate memory for encoding H225 " + "message(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + iRet = ooEncodeH225Message(call, msg, encodebuf, MAXMSGLEN); + if(iRet != OO_OK) + { + OOTRACEERR3("Error:Failed to encode H225 message. (%s, %s)\n", + call->callType, call->callToken); + memFreePtr (call->pctxt, encodebuf); + return OO_FAILED; + } + + /* If high priority messages, send immediately.*/ + if(encodebuf[0] == OOReleaseComplete || + (encodebuf[0]==OOFacility && encodebuf[1]==OOEndSessionCommand)) + { + dListFreeAll(call->pctxt, &call->pH225Channel->outQueue); + dListAppend (call->pctxt, &call->pH225Channel->outQueue, encodebuf); + // ooSendMsg(call, OOQ931MSG); + } + else{ + dListAppend (call->pctxt, &call->pH225Channel->outQueue, encodebuf); + + OOTRACEDBGC4("Queued H225 messages %d. (%s, %s)\n", + call->pH225Channel->outQueue.count, + call->callType, call->callToken); + } + return OO_OK; +} + +int ooCreateH225Connection(OOH323CallData *call) +{ + int ret=0; + OOSOCKET channelSocket=0; + if((ret=ooSocketCreate (&channelSocket))!=ASN_OK) + { + OOTRACEERR3("Failed to create socket for transmit H2250 channel (%s, %s)" + "\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + } + return OO_FAILED; + } + else + { + /* + bind socket to a port before connecting. Thus avoiding + implicit bind done by a connect call. Avoided on windows as + windows sockets have problem in reusing the addresses even after + setting SO_REUSEADDR, hence in windows we just allow os to bind + to any random port. + */ +#ifndef _WIN32 + ret = ooBindPort(OOTCP,channelSocket, call->localIP); +#else + ret = ooBindOSAllocatedPort(channelSocket, call->localIP); +#endif + + if(ret == OO_FAILED) + { + OOTRACEERR3("Error:Unable to bind to a TCP port (%s, %s)\n", + call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + } + return OO_FAILED; + } + + if (0 == call->pH225Channel) { + call->pH225Channel = + (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel)); + } + call->pH225Channel->port = ret; + + OOTRACEINFO5("Trying to connect to remote endpoint(%s:%d) to setup " + "H2250 channel (%s, %s)\n", call->remoteIP, + call->remotePort, call->callType, call->callToken); + + if((ret=ooSocketConnect(channelSocket, call->remoteIP, + call->remotePort))==ASN_OK) + { + call->pH225Channel->sock = channelSocket; + + OOTRACEINFO3("H2250 transmiter channel creation - succesful " + "(%s, %s)\n", call->callType, call->callToken); + + /* If multihomed, get ip from socket */ + if(!strcmp(call->localIP, "0.0.0.0")) + { + OOTRACEDBGA3("Determining IP address for outgoing call in " + "multihomed mode. (%s, %s)\n", call->callType, + call->callToken); + ret = ooSocketGetIpAndPort(channelSocket, call->localIP, 20, + &call->pH225Channel->port); + if(ret != ASN_OK) + { + OOTRACEERR3("ERROR:Failed to retrieve local ip and port from " + "socket for multihomed mode.(%s, %s)\n", + call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { /* transport failure */ + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + } + return OO_FAILED; + } + OOTRACEDBGA4("Using local ip %s for outgoing call(multihomedMode)." + " (%s, %s)\n", call->localIP, call->callType, + call->callToken); + } + return OO_OK; + } + else + { + OOTRACEERR3("ERROR:Failed to connect to remote destination for " + "transmit H2250 channel(%s, %s)\n",call->callType, + call->callToken); + if(call->callState < OO_CALL_CLEAR) + { /* No one is listening at remote end */ + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_NOUSER; + } + return OO_FAILED; + } + + return OO_FAILED; + } +} + +int ooCloseH225Connection (OOH323CallData *call) +{ + if (0 != call->pH225Channel) + { + if(call->pH225Channel->sock != 0) + ooSocketClose (call->pH225Channel->sock); + if (call->pH225Channel->outQueue.count > 0) + { + dListFreeAll (call->pctxt, &(call->pH225Channel->outQueue)); + } + memFreePtr (call->pctxt, call->pH225Channel); + call->pH225Channel = NULL; + } + return OO_OK; +} + +int ooCreateH323Listener() +{ + int ret=0; + OOSOCKET channelSocket=0; + OOIPADDR ipaddrs; + + /* Create socket */ + if((ret=ooSocketCreate (&channelSocket))!=ASN_OK) + { + OOTRACEERR1("Failed to create socket for H323 Listener\n"); + return OO_FAILED; + } + ret= ooSocketStrToAddr (gH323ep.signallingIP, &ipaddrs); + if((ret=ooSocketBind (channelSocket, ipaddrs, + gH323ep.listenPort))==ASN_OK) + { + gH323ep.listener = (OOSOCKET*)memAlloc(&gH323ep.ctxt,sizeof(OOSOCKET)); + *(gH323ep.listener) = channelSocket; + + ooSocketListen(channelSocket,20); /*listen on socket*/ + OOTRACEINFO1("H323 listener creation - successful\n"); + return OO_OK; + } + else + { + OOTRACEERR1("ERROR:Failed to create H323 listener\n"); + return OO_FAILED; + } +} + + + +int ooAcceptH225Connection() +{ + OOH323CallData * call; + int ret; + char callToken[20]; + OOSOCKET h225Channel=0; + ret = ooSocketAccept (*(gH323ep.listener), &h225Channel, + NULL, NULL); + if(ret != ASN_OK) + { + OOTRACEERR1("Error:Accepting h225 connection\n"); + return OO_FAILED; + } + ooGenerateCallToken(callToken, sizeof(callToken)); + + call = ooCreateCall("incoming", callToken); + if(!call) + { + OOTRACEERR1("ERROR:Failed to create an incoming call\n"); + return OO_FAILED; + } + + call->pH225Channel = (OOH323Channel*) + memAllocZ (call->pctxt, sizeof(OOH323Channel)); + + call->pH225Channel->sock = h225Channel; + + /* If multihomed, get ip from socket */ + if(!strcmp(call->localIP, "0.0.0.0")) + { + OOTRACEDBGA3("Determining IP address for incoming call in multihomed " + "mode (%s, %s)\n", call->callType, call->callToken); + + ret = ooSocketGetIpAndPort(h225Channel, call->localIP, 20, + &call->pH225Channel->port); + if(ret != ASN_OK) + { + OOTRACEERR3("Error:Failed to retrieve local ip and port from " + "socket for multihomed mode.(%s, %s)\n", + call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { /* transport failure */ + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + } + return OO_FAILED; + } + OOTRACEDBGA4("Using Local IP address %s for incoming call in multihomed " + "mode. (%s, %s)\n", call->localIP, call->callType, + call->callToken); + } + + return OO_OK; +} + +int ooAcceptH245Connection(OOH323CallData *call) +{ + int ret; + OOSOCKET h245Channel=0; + ret = ooSocketAccept (*(call->h245listener), &h245Channel, + NULL, NULL); + if(ret != ASN_OK) + { + OOTRACEERR1("Error:Accepting h245 connection\n"); + return OO_FAILED; + } + + if (0 == call->pH245Channel) { + call->pH245Channel = + (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel)); + } + call->pH245Channel->sock = h245Channel; + call->h245SessionState = OO_H245SESSION_ACTIVE; + + + OOTRACEINFO3("H.245 connection established (%s, %s)\n", + call->callType, call->callToken); + + + /* Start terminal capability exchange and master slave determination */ + ret = ooSendTermCapMsg(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n", + call->callType, call->callToken); + return ret; + } + ret = ooSendMasterSlaveDetermination(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Master-slave determination message " + "(%s, %s)\n", call->callType, call->callToken); + return ret; + } + return OO_OK; +} + + +int ooSetFDSETs(fd_set *pReadfds, fd_set *pWritefds, int *nfds) +{ + OOH323CallData *call=NULL; + + if(gH323ep.gkClient && gH323ep.gkClient->rasSocket != 0) + { + FD_SET(gH323ep.gkClient->rasSocket, pReadfds ); + if ( *nfds < (int)gH323ep.gkClient->rasSocket) + *nfds = (int)gH323ep.gkClient->rasSocket; + } + if(gH323ep.listener) + { + FD_SET(*(gH323ep.listener), pReadfds); + if(*nfds < (int)*(gH323ep.listener)) + *nfds = *((int*)gH323ep.listener); + } + + if(gH323ep.cmdSock) + { + FD_SET(gH323ep.cmdSock, pReadfds); + if(*nfds < (int)gH323ep.cmdSock) + *nfds = (int)gH323ep.cmdSock; + } + + + + if(gH323ep.callList) + { + call = gH323ep.callList; + while(call) + { + if (0 != call->pH225Channel && 0 != call->pH225Channel->sock) + { + FD_SET (call->pH225Channel->sock, pReadfds); + if (call->pH225Channel->outQueue.count > 0 || + (OO_TESTFLAG (call->flags, OO_M_TUNNELING) && + 0 != call->pH245Channel && + call->pH245Channel->outQueue.count>0)) + FD_SET (call->pH225Channel->sock, pWritefds); + if(*nfds < (int)call->pH225Channel->sock) + *nfds = call->pH225Channel->sock; + } + + if (0 != call->pH245Channel && call->pH245Channel->sock != 0) + { + FD_SET(call->pH245Channel->sock, pReadfds); + if (call->pH245Channel->outQueue.count>0) + FD_SET(call->pH245Channel->sock, pWritefds); + if(*nfds < (int)call->pH245Channel->sock) + *nfds = call->pH245Channel->sock; + } + else if(call->h245listener) + { + OOTRACEINFO3("H.245 Listerner socket being monitored " + "(%s, %s)\n", call->callType, call->callToken); + FD_SET(*(call->h245listener), pReadfds); + if(*nfds < (int)*(call->h245listener)) + *nfds = *(call->h245listener); + } + call = call->next; + + }/* while(call) */ + }/*if(gH323ep.callList) */ + + + if(*nfds != 0) *nfds = *nfds+1; + + return OO_OK; + +} + +int ooProcessFDSETsAndTimers + (fd_set *pReadfds, fd_set *pWritefds, struct timeval *pToMin) +{ + OOH323CallData *call, *prev=NULL; + struct timeval toNext; + + /* Process gatekeeper client timers */ + if(gH323ep.gkClient) + { + ooTimerFireExpired(&gH323ep.gkClient->ctxt, + &gH323ep.gkClient->timerList); + if(ooTimerNextTimeout(&gH323ep.gkClient->timerList, &toNext)) + { + if(ooCompareTimeouts(pToMin, &toNext)>0) + { + pToMin->tv_sec = toNext.tv_sec; + pToMin->tv_usec = toNext.tv_usec; + } + } + if(gH323ep.gkClient->state == GkClientFailed || + gH323ep.gkClient->state == GkClientGkErr) + { + if(ooGkClientHandleClientOrGkFailure(gH323ep.gkClient)!=OO_OK) + { + //ooStopMonitorCalls(); //Function calling ooProcessFDSETsAndTimers is responsible for this. + return OO_FAILED; + } + } + } + + if(gH323ep.cmdSock) { + if(FD_ISSET(gH323ep.cmdSock, pReadfds)) { + if(ooReadAndProcessStackCommand() != OO_OK) { + /* ooReadAndProcessStackCommand prints an error message */ + return OO_FAILED; + } + } + } + + /* Manage ready descriptors after select */ + + if(0 != gH323ep.gkClient && 0 != gH323ep.gkClient->rasSocket) + { + if(FD_ISSET( gH323ep.gkClient->rasSocket, pReadfds) ) + { + ooGkClientReceive(gH323ep.gkClient); + if(gH323ep.gkClient->state == GkClientFailed || + gH323ep.gkClient->state == GkClientGkErr) { + ooGkClientHandleClientOrGkFailure(gH323ep.gkClient); + } + } + } + + if(gH323ep.listener) + { + if(FD_ISSET(*(gH323ep.listener), pReadfds)) + { + OOTRACEDBGA1("New connection at H225 receiver\n"); + ooAcceptH225Connection(); + } + } + + + if(gH323ep.callList) + { + call = gH323ep.callList; + while(call) + { + ooTimerFireExpired(call->pctxt, &call->timerList); + if (0 != call->pH225Channel && 0 != call->pH225Channel->sock) + { + if(FD_ISSET(call->pH225Channel->sock, pReadfds)) + { + if(ooH2250Receive(call) != OO_OK) + { + OOTRACEERR3("ERROR:Failed ooH2250Receive - Clearing call " + "(%s, %s)\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + } + } + } + + + if (0 != call->pH245Channel && 0 != call->pH245Channel->sock) + { + if(FD_ISSET(call->pH245Channel->sock, pReadfds)) + { + ooH245Receive(call); + } + } + + if (0 != call->pH245Channel && 0 != call->pH245Channel->sock) + { + if(FD_ISSET(call->pH245Channel->sock, pWritefds)) + { + if(call->pH245Channel->outQueue.count>0) + ooSendMsg(call, OOH245MSG); + } + } + else if(call->h245listener) + { + if(FD_ISSET(*(call->h245listener), pReadfds)) + { + OOTRACEDBGC3("Incoming H.245 connection (%s, %s)\n", + call->callType, call->callToken); + ooAcceptH245Connection(call); + } + } + + if (0 != call->pH225Channel && 0 != call->pH225Channel->sock) + { + if(FD_ISSET(call->pH225Channel->sock, pWritefds)) + { + if(call->pH225Channel->outQueue.count>0) + { + OOTRACEDBGC3("Sending H225 message (%s, %s)\n", + call->callType, call->callToken); + ooSendMsg(call, OOQ931MSG); + } + if(call->pH245Channel && + call->pH245Channel->outQueue.count>0 && + OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + OOTRACEDBGC3("H245 message needs to be tunneled. " + "(%s, %s)\n", call->callType, + call->callToken); + ooSendMsg(call, OOH245MSG); + } + } + } + + if(ooTimerNextTimeout(&call->timerList, &toNext)) + { + if(ooCompareTimeouts(pToMin, &toNext) > 0) + { + pToMin->tv_sec = toNext.tv_sec; + pToMin->tv_usec = toNext.tv_usec; + } + } + prev = call; + call = call->next; + if(prev->callState >= OO_CALL_CLEAR) + ooEndCall(prev); + }/* while(call) */ + }/* if(gH323ep.callList) */ + + return OO_OK; + +} + +int ooMonitorChannels() +{ + int ret=0, nfds=0; + struct timeval toMin, toNext; + fd_set readfds, writefds; + + gMonitor = TRUE; + + toMin.tv_sec = 3; + toMin.tv_usec = 0; + ooH323EpPrintConfig(); + + if(gH323ep.gkClient) { + ooGkClientPrintConfig(gH323ep.gkClient); + if(OO_OK != ooGkClientStart(gH323ep.gkClient)) + { + OOTRACEERR1("Error:Failed to start Gatekeeper client\n"); + ooGkClientDestroy(); + } + } + + while(1) + { + FD_ZERO(&readfds); + FD_ZERO(&writefds); + nfds = 0; + ooSetFDSETs(&readfds, &writefds, &nfds); + + if(!gMonitor) { + OOTRACEINFO1("Ending Monitor thread\n"); + break; + } + + + if(nfds == 0) +#ifdef _WIN32 + Sleep(10); +#else + { + toMin.tv_sec = 0; + toMin.tv_usec = 10000; + ooSocketSelect(1, 0, 0, 0, &toMin); + } +#endif + else + ret = ooSocketSelect(nfds, &readfds, &writefds, + NULL, &toMin); + + if(ret == -1) + { + + OOTRACEERR1("Error in select ...exiting\n"); + exit(-1); + } + + toMin.tv_sec = 0; + toMin.tv_usec = 100000; /* 100ms*/ + /*This is for test application. Not part of actual stack */ + + ooTimerFireExpired(&gH323ep.ctxt, &g_TimerList); + if(ooTimerNextTimeout(&g_TimerList, &toNext)) + { + if(ooCompareTimeouts(&toMin, &toNext)>0) + { + toMin.tv_sec = toNext.tv_sec; + toMin.tv_usec = toNext.tv_usec; + } + } + + if(ooProcessFDSETsAndTimers(&readfds, &writefds, &toMin) != OO_OK) + { + ooStopMonitorCalls(); + continue; + } + + }/* while(1)*/ + return OO_OK; +} + +int ooH2250Receive(OOH323CallData *call) +{ + int recvLen=0, total=0, ret=0; + ASN1OCTET message[MAXMSGLEN], message1[MAXMSGLEN]; + int len; + Q931Message *pmsg; + OOCTXT *pctxt = &gH323ep.msgctxt; + struct timeval timeout; + fd_set readfds; + + + pmsg = (Q931Message*)memAlloc(pctxt, sizeof(Q931Message)); + if(!pmsg) + { + OOTRACEERR3("ERROR:Failed to allocate memory for incoming H.2250 message" + " (%s, %s)\n", call->callType, call->callToken); + memReset(&gH323ep.msgctxt); + return OO_FAILED; + } + memset(pmsg, 0, sizeof(Q931Message)); + /* First read just TPKT header which is four bytes */ + recvLen = ooSocketRecv (call->pH225Channel->sock, message, 4); + if(recvLen <= 0) + { + if(recvLen == 0) + OOTRACEWARN3("Warn:RemoteEndpoint closed connection (%s, %s)\n", + call->callType, call->callToken); + else + OOTRACEERR3("Error:Transport failure while reading Q931 " + "message (%s, %s)\n", call->callType, call->callToken); + + ooCloseH225Connection(call); + if(call->callState < OO_CALL_CLEARED) + { + if(call->callState < OO_CALL_CLEAR) + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEARED; + + } + ooFreeQ931Message(pmsg); + return OO_OK; + } + OOTRACEDBGC3("Receiving H.2250 message (%s, %s)\n", + call->callType, call->callToken); + /* Since we are working with TCP, need to determine the + message boundary. Has to be done at channel level, as channels + know the message formats and can determine boundaries + */ + if(recvLen != 4) + { + OOTRACEERR4("Error: Reading TPKT header for H225 message " + "recvLen= %d (%s, %s)\n", recvLen, call->callType, + call->callToken); + ooFreeQ931Message(pmsg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + + + len = message[2]; + len = len<<8; + len = len | message[3]; + /* Remaining message length is length - tpkt length */ + len = len - 4; + + /* Now read actual Q931 message body. We should make sure that we + receive complete message as indicated by len. If we don't then there + is something wrong. The loop below receives message, then checks whether + complete message is received. If not received, then uses select to peek + for remaining bytes of the message. If message is not received in 3 + seconds, then we have a problem. Report an error and exit. + */ + while(total < len) + { + recvLen = ooSocketRecv (call->pH225Channel->sock, message1, len-total); + memcpy(message+total, message1, recvLen); + total = total + recvLen; + + if(total == len) break; /* Complete message is received */ + + FD_ZERO(&readfds); + FD_SET(call->pH225Channel->sock, &readfds); + timeout.tv_sec = 3; + timeout.tv_usec = 0; + ret = ooSocketSelect(call->pH225Channel->sock+1, &readfds, NULL, + NULL, &timeout); + if(ret == -1) + { + OOTRACEERR3("Error in select while receiving H.2250 message - " + "clearing call (%s, %s)\n", call->callType, + call->callToken); + ooFreeQ931Message(pmsg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + /* If remaining part of the message is not received in 3 seconds + exit */ + if(!FD_ISSET(call->pH225Channel->sock, &readfds)) + { + OOTRACEERR3("Error: Incomplete H.2250 message received - clearing " + "call (%s, %s)\n", call->callType, call->callToken); + ooFreeQ931Message(pmsg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + } + + OOTRACEDBGC3("Received Q.931 message: (%s, %s)\n", + call->callType, call->callToken); + + initializePrintHandler(&printHandler, "Received H.2250 Message"); + setEventHandler (pctxt, &printHandler); + ret = ooQ931Decode (call, pmsg, len, message); + if(ret != OO_OK) { + OOTRACEERR3("Error:Failed to decode received H.2250 message. (%s, %s)\n", + call->callType, call->callToken); + } + OOTRACEDBGC3("Decoded Q931 message (%s, %s)\n", call->callType, + call->callToken); + finishPrint(); + removeEventHandler(pctxt); + if(ret == OO_OK) { + ooHandleH2250Message(call, pmsg); + } + return ret; +} + + + +int ooH245Receive(OOH323CallData *call) +{ + int recvLen, ret, len, total=0; + ASN1OCTET message[MAXMSGLEN], message1[MAXMSGLEN]; + ASN1BOOL aligned = TRUE; + H245Message *pmsg; + OOCTXT *pctxt = &gH323ep.msgctxt; + struct timeval timeout; + fd_set readfds; + + pmsg = (H245Message*)memAlloc(pctxt, sizeof(H245Message)); + + /* First read just TPKT header which is four bytes */ + recvLen = ooSocketRecv (call->pH245Channel->sock, message, 4); + /* Since we are working with TCP, need to determine the + message boundary. Has to be done at channel level, as channels + know the message formats and can determine boundaries + */ + if(recvLen<=0 && call->h245SessionState != OO_H245SESSION_PAUSED) + { + if(recvLen == 0) + OOTRACEINFO3("Closing H.245 channels as remote end point closed H.245" + " connection (%s, %s)\n", call->callType, call->callToken); + else + OOTRACEERR3("Error: Transport failure while trying to receive H245" + " message (%s, %s)\n", call->callType, call->callToken); + + ooCloseH245Connection(call); + ooFreeH245Message(call, pmsg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + if(call->h245SessionState == OO_H245SESSION_PAUSED) + { + ooLogicalChannel *temp; + + OOTRACEINFO3("Call Paused, closing logical channels" + " (%s, %s)\n", call->callType, call->callToken); + + temp = call->logicalChans; + while(temp) + { + if(temp->state == OO_LOGICALCHAN_ESTABLISHED) + { + /* Sending closelogicalchannel only for outgoing channels*/ + if(!strcmp(temp->dir, "transmit")) + { + ooSendCloseLogicalChannel(call, temp); + } + } + temp = temp->next; + } + call->masterSlaveState = OO_MasterSlave_Idle; + call->callState = OO_CALL_PAUSED; + call->localTermCapState = OO_LocalTermCapExchange_Idle; + call->remoteTermCapState = OO_RemoteTermCapExchange_Idle; + call->h245SessionState = OO_H245SESSION_IDLE; + call->logicalChans = NULL; + } + OOTRACEDBGC1("Receiving H245 message\n"); + if(recvLen != 4) + { + OOTRACEERR3("Error: Reading TPKT header for H245 message (%s, %s)\n", + call->callType, call->callToken); + ooFreeH245Message(call, pmsg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + + len = message[2]; + len = len<<8; + len = (len | message[3]); + /* Remaining message length is length - tpkt length */ + len = len - 4; + /* Now read actual H245 message body. We should make sure that we + receive complete message as indicated by len. If we don't then there + is something wrong. The loop below receives message, then checks whether + complete message is received. If not received, then uses select to peek + for remaining bytes of the message. If message is not received in 3 + seconds, then we have a problem. Report an error and exit. + */ + while(total < len) + { + recvLen = ooSocketRecv (call->pH245Channel->sock, message1, len-total); + memcpy(message+total, message1, recvLen); + total = total + recvLen; + if(total == len) break; /* Complete message is received */ + FD_ZERO(&readfds); + FD_SET(call->pH245Channel->sock, &readfds); + timeout.tv_sec = 3; + timeout.tv_usec = 0; + ret = ooSocketSelect(call->pH245Channel->sock+1, &readfds, NULL, + NULL, &timeout); + if(ret == -1) + { + OOTRACEERR3("Error in select...H245 Receive-Clearing call (%s, %s)\n", + call->callType, call->callToken); + ooFreeH245Message(call, pmsg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + /* If remaining part of the message is not received in 3 seconds + exit */ + if(!FD_ISSET(call->pH245Channel->sock, &readfds)) + { + OOTRACEERR3("Error: Incomplete h245 message received (%s, %s)\n", + call->callType, call->callToken); + ooFreeH245Message(call, pmsg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + } + + OOTRACEDBGC3("Complete H245 message received (%s, %s)\n", + call->callType, call->callToken); + setPERBuffer(pctxt, message, recvLen, aligned); + initializePrintHandler(&printHandler, "Received H.245 Message"); + + /* Set event handler */ + setEventHandler (pctxt, &printHandler); + + ret = asn1PD_H245MultimediaSystemControlMessage(pctxt, &(pmsg->h245Msg)); + if(ret != ASN_OK) + { + OOTRACEERR3("Error decoding H245 message (%s, %s)\n", + call->callType, call->callToken); + ooFreeH245Message(call, pmsg); + return OO_FAILED; + } + finishPrint(); + removeEventHandler(pctxt); + ooHandleH245Message(call, pmsg); + return OO_OK; +} + +/* Generic Send Message functionality. Based on type of message to be sent, + it calls the corresponding function to retrieve the message buffer and + then transmits on the associated channel + Interpreting msgptr: + Q931 messages except facility + 1st octet - msgType, next 4 octets - tpkt header, + followed by encoded msg + Q931 message facility + 1st octect - OOFacility, 2nd octet - tunneled msg + type(in case no tunneled msg - OOFacility), + 3rd and 4th octet - associated logical channel + of the tunneled msg(0 when no channel is + associated. ex. in case of MSD, TCS), next + 4 octets - tpkt header, followed by encoded + message. + + H.245 messages no tunneling + 1st octet - msg type, next two octets - logical + channel number(0, when no channel is associated), + next two octets - total length of the message + (including tpkt header) + + H.245 messages - tunneling. + 1st octet - msg type, next two octets - logical + channel number(0, when no channel is associated), + next two octets - total length of the message. + Note, no tpkt header is present in this case. + +*/ +int ooSendMsg(OOH323CallData *call, int type) +{ + + int len=0, ret=0, msgType=0, tunneledMsgType=0, logicalChannelNo = 0; + DListNode * p_msgNode=NULL; + ASN1OCTET *msgptr, *msgToSend=NULL; + + + + if(call->callState == OO_CALL_CLEARED) + { + OOTRACEDBGA3("Warning:Call marked for cleanup. Can not send message." + "(%s, %s)\n", call->callType, call->callToken); + return OO_OK; + } + + if(type == OOQ931MSG) + { + if(call->pH225Channel->outQueue.count == 0) + { + OOTRACEWARN3("WARN:No H.2250 message to send. (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + OOTRACEDBGA3("Sending Q931 message (%s, %s)\n", call->callType, + call->callToken); + p_msgNode = call->pH225Channel->outQueue.head; + msgptr = (ASN1OCTET*) p_msgNode->data; + msgType = msgptr[0]; + + if(msgType == OOFacility) + { + tunneledMsgType = msgptr[1]; + logicalChannelNo = msgptr[2]; + logicalChannelNo = logicalChannelNo << 8; + logicalChannelNo = (logicalChannelNo | msgptr[3]); + len = msgptr[6]; + len = len<<8; + len = (len | msgptr[7]); + msgToSend = msgptr+4; + } + else { + len = msgptr[3]; + len = len<<8; + len = (len | msgptr[4]); + msgToSend = msgptr+1; + } + + /* Remove the message from rtdlist pH225Channel->outQueue */ + dListRemove(&(call->pH225Channel->outQueue), p_msgNode); + if(p_msgNode) + memFreePtr(call->pctxt, p_msgNode); + + /*TODO: This is not required ideally. We will see for some time and if + we don't face any problems we will delete this code */ +#if 0 + /* Check whether connection with remote is alright */ + if(!ooChannelsIsConnectionOK(call, call->pH225Channel->sock)) + { + OOTRACEERR3("Error:Transport failure for signalling channel. " + "Abandoning message send and marking call for cleanup.(%s" + "'%s)\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEARED; + return OO_OK; + } +#endif + /* Send message out via TCP */ + ret = ooSocketSend(call->pH225Channel->sock, msgToSend, len); + if(ret == ASN_OK) + { + memFreePtr (call->pctxt, msgptr); + OOTRACEDBGC3("H2250/Q931 Message sent successfully (%s, %s)\n", + call->callType, call->callToken); + ooOnSendMsg(call, msgType, tunneledMsgType, logicalChannelNo); + return OO_OK; + } + else{ + OOTRACEERR3("H2250Q931 Message send failed (%s, %s)\n", + call->callType, call->callToken); + memFreePtr (call->pctxt, msgptr); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + }/* end of type==OOQ931MSG */ + if(type == OOH245MSG) + { + if(call->pH245Channel->outQueue.count == 0) + { + OOTRACEWARN3("WARN:No H.245 message to send. (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + OOTRACEDBGA3("Sending H245 message (%s, %s)\n", call->callType, + call->callToken); + p_msgNode = call->pH245Channel->outQueue.head; + msgptr = (ASN1OCTET*) p_msgNode->data; + msgType = msgptr[0]; + + logicalChannelNo = msgptr[1]; + logicalChannelNo = logicalChannelNo << 8; + logicalChannelNo = (logicalChannelNo | msgptr[2]); + + len = msgptr[3]; + len = len<<8; + len = (len | msgptr[4]); + /* Remove the message from queue */ + dListRemove(&(call->pH245Channel->outQueue), p_msgNode); + if(p_msgNode) + memFreePtr(call->pctxt, p_msgNode); + + /* Send message out */ + if (0 == call->pH245Channel && !OO_TESTFLAG(call->flags, OO_M_TUNNELING)) + { + OOTRACEWARN3("Neither H.245 channel nor tunneling active " + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr (call->pctxt, msgptr); + /*ooCloseH245Session(call);*/ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_OK; + } + + if (0 != call->pH245Channel && 0 != call->pH245Channel->sock) + { + OOTRACEDBGC4("Sending %s H245 message over H.245 channel. " + "(%s, %s)\n", ooGetMsgTypeText(msgType), + call->callType, call->callToken); + + ret = ooSocketSend(call->pH245Channel->sock, msgptr+5, len); + if(ret == ASN_OK) + { + memFreePtr (call->pctxt, msgptr); + OOTRACEDBGA3("H245 Message sent successfully (%s, %s)\n", + call->callType, call->callToken); + ooOnSendMsg(call, msgType, tunneledMsgType, logicalChannelNo); + return OO_OK; + } + else{ + memFreePtr (call->pctxt, msgptr); + OOTRACEERR3("ERROR:H245 Message send failed (%s, %s)\n", + call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + } + else if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) { + OOTRACEDBGC4("Sending %s H245 message as a tunneled message." + "(%s, %s)\n", ooGetMsgTypeText(msgType), + call->callType, call->callToken); + + ret = ooSendAsTunneledMessage + (call, msgptr+5,len,msgType, logicalChannelNo); + + if(ret != OO_OK) + { + memFreePtr (call->pctxt, msgptr); + OOTRACEERR3("ERROR:Failed to tunnel H.245 message (%s, %s)\n", + call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + memFreePtr (call->pctxt, msgptr); + return OO_OK; + } + } + /* Need to add support for other messages such as T38 etc */ + OOTRACEWARN3("ERROR:Unknown message type - message not Sent (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; +} + +int ooCloseH245Connection(OOH323CallData *call) +{ + OOTRACEINFO3("Closing H.245 connection (%s, %s)\n", call->callType, + call->callToken); + + if (0 != call->pH245Channel) + { + if(0 != call->pH245Channel->sock) + ooSocketClose (call->pH245Channel->sock); + if (call->pH245Channel->outQueue.count > 0) + dListFreeAll(call->pctxt, &(call->pH245Channel->outQueue)); + memFreePtr (call->pctxt, call->pH245Channel); + call->pH245Channel = NULL; + OOTRACEDBGC3("Closed H245 connection. (%s, %s)\n", call->callType, + call->callToken); + } + call->h245SessionState = OO_H245SESSION_CLOSED; + + return OO_OK; +} + +int ooCloseH245Listener(OOH323CallData *call) +{ + OOTRACEINFO3("Closing H.245 Listener (%s, %s)\n", call->callType, + call->callToken); + if(call->h245listener) + { + ooSocketClose(*(call->h245listener)); + memFreePtr(call->pctxt, call->h245listener); + call->h245listener = NULL; + } + return OO_OK; +} + +int ooOnSendMsg + (OOH323CallData *call, int msgType, int tunneledMsgType, int associatedChan) +{ + ooTimerCallback *cbData=NULL; + switch(msgType) + { + case OOSetup: + OOTRACEINFO3("Sent Message - Setup (%s, %s)\n", call->callType, + call->callToken); + /* Start call establishment timer */ + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer callback." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_CALLESTB_TIMER; + if(!ooTimerCreate(call->pctxt, &call->timerList, &ooCallEstbTimerExpired, + gH323ep.callEstablishmentTimeout, cbData, FALSE)) + { + OOTRACEERR3("Error:Unable to create call establishment timer. " + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + + if(gH323ep.h323Callbacks.onOutgoingCall) + gH323ep.h323Callbacks.onOutgoingCall(call); + break; + case OOCallProceeding: + OOTRACEINFO3("Sent Message - CallProceeding (%s, %s)\n", call->callType, + call->callToken); + break; + case OOAlert: + OOTRACEINFO3("Sent Message - Alerting (%s, %s) \n", call->callType, + call->callToken); + if(gH323ep.h323Callbacks.onAlerting && call->callState < OO_CALL_CLEAR) + gH323ep.h323Callbacks.onAlerting(call); + break; + case OOConnect: + OOTRACEINFO3("Sent Message - Connect (%s, %s)\n", call->callType, + call->callToken); + if(gH323ep.h323Callbacks.onCallEstablished) + gH323ep.h323Callbacks.onCallEstablished(call); + break; + case OOReleaseComplete: + OOTRACEINFO3("Sent Message - ReleaseComplete (%s, %s)\n", call->callType, + call->callToken); + + if(call->callState == OO_CALL_CLEAR_RELEASERECVD) + call->callState = OO_CALL_CLEARED; + else{ + call->callState = OO_CALL_CLEAR_RELEASESENT; + if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK) && + gH323ep.gkClient->state == GkClientRegistered){ + OOTRACEDBGA3("Sending DRQ after sending ReleaseComplete." + "(%s, %s)\n", call->callType, call->callToken); + ooGkClientSendDisengageRequest(gH323ep.gkClient, call); + } + } + + if(call->callState == OO_CALL_CLEAR_RELEASESENT && + call->h245SessionState == OO_H245SESSION_IDLE) + { + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer callback " + "data.(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_SESSION_TIMER; + cbData->channelNumber = 0; + if(!ooTimerCreate(call->pctxt, &call->timerList, + &ooSessionTimerExpired, gH323ep.sessionTimeout, cbData, FALSE)) + { + OOTRACEERR3("Error:Unable to create EndSession timer- " + "ReleaseComplete.(%s, %s)\n", call->callType, + call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + } + + if(call->h245SessionState == OO_H245SESSION_CLOSED) + { + call->callState = OO_CALL_CLEARED; + } + break; + + case OOFacility: + if(tunneledMsgType == OOFacility) + { + OOTRACEINFO3("Sent Message - Facility. (%s, %s)\n", + call->callType, call->callToken); + } + else{ + OOTRACEINFO4("Sent Message - Facility(%s) (%s, %s)\n", + ooGetMsgTypeText(tunneledMsgType), + call->callType, call->callToken); + + ooOnSendMsg(call, tunneledMsgType, 0, associatedChan); + } + break; + + case OOMasterSlaveDetermination: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - MasterSlaveDetermination (%s, %s)\n", + call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - MasterSlaveDetermination (%s, %s)\n", + call->callType, call->callToken); + /* Start MSD timer */ + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer callback data." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_MSD_TIMER; + if(!ooTimerCreate(call->pctxt, &call->timerList, &ooMSDTimerExpired, + gH323ep.msdTimeout, cbData, FALSE)) + { + OOTRACEERR3("Error:Unable to create MSD timer. " + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + + break; + case OOMasterSlaveAck: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationAck (%s, %s)" + "\n", call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - MasterSlaveDeterminationAck (%s, %s)\n", + call->callType, call->callToken); + break; + case OOMasterSlaveReject: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationReject " + "(%s, %s)\n", call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - MasterSlaveDeterminationReject(%s, %s)\n", + call->callType, call->callToken); + break; + case OOMasterSlaveRelease: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - MasterSlaveDeterminationRelease " + "(%s, %s)\n", call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - MasterSlaveDeterminationRelease " + "(%s, %s)\n", call->callType, call->callToken); + break; + case OOTerminalCapabilitySet: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) { + /* If session isn't marked active yet, do it. possible in case of + tunneling */ + if(call->h245SessionState == OO_H245SESSION_IDLE || + call->h245SessionState == OO_H245SESSION_PAUSED) { + call->h245SessionState = OO_H245SESSION_ACTIVE; + } + OOTRACEINFO3("Tunneled Message - TerminalCapabilitySet (%s, %s)\n", + call->callType, call->callToken); + } + else { + OOTRACEINFO3("Sent Message - TerminalCapabilitySet (%s, %s)\n", + call->callType, call->callToken); + } + /* Start TCS timer */ + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer callback data." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_TCS_TIMER; + if(!ooTimerCreate(call->pctxt, &call->timerList, &ooTCSTimerExpired, + gH323ep.tcsTimeout, cbData, FALSE)) + { + OOTRACEERR3("Error:Unable to create TCS timer. " + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + break; + + + case OOTerminalCapabilitySetAck: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - TerminalCapabilitySetAck (%s, %s)\n", + call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - TerminalCapabilitySetAck (%s, %s)\n", + call->callType, call->callToken); + break; + case OOTerminalCapabilitySetReject: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - TerminalCapabilitySetReject " + "(%s, %s)\n", call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - TerminalCapabilitySetReject (%s, %s)\n", + call->callType, call->callToken); + break; + case OOOpenLogicalChannel: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO4("Tunneled Message - OpenLogicalChannel(%d). (%s, %s)\n", + associatedChan, call->callType, call->callToken); + else + OOTRACEINFO4("Sent Message - OpenLogicalChannel(%d). (%s, %s)\n", + associatedChan, call->callType, call->callToken); + /* Start LogicalChannel timer */ + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer callback data." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_OLC_TIMER; + cbData->channelNumber = associatedChan; + if(!ooTimerCreate(call->pctxt, &call->timerList, + &ooOpenLogicalChannelTimerExpired, gH323ep.logicalChannelTimeout, + cbData, FALSE)) + { + OOTRACEERR3("Error:Unable to create OpenLogicalChannel timer. " + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + + break; + case OOOpenLogicalChannelAck: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO4("Tunneled Message - OpenLogicalChannelAck(%d) (%s,%s)\n", + associatedChan, call->callType, call->callToken); + else + OOTRACEINFO4("Sent Message - OpenLogicalChannelAck(%d) (%s, %s)\n", + associatedChan, call->callType, call->callToken); + break; + case OOOpenLogicalChannelReject: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO4("Tunneled Message - OpenLogicalChannelReject(%d)" + "(%s, %s)\n", associatedChan, call->callType, + call->callToken); + else + OOTRACEINFO4("Sent Message - OpenLogicalChannelReject(%d) (%s, %s)\n", + associatedChan, call->callType, call->callToken); + break; + case OOEndSessionCommand: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - EndSessionCommand(%s, %s)\n", + call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - EndSessionCommand (%s, %s)\n", + call->callType, call->callToken); + if((call->h245SessionState == OO_H245SESSION_ACTIVE)) + { + /* Start EndSession timer */ + call->h245SessionState = OO_H245SESSION_ENDSENT; + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer callback " + "data.(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_SESSION_TIMER; + cbData->channelNumber = 0; + if(!ooTimerCreate(call->pctxt, &call->timerList, + &ooSessionTimerExpired, gH323ep.sessionTimeout, cbData, FALSE)) + { + OOTRACEERR3("Error:Unable to create EndSession timer. " + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + } + else{ + ooCloseH245Connection(call); + } + break; + case OOCloseLogicalChannel: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - CloseLogicalChannel (%s, %s)\n", + call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - CloseLogicalChannel (%s, %s)\n", + call->callType, call->callToken); + /* Start LogicalChannel timer */ + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer callback data." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_CLC_TIMER; + cbData->channelNumber = associatedChan; + if(!ooTimerCreate(call->pctxt, &call->timerList, + &ooCloseLogicalChannelTimerExpired, gH323ep.logicalChannelTimeout, + cbData, FALSE)) + { + OOTRACEERR3("Error:Unable to create CloseLogicalChannel timer. " + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + + break; + case OOCloseLogicalChannelAck: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - CloseLogicalChannelAck (%s, %s)\n", + call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - CloseLogicalChannelAck (%s, %s)\n", + call->callType, call->callToken); + break; + case OORequestChannelClose: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - RequestChannelClose (%s, %s)\n", + call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - RequestChannelClose (%s, %s)\n", + call->callType, call->callToken); + /* Start RequestChannelClose timer */ + cbData = (ooTimerCallback*) memAlloc(call->pctxt, + sizeof(ooTimerCallback)); + if(!cbData) + { + OOTRACEERR3("Error:Unable to allocate memory for timer callback data." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + cbData->call = call; + cbData->timerType = OO_RCC_TIMER; + cbData->channelNumber = associatedChan; + if(!ooTimerCreate(call->pctxt, &call->timerList, + &ooRequestChannelCloseTimerExpired, gH323ep.logicalChannelTimeout, + cbData, FALSE)) + { + OOTRACEERR3("Error:Unable to create RequestChannelClose timer. " + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + return OO_FAILED; + } + break; + case OORequestChannelCloseAck: + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + OOTRACEINFO3("Tunneled Message - RequestChannelCloseAck (%s, %s)\n", + call->callType, call->callToken); + else + OOTRACEINFO3("Sent Message - RequestChannelCloseAck (%s, %s)\n", + call->callType, call->callToken); + break; + + default: + ; + } + return OO_OK; +} + + +int ooStopMonitorCalls() +{ + OOH323CallData * call; + if(gMonitor) + { + OOTRACEINFO1("Doing ooStopMonitorCalls\n"); + if(gH323ep.cmdSock) + { + ooCloseCmdConnection(); + } + + if(gH323ep.callList) + { + OOTRACEWARN1("Warn:Abruptly ending calls as stack going down\n"); + call = gH323ep.callList; + while(call) + { + OOTRACEWARN3("Clearing call (%s, %s)\n", call->callType, + call->callToken); + call->callEndReason = OO_REASON_LOCAL_CLEARED; + ooCleanCall(call); + call = NULL; + call = gH323ep.callList; + } + gH323ep.callList = NULL; + } + OOTRACEINFO1("Stopping listener for incoming calls\n"); + if(gH323ep.listener) + { + ooSocketClose(*(gH323ep.listener)); + memFreePtr(&gH323ep.ctxt, gH323ep.listener); + gH323ep.listener = NULL; + } + + gMonitor = FALSE; + OOTRACEINFO1("Done ooStopMonitorCalls\n"); + } + return OO_OK; +} + +OOBOOL ooChannelsIsConnectionOK(OOH323CallData *call, OOSOCKET sock) +{ + struct timeval to; + fd_set readfds; + int ret = 0, nfds=0; + + to.tv_sec = 0; + to.tv_usec = 500; + FD_ZERO(&readfds); + + FD_SET(sock, &readfds); + if(nfds < (int)sock) + nfds = (int)sock; + + nfds++; + + ret = ooSocketSelect(nfds, &readfds, NULL, NULL, &to); + + if(ret == -1) + { + OOTRACEERR3("Error in select ...broken pipe check(%s, %s)\n", + call->callType, call->callToken ); + return FALSE; + } + + if(FD_ISSET(sock, &readfds)) + { + char buf[2]; + if(ooSocketRecvPeek(sock, buf, 2) == 0) + { + OOTRACEWARN3("Broken pipe detected. (%s, %s)", call->callType, + call->callToken); + if(call->callState < OO_CALL_CLEAR) + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEARED; + return FALSE; + } + } + return TRUE; +} diff --git a/addons/ooh323c/src/oochannels.h b/addons/ooh323c/src/oochannels.h new file mode 100644 index 000000000..96befb567 --- /dev/null +++ b/addons/ooh323c/src/oochannels.h @@ -0,0 +1,216 @@ +/* + * 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. + * + *****************************************************************************/ + +/** + * @file oochannels.h + * This file contains functions to create and use channels. + */ +#ifndef _OOCHANNELS_H_ +#define _OOCHANNELS_H_ + +#include "H323-MESSAGES.h" +#include "MULTIMEDIA-SYSTEM-CONTROL.h" +#include "ootypes.h" +#include "ooSocket.h" +#include "ooCalls.h" + +#define OORECEIVER 1 +#define OOTRANSMITTER 2 +#define OODUPLEX 3 + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +struct OOH323CallData; +struct Q931Message; + +/** + * @defgroup channels Channel Management + * @{ + */ +/** + * This function is used to create a listener for incoming calls. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCreateH323Listener(void); + +/** + * This function is used to create a listener for incoming H.245 connections. + * @param call Pointer to call for which H.245 listener has to be created + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCreateH245Listener(struct OOH323CallData *call); + +/** + * This function is used to close an H245 listener for a call. + * @param call Pointer to call for which H245 Listener has to be closed. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCloseH245Listener(struct OOH323CallData *call); + +/** + * This function is used to accept incoming H.225 connections. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooAcceptH225Connection(void); + +/** + * This function is used to accept an incoming H.245 connection. + * @param call Pointer to a call for which H.245 connection request has + * arrived. + * + * @return OO_OK, on succes. OO_FAILED, on failure. + */ +EXTERN int ooAcceptH245Connection(struct OOH323CallData *call); + +/** + * This function is used to create an H.225 connection to the remote end point. + * @param call Pointer to the call for which H.225 connection has to be + * setup. + * @return OO_OK, on succes. OO_FAILED, on failure. + */ +EXTERN int ooCreateH225Connection(struct OOH323CallData *call); + +/** + * This function is used to setup an H.245 connection with the remote endpoint + * for control negotiations. + * @param call Pointer to call for which H.245 connection has to be setup. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCreateH245Connection(struct OOH323CallData *call); + +/** + * This function is used to close an H.225 connection + * @param call Pointer to the call for which H.225 connection has to be + * closed. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCloseH225Connection(struct OOH323CallData *call); + +/** + * This function is used to close an H.245 connection for a call. + * + * @param call Pointer to call for which H.245 connection has + * to be closed. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCloseH245Connection(struct OOH323CallData *call); + +/** + * This function is used to start monitoring channels for the calls. It has + * an infinite loop which uses select to monitor various channels. + * + */ +EXTERN int ooMonitorChannels(void); + +/** + * This function is called to stop the monitor channels event loop. + * It cleans up all the active calls before stopping the monitor. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooStopMonitorCalls(void); + +/** + * This function is used to receive an H.2250 message received on a calls + * H.225 channel. It receives the message, decodes it and calls + * 'ooHandleH2250Message' to process the message. + * @param call Pointer to the call for which the message has to be + * received. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooH2250Receive(struct OOH323CallData *call); + +/** + * This function is used to receive an H.245 message received on a calls + * H.245 channel. It receives the message, decodes it and calls + * 'ooHandleH245Message' to process it. + * @param call Pointer to the call for which the message has to be + * received. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooH245Receive(struct OOH323CallData *call); + +/** + * This function is used to enqueue an H.225 message into an outgoing queue for + * the call. + * @param call Pointer to call for which message has to be enqueued. + * @param msg Pointer to the H.225 message to be sent. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendH225Msg(struct OOH323CallData *call, struct Q931Message *msg); + +/** + * This function is used to Send a message on the channel, when channel is + * available for write. + * @param call Pointer to call for which message has to be sent. + * @param type Type of the message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendMsg(struct OOH323CallData *call, int type); + +/** + * This function is called after a message is sent on the call's channel. + * It can be used to some followup action after message has been sent. + * @param call Pointer to call for which message has been sent. + * @param msgType Type of message + * @param tunneledMsgType If this message is carrying a tunneled message, then + * type of the tunneled message. + * @param associatedChan The channel number associated with the message sent, + * or tunneled message. 0, if no channel is associated. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooOnSendMsg + (struct OOH323CallData *call, int msgType, int tunneledMsgType, + int associatedChan); + +/** + * This function is used to check the status of tcp connection. + * @param call Handle to the call to which connection belongs. + * @param sock Connected socket. + * + * @return True if connection is ok, false otherwise. + */ +EXTERN OOBOOL ooChannelsIsConnectionOK(OOH323CallData *call, OOSOCKET sock); + +/** + * @} + */ +#ifdef __cplusplus +} +#endif +#endif + diff --git a/addons/ooh323c/src/ooh245.c b/addons/ooh323c/src/ooh245.c new file mode 100644 index 000000000..35d1fe1b0 --- /dev/null +++ b/addons/ooh323c/src/ooh245.c @@ -0,0 +1,3686 @@ +/* + * 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 "ooh245.h" +#include "ooCalls.h" +#include "printHandler.h" +#include "ooh323ep.h" +#include "ooCapability.h" +#include "ooTimer.h" +#ifdef _WIN32 +#include +#include +#define getpid _getpid +#endif +#include + +/** Global endpoint structure */ +extern ooEndPoint gH323ep; + +static ASN1OBJID gh245ProtocolID = { + 6, { 0, 0, 8, 245, 0, 8 } +}; + +int ooCreateH245Message(H245Message **pph245msg, int type) +{ + OOCTXT* pctxt = &gH323ep.msgctxt; + + *pph245msg = (H245Message*) memAlloc (pctxt, sizeof(H245Message)); + + if(!(*pph245msg)) + { + OOTRACEERR1("ERROR:Failed to allocate memory for h245 message\n"); + return OO_FAILED; + } + else + { + (*pph245msg)->h245Msg.t = type; + (*pph245msg)->logicalChannelNo = 0; + switch(type) + { + case T_H245MultimediaSystemControlMessage_request: + (*pph245msg)->h245Msg.u.request = (H245RequestMessage*) + memAllocZ (pctxt, sizeof(H245RequestMessage)); + + /*Check for successful mem allocation, and if successful initialize + mem to zero*/ + if(!(*pph245msg)->h245Msg.u.request) + { + OOTRACEERR1("ERROR:Memory allocation for H.245 request" + " message failed\n"); + return OO_FAILED; + } + break; + + case T_H245MultimediaSystemControlMessage_response: + (*pph245msg)->h245Msg.u.response = (H245ResponseMessage*) + memAllocZ (pctxt, sizeof(H245ResponseMessage)); + + /*Check for successful mem allocation, and if successful initialize + mem to zero*/ + if(!(*pph245msg)->h245Msg.u.response) + { + OOTRACEERR1("ERROR:Memory allocation for H.245 response" + " message failed\n"); + return OO_FAILED; + } + break; + + case T_H245MultimediaSystemControlMessage_command: + (*pph245msg)->h245Msg.u.command = (H245CommandMessage*) + memAllocZ (pctxt, sizeof(H245CommandMessage)); + + /*Check for successful mem allocation, and if successful initialize + mem to zero*/ + if(!(*pph245msg)->h245Msg.u.command) + { + OOTRACEERR1("ERROR:Memory allocation for H.245 command" + " message failed\n"); + return OO_FAILED; + } + break; + + case T_H245MultimediaSystemControlMessage_indication: + (*pph245msg)->h245Msg.u.indication = (H245IndicationMessage*) + memAllocZ (pctxt, sizeof(H245IndicationMessage)); + + /*Check for successful mem allocation, and if successful initialize + mem to zero*/ + if(!(*pph245msg)->h245Msg.u.indication) + { + OOTRACEERR1("ERROR:Memory allocation for H.245 indication" + " message failed\n"); + return OO_FAILED; + } + break; + + default: + OOTRACEERR1("ERROR: H245 message type not supported\n"); + } + + return OO_OK; + } +} + +int ooFreeH245Message(OOH323CallData *call, H245Message *pmsg) +{ + /* In case of tunneling, memory is freed when corresponding Q931 message is freed.*/ + OOTRACEDBGC1("msgCtxt Reset?"); + if (0 != pmsg) { + if(!OO_TESTFLAG (call->flags, OO_M_TUNNELING)){ + memReset (&gH323ep.msgctxt); + OOTRACEDBGC3(" Done (%s, %s)\n", call->callType, call->callToken); + return OO_OK; + } + } + OOTRACEDBGC3("Not Done (%s, %s)\n", call->callType, call->callToken); + return OO_OK; +} + +#ifndef _COMPACT +static void ooPrintH245Message + (OOH323CallData* call, ASN1OCTET* msgbuf, ASN1UINT msglen) +{ + OOCTXT ctxt; + H245MultimediaSystemControlMessage mmMsg; + int ret; + + initContext (&ctxt); + + setPERBuffer (&ctxt, msgbuf, msglen, TRUE); + + initializePrintHandler(&printHandler, "Sending H.245 Message"); + + /* Set event handler */ + setEventHandler (&ctxt, &printHandler); + + ret = asn1PD_H245MultimediaSystemControlMessage(&ctxt, &mmMsg); + if(ret != ASN_OK) + { + OOTRACEERR3("Error decoding H245 message (%s, %s)\n", + call->callType, call->callToken); + OOTRACEERR1 (errGetText (&ctxt)); + } + finishPrint(); + freeContext(&ctxt); +} +#endif + +int ooEncodeH245Message + (OOH323CallData *call, H245Message *ph245Msg, char *msgbuf, int size) +{ + int len=0, encodeLen=0, i=0; + int stat=0; + ASN1OCTET* encodePtr=NULL; + H245MultimediaSystemControlMessage *multimediaMsg; + OOCTXT *pctxt = &gH323ep.msgctxt; + multimediaMsg = &(ph245Msg->h245Msg); + + if(!msgbuf || size<200) + { + OOTRACEERR3("Error: Invalid message buffer/size for " + "ooEncodeH245Message. (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + msgbuf[i++] = ph245Msg->msgType; + msgbuf[i++] = (ph245Msg->logicalChannelNo>>8); + msgbuf[i++] = ph245Msg->logicalChannelNo; + /* This will contain the total length of the encoded message */ + msgbuf[i++] = 0; + msgbuf[i++] = 0; + + if(!OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + /* Populate message buffer to be returned */ + len = 4; + msgbuf[i++] = 3; /* TPKT version */ + msgbuf[i++] = 0; /* TPKT resevred */ + /* 1st octet of length, will be populated once len is determined */ + msgbuf[i++] = 0; + /* 2nd octet of length, will be populated once len is determined */ + msgbuf[i++] = 0; + } + + setPERBuffer (pctxt, msgbuf+i, (size-i), TRUE); + + stat = asn1PE_H245MultimediaSystemControlMessage (&gH323ep.msgctxt, + multimediaMsg); + + if (stat != ASN_OK) { + OOTRACEERR3 ("ERROR: H245 Message encoding failed (%s, %s)\n", + call->callType, call->callToken); + OOTRACEERR1 (errGetText (&gH323ep.msgctxt)); + return OO_FAILED; + } + + encodePtr = encodeGetMsgPtr(pctxt, &encodeLen); + len +=encodeLen; + msgbuf[3] = (len>>8); + msgbuf[4] = len; + if(!OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + msgbuf[7] = len>>8; + msgbuf[8] = len; + } +#ifndef _COMPACT + ooPrintH245Message (call, encodePtr, encodeLen); +#endif + return OO_OK; +} + +int ooSendH245Msg(OOH323CallData *call, H245Message *msg) +{ + int iRet=0, len=0, msgType=0, logicalChannelNo = 0; + ASN1OCTET * encodebuf; + + + if(!call) + return OO_FAILED; + + encodebuf = (ASN1OCTET*) memAlloc (call->pctxt, MAXMSGLEN); + if(!encodebuf) + { + OOTRACEERR3("Error:Failed to allocate memory for encoding H245 " + "message(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + iRet = ooEncodeH245Message(call, msg, encodebuf, MAXMSGLEN); + + if(iRet != OO_OK) + { + OOTRACEERR3("Error:Failed to encode H245 message. (%s, %s)\n", + call->callType, call->callToken); + memFreePtr (call->pctxt, encodebuf); + return OO_FAILED; + } + if(!call->pH245Channel) + { + call->pH245Channel = + (OOH323Channel*) memAllocZ (call->pctxt, sizeof(OOH323Channel)); + if(!call->pH245Channel) + { + OOTRACEERR3("Error:Failed to allocate memory for H245Channel " + "structure. (%s, %s)\n", call->callType, call->callToken); + memFreePtr (call->pctxt, encodebuf); + return OO_FAILED; + } + } + + /* We need to send EndSessionCommand immediately.*/ + if(!OO_TESTFLAG(call->flags, OO_M_TUNNELING)){ + if(encodebuf[0]== OOEndSessionCommand) /* High priority message */ + { + dListFreeAll(call->pctxt, &call->pH245Channel->outQueue); + dListAppend (call->pctxt, &call->pH245Channel->outQueue, encodebuf); + ooSendMsg(call, OOH245MSG); + } + else{ + dListAppend (call->pctxt, &call->pH245Channel->outQueue, encodebuf); + OOTRACEDBGC4("Queued H245 messages %d. (%s, %s)\n", + call->pH245Channel->outQueue.count, + call->callType, call->callToken); + } + } + else{ + msgType = encodebuf[0]; + + logicalChannelNo = encodebuf[1]; + logicalChannelNo = logicalChannelNo << 8; + logicalChannelNo = (logicalChannelNo | encodebuf[2]); + + len = encodebuf[3]; + len = len<<8; + len = (len | encodebuf[4]); + + iRet = ooSendAsTunneledMessage + (call, encodebuf+5,len,msgType, logicalChannelNo); + + if(iRet != OO_OK) + { + memFreePtr (call->pctxt, encodebuf); + OOTRACEERR3("ERROR:Failed to tunnel H.245 message (%s, %s)\n", + call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + memFreePtr (call->pctxt, encodebuf); + return OO_OK; + } + + return OO_OK; +} + +int ooSendTermCapMsg(OOH323CallData *call) +{ + int ret; + H245RequestMessage *request=NULL; + OOCTXT *pctxt=NULL; + ooH323EpCapability *epCap=NULL; + H245TerminalCapabilitySet *termCap=NULL; + H245AudioCapability *audioCap=NULL; + H245AudioTelephonyEventCapability *ateCap=NULL; + H245UserInputCapability *userInputCap = NULL; + H245CapabilityTableEntry *entry=NULL; + H245AlternativeCapabilitySet *altSet=NULL; + H245CapabilityDescriptor *capDesc=NULL; + H245Message *ph245msg=NULL; + H245VideoCapability *videoCap=NULL; + + int i=0, j=0, k=0; + if(call->localTermCapState == OO_LocalTermCapSetSent) + { + OOTRACEINFO3("TerminalCapabilitySet exchange procedure already in " + "progress. (%s, %s)\n", call->callType, call->callToken); + return OO_OK; + } + + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_request); + + if(ret == OO_FAILED) + { + OOTRACEERR3("Error:Failed to create H245 message for Terminal " + "CapabilitySet (%s, %s)\n", call->callType,call->callToken); + return OO_FAILED; + } + + /* Set request type as TerminalCapabilitySet */ + request = ph245msg->h245Msg.u.request; + pctxt = &gH323ep.msgctxt; + ph245msg->msgType = OOTerminalCapabilitySet; + memset(request, 0, sizeof(H245RequestMessage)); + if(request == NULL) + { + OOTRACEERR3("ERROR: No memory allocated for request message (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + request->t = T_H245RequestMessage_terminalCapabilitySet; + request->u.terminalCapabilitySet = (H245TerminalCapabilitySet*) + memAlloc(pctxt, sizeof(H245TerminalCapabilitySet)); + termCap = request->u.terminalCapabilitySet; + memset(termCap, 0, sizeof(H245TerminalCapabilitySet)); + termCap->m.multiplexCapabilityPresent = 0; + termCap->m.capabilityTablePresent = 1; + termCap->m.capabilityDescriptorsPresent = 1; + termCap->sequenceNumber = ++(call->localTermCapSeqNo); + termCap->protocolIdentifier = gh245ProtocolID; /* protocol id */ + + /* Add audio Capabilities */ + + dListInit(&(termCap->capabilityTable)); + for(k=0; k<(int)call->capPrefs.index; k++) + { + if(call->ourCaps) + epCap = call->ourCaps; + else + epCap = gH323ep.myCaps; + while(epCap) { + if(epCap->cap == call->capPrefs.order[k]) + break; + epCap = epCap->next; + } + if(!epCap) + { + OOTRACEWARN4("WARN:Preferred capability %d not supported.(%s, %s)\n", + call->capPrefs.order[k],call->callType, call->callToken); + continue; + } + + if(epCap->capType == OO_CAP_TYPE_AUDIO) + { + + /* Create audio capability. If capability supports receive, we only + add it as receive capability in TCS. However, if it supports only + transmit, we add it as transmit capability in TCS. + */ + if((epCap->dir & OORX)) + { + + OOTRACEDBGC4("Sending receive capability %s in TCS.(%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, call->callToken); + + audioCap = ooCapabilityCreateAudioCapability(epCap, pctxt, OORX); + if(!audioCap) + { + OOTRACEWARN4("WARN:Failed to create audio capability %s " + "(%s, %s)\n", ooGetCapTypeText(epCap->cap), + call->callType, call->callToken); + continue; + } + } + else if(epCap->dir & OOTX) + { + OOTRACEDBGC4("Sending transmit capability %s in TCS.(%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, call->callToken); + audioCap = ooCapabilityCreateAudioCapability(epCap, pctxt, OOTX); + if(!audioCap) + { + OOTRACEWARN4("WARN:Failed to create audio capability %s " + "(%s, %s)\n", ooGetCapTypeText(epCap->cap), + call->callType, call->callToken); + continue; + } + } + else{ + OOTRACEWARN3("Warn:Capability is not RX/TX/RXANDTX. Symmetric " + "capabilities are not supported.(%s, %s)\n", + call->callType, call->callToken); + continue; + } + /* Add Capabilities to Capability Table */ + entry = (H245CapabilityTableEntry*) memAlloc(pctxt, + sizeof(H245CapabilityTableEntry)); + if(!entry) + { + OOTRACEERR3("Error:Memory - ooSendTermCapMsg - entry(audio Cap)." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + memset(entry, 0, sizeof(H245CapabilityTableEntry)); + entry->m.capabilityPresent = 1; + if((epCap->dir & OORX)) + { + entry->capability.t = T_H245Capability_receiveAudioCapability; + entry->capability.u.receiveAudioCapability = audioCap; + } + else{ + entry->capability.t = T_H245Capability_transmitAudioCapability; + entry->capability.u.transmitAudioCapability = audioCap; + } + entry->capabilityTableEntryNumber = i+1; + dListAppend(pctxt , &(termCap->capabilityTable), entry); + i++; + } + else if(epCap->capType == OO_CAP_TYPE_VIDEO) + { + if((epCap->dir & OORX)) + { + OOTRACEDBGC4("Sending receive capability %s in TCS.(%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, call->callToken); + videoCap = ooCapabilityCreateVideoCapability(epCap, pctxt, OORX); + if(!videoCap) + { + OOTRACEWARN4("WARN:Failed to create Video capability %s " + "(%s, %s)\n", ooGetCapTypeText(epCap->cap), + call->callType, call->callToken); + continue; + } + } + else if(epCap->dir & OOTX) + { + OOTRACEDBGC4("Sending transmit capability %s in TCS.(%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, call->callToken); + videoCap = ooCapabilityCreateVideoCapability(epCap, pctxt, OOTX); + if(!videoCap) + { + OOTRACEWARN4("WARN:Failed to create video capability %s " + "(%s, %s)\n", ooGetCapTypeText(epCap->cap), + call->callType, call->callToken); + continue; + } + } + else{ + OOTRACEWARN3("Warn:Capability is not RX/TX/RXANDTX. Symmetric " + "capabilities are not supported.(%s, %s)\n", + call->callType, call->callToken); + continue; + } + /* Add Video capabilities to Capability Table */ + entry = (H245CapabilityTableEntry*) memAlloc(pctxt, + sizeof(H245CapabilityTableEntry)); + if(!entry) + { + OOTRACEERR3("Error:Memory - ooSendTermCapMsg - entry(video Cap)." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + memset(entry, 0, sizeof(H245CapabilityTableEntry)); + entry->m.capabilityPresent = 1; + if((epCap->dir & OORX)) + { + entry->capability.t = T_H245Capability_receiveVideoCapability; + entry->capability.u.receiveVideoCapability = videoCap; + } + else{ + entry->capability.t = T_H245Capability_transmitVideoCapability; + entry->capability.u.transmitVideoCapability = videoCap; + } + entry->capabilityTableEntryNumber = i+1; + dListAppend(pctxt , &(termCap->capabilityTable), entry); + i++; + } + } + /* Add dtmf capability, if any */ + if(call->dtmfmode & OO_CAP_DTMF_RFC2833) + { + ateCap = (H245AudioTelephonyEventCapability*) + ooCapabilityCreateDTMFCapability(OO_CAP_DTMF_RFC2833, pctxt); + if(!ateCap) + { + OOTRACEWARN3("WARN:Failed to add RFC2833 cap to TCS(%s, %s)\n", + call->callType, call->callToken); + } + else { + entry = (H245CapabilityTableEntry*) memAlloc(pctxt, + sizeof(H245CapabilityTableEntry)); + if(!entry) + { + OOTRACEERR3("Error:Failed to allocate memory for new capability " + "table entry. (%s, %s)\n", call->callType, + call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + + memset(entry, 0, sizeof(H245CapabilityTableEntry)); + entry->m.capabilityPresent = 1; + + entry->capability.t = T_H245Capability_receiveRTPAudioTelephonyEventCapability; + entry->capability.u.receiveRTPAudioTelephonyEventCapability = ateCap; + + entry->capabilityTableEntryNumber = i+1; + dListAppend(pctxt , &(termCap->capabilityTable), entry); + + i++; + } + } + + if(call->dtmfmode & OO_CAP_DTMF_H245_alphanumeric) + { + userInputCap = (H245UserInputCapability*)ooCapabilityCreateDTMFCapability + (OO_CAP_DTMF_H245_alphanumeric, pctxt); + if(!userInputCap) + { + OOTRACEWARN3("WARN:Failed to add H245(alphanumeric) cap to " + "TCS(%s, %s)\n", call->callType, call->callToken); + } + else { + entry = (H245CapabilityTableEntry*) memAlloc(pctxt, + sizeof(H245CapabilityTableEntry)); + if(!entry) + { + OOTRACEERR3("Error:Failed to allocate memory for new capability " + "table entry. (%s, %s)\n", call->callType, + call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + + memset(entry, 0, sizeof(H245CapabilityTableEntry)); + entry->m.capabilityPresent = 1; + + entry->capability.t = T_H245Capability_receiveUserInputCapability; + entry->capability.u.receiveUserInputCapability = userInputCap; + + entry->capabilityTableEntryNumber = i+1; + dListAppend(pctxt , &(termCap->capabilityTable), entry); + + i++; + } + } + userInputCap = NULL; + if(call->dtmfmode & OO_CAP_DTMF_H245_signal) + { + userInputCap = (H245UserInputCapability*)ooCapabilityCreateDTMFCapability + (OO_CAP_DTMF_H245_signal, pctxt); + if(!userInputCap) + { + OOTRACEWARN3("WARN:Failed to add H245(signal) cap to " + "TCS(%s, %s)\n", call->callType, call->callToken); + } + else { + entry = (H245CapabilityTableEntry*) memAlloc(pctxt, + sizeof(H245CapabilityTableEntry)); + if(!entry) + { + OOTRACEERR3("Error:Failed to allocate memory for new capability " + "table entry. (%s, %s)\n", call->callType, + call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + + memset(entry, 0, sizeof(H245CapabilityTableEntry)); + entry->m.capabilityPresent = 1; + + entry->capability.t = T_H245Capability_receiveUserInputCapability; + entry->capability.u.receiveUserInputCapability = userInputCap; + + entry->capabilityTableEntryNumber = i+1; + dListAppend(pctxt , &(termCap->capabilityTable), entry); + + i++; + } + } + + + /*TODO:Add Video and Data capabilities, if required*/ + if(i==0) + { + OOTRACEERR3("Error:No capabilities found to send in TCS message." + " (%s, %s)\n", call->callType, call->callToken); + ooFreeH245Message(call,ph245msg); + return OO_FAILED; + } + + /* Define capability descriptior */ + capDesc = (H245CapabilityDescriptor*) + memAlloc(pctxt, sizeof(H245CapabilityDescriptor)); + memset(capDesc, 0, sizeof(H245CapabilityDescriptor)); + capDesc->m.simultaneousCapabilitiesPresent = 1; + capDesc->capabilityDescriptorNumber = 1; + dListInit(&(capDesc->simultaneousCapabilities)); + /* Add Alternative Capability Set. + TODO: Right now all capabilities are added in separate + alternate capabilities set. Need a way for application + developer to specify the alternative capability sets. + */ + for(j=0; jn = 1; + altSet->elem[0] = j+1; + + dListAppend(pctxt, &(capDesc->simultaneousCapabilities), altSet); + } + + dListInit(&(termCap->capabilityDescriptors)); + dListAppend(pctxt, &(termCap->capabilityDescriptors), capDesc); + + OOTRACEDBGA3("Built terminal capability set message (%s, %s)\n", + call->callType, call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue TCS message to outbound queue. " + "(%s, %s)\n", call->callType, call->callToken); + } + else { + call->localTermCapState = OO_LocalTermCapSetSent; + } + + ooFreeH245Message(call,ph245msg); + + return ret; +} + + +ASN1UINT ooGenerateStatusDeterminationNumber() +{ + ASN1UINT statusDeterminationNumber; + ASN1UINT random_factor = getpid(); + +#ifdef _WIN32 + SYSTEMTIME systemTime; + GetLocalTime(&systemTime); + srand((systemTime.wMilliseconds ^ systemTime.wSecond) + random_factor); +#else + struct timeval tv; + gettimeofday(&tv, NULL); + srand((tv.tv_usec ^ tv.tv_sec) + random_factor ); +#endif + + statusDeterminationNumber = rand()%16777215; + return statusDeterminationNumber; +} +/* TODO: Should Send MasterSlave Release when no response from + Remote endpoint after MasterSlaveDetermination sent within + timeout. +*/ +int ooHandleMasterSlave(OOH323CallData *call, void * pmsg, + int msgType) +{ + H245MasterSlaveDetermination *masterSlave; + H245MasterSlaveDeterminationAck *masterSlaveAck; + ASN1UINT statusDeterminationNumber; + + switch(msgType) + { + case OOMasterSlaveDetermination: + OOTRACEINFO3("Master Slave Determination received (%s, %s)\n", + call->callType, call->callToken); + + masterSlave = (H245MasterSlaveDetermination*)pmsg; + + if(masterSlave->terminalType < gH323ep.termType) + { + ooSendMasterSlaveDeterminationAck(call, "slave"); + call->masterSlaveState = OO_MasterSlave_Master; + OOTRACEINFO3("MasterSlaveDetermination done - Master(%s, %s)\n", + call->callType, call->callToken); + return OO_OK; + } + if(masterSlave->terminalType > gH323ep.termType) + { + ooSendMasterSlaveDeterminationAck(call, "master"); + call->masterSlaveState = OO_MasterSlave_Slave; + OOTRACEINFO3("MasterSlaveDetermination done - Slave(%s, %s)\n", + call->callType, call->callToken); + return OO_OK; + } + /* Since term types are same, master slave determination will + be done based on statusdetermination number + */ + + OOTRACEDBGA3("Determining master-slave based on StatusDetermination" + "Number (%s, %s)\n", call->callType, call->callToken); + if(call->masterSlaveState == OO_MasterSlave_DetermineSent) + statusDeterminationNumber = call->statusDeterminationNumber; + else + statusDeterminationNumber = ooGenerateStatusDeterminationNumber(); + + if(masterSlave->statusDeterminationNumber < + statusDeterminationNumber) + { + ooSendMasterSlaveDeterminationAck(call, "slave"); + call->masterSlaveState = OO_MasterSlave_Master; + OOTRACEINFO3("MasterSlaveDetermination done - Master(%s, %s)\n", + call->callType, call->callToken); + return OO_OK; + } + if(masterSlave->statusDeterminationNumber > + statusDeterminationNumber) + { + ooSendMasterSlaveDeterminationAck(call, "master"); + call->masterSlaveState = OO_MasterSlave_Slave; + OOTRACEINFO3("MasterSlaveDetermination done - Slave(%s, %s)\n", + call->callType, call->callToken); + return OO_OK; + } + if(masterSlave->statusDeterminationNumber == + statusDeterminationNumber) + { + ooSendMasterSlaveDeterminationReject (call); + + OOTRACEERR3("ERROR:MasterSlaveDetermination failed- identical " + "numbers (%s, %s)\n", call->callType, call->callToken); + } + break; + + case OOMasterSlaveAck: + masterSlaveAck = (H245MasterSlaveDeterminationAck*)pmsg; + if(call->masterSlaveState == OO_MasterSlave_DetermineSent) + { + if(masterSlaveAck->decision.t == + T_H245MasterSlaveDeterminationAck_decision_master) + { + ooSendMasterSlaveDeterminationAck(call, "slave"); + call->masterSlaveState = OO_MasterSlave_Master; + OOTRACEINFO3("MasterSlaveDetermination done - Master(%s, %s)\n", + call->callType, call->callToken); + } + else + { + ooSendMasterSlaveDeterminationAck(call, "master"); + call->masterSlaveState = OO_MasterSlave_Slave; + OOTRACEINFO3("MasterSlaveDetermination done - Slave(%s, %s)\n", + call->callType, call->callToken); + } + } + + if(call->localTermCapState == OO_LocalTermCapSetAckRecvd && + call->remoteTermCapState == OO_RemoteTermCapSetAckSent) + { + /*Since Cap exchange and MasterSlave Procedures are done */ + if(gH323ep.h323Callbacks.openLogicalChannels) + gH323ep.h323Callbacks.openLogicalChannels(call); + else{ + if(!call->logicalChans) + ooOpenLogicalChannels(call); + } +#if 0 + if(!call->logicalChans){ + if(!gH323ep.h323Callbacks.openLogicalChannels) + ooOpenLogicalChannels(call); + else + gH323ep.h323Callbacks.openLogicalChannels(call); + } +#endif + } + else + OOTRACEDBGC1("Not opening logical channels as Cap exchange " + "remaining\n"); + break; + default: + OOTRACEWARN3("Warn:Unhandled Master Slave message received - %s - " + "%s\n", call->callType, call->callToken); + } + return OO_OK; +} + +int ooSendMasterSlaveDetermination(OOH323CallData *call) +{ + int ret; + H245Message* ph245msg=NULL; + H245RequestMessage *request; + OOCTXT *pctxt=&gH323ep.msgctxt; + H245MasterSlaveDetermination* pMasterSlave; + + /* Check whether Master Slave Determination already in progress */ + if(call->masterSlaveState != OO_MasterSlave_Idle) + { + OOTRACEINFO3("MasterSlave determination already in progress (%s, %s)\n", + call->callType, call->callToken); + return OO_OK; + } + + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_request); + if(ret != OO_OK) + { + OOTRACEERR3("Error: creating H245 message - MasterSlave Determination " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOMasterSlaveDetermination; + request = ph245msg->h245Msg.u.request; + request->t = T_H245RequestMessage_masterSlaveDetermination; + request->u.masterSlaveDetermination = (H245MasterSlaveDetermination*) + ASN1MALLOC(pctxt, sizeof(H245MasterSlaveDetermination)); + + + pMasterSlave = request->u.masterSlaveDetermination; + memset(pMasterSlave, 0, sizeof(H245MasterSlaveDetermination)); + pMasterSlave->terminalType = gH323ep.termType; + pMasterSlave->statusDeterminationNumber = + ooGenerateStatusDeterminationNumber(); + call->statusDeterminationNumber = pMasterSlave->statusDeterminationNumber; + + OOTRACEDBGA3("Built MasterSlave Determination (%s, %s)\n", call->callType, + call->callToken); + ret = ooSendH245Msg(call, ph245msg); + + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue MasterSlaveDetermination message to" + " outbound queue. (%s, %s)\n", call->callType, + call->callToken); + } + else + call->masterSlaveState = OO_MasterSlave_DetermineSent; + + ooFreeH245Message(call, ph245msg); + + return ret; +} + +int ooSendMasterSlaveDeterminationAck(OOH323CallData* call, + char * status) +{ + int ret=0; + H245ResponseMessage * response=NULL; + H245Message *ph245msg=NULL; + OOCTXT *pctxt=&gH323ep.msgctxt; + + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_response); + if(ret != OO_OK) + { + OOTRACEERR3("Error:H245 message creation failed for - MasterSlave " + "Determination Ack (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOMasterSlaveAck; + response = ph245msg->h245Msg.u.response; + memset(response, 0, sizeof(H245ResponseMessage)); + response->t = T_H245ResponseMessage_masterSlaveDeterminationAck; + response->u.masterSlaveDeterminationAck = (H245MasterSlaveDeterminationAck*) + ASN1MALLOC(pctxt, sizeof(H245MasterSlaveDeterminationAck)); + memset(response->u.masterSlaveDeterminationAck, 0, + sizeof(H245MasterSlaveDeterminationAck)); + if(!strcmp("master", status)) + response->u.masterSlaveDeterminationAck->decision.t = + T_H245MasterSlaveDeterminationAck_decision_master; + else + response->u.masterSlaveDeterminationAck->decision.t = + T_H245MasterSlaveDeterminationAck_decision_slave; + + OOTRACEDBGA3("Built MasterSlave determination Ack (%s, %s)\n", + call->callType, call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue MasterSlaveDeterminationAck message" + " to outbound queue. (%s, %s)\n", call->callType, + call->callToken); + } + + ooFreeH245Message(call, ph245msg); + return ret; +} + +int ooSendMasterSlaveDeterminationReject (OOH323CallData* call) +{ + int ret=0; + H245ResponseMessage* response=NULL; + H245Message *ph245msg=NULL; + OOCTXT *pctxt=&gH323ep.msgctxt; + + ret = ooCreateH245Message + (&ph245msg, T_H245MultimediaSystemControlMessage_response); + + if (ret != OO_OK) { + OOTRACEERR3("Error:H245 message creation failed for - MasterSlave " + "Determination Reject (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOMasterSlaveReject; + response = ph245msg->h245Msg.u.response; + + response->t = T_H245ResponseMessage_masterSlaveDeterminationReject; + + response->u.masterSlaveDeterminationReject = + (H245MasterSlaveDeterminationReject*) + memAlloc (pctxt, sizeof(H245MasterSlaveDeterminationReject)); + + response->u.masterSlaveDeterminationReject->cause.t = + T_H245MasterSlaveDeterminationReject_cause_identicalNumbers; + + OOTRACEDBGA3 ("Built MasterSlave determination reject (%s, %s)\n", + call->callType, call->callToken); + + ret = ooSendH245Msg (call, ph245msg); + + if (ret != OO_OK) { + OOTRACEERR3 + ("Error:Failed to enqueue MasterSlaveDeterminationReject " + "message to outbound queue.(%s, %s)\n", call->callType, + call->callToken); + } + + ooFreeH245Message (call, ph245msg); + + return ret; +} + +int ooSendMasterSlaveDeterminationRelease(OOH323CallData * call) +{ + int ret=0; + H245IndicationMessage* indication=NULL; + H245Message *ph245msg=NULL; + OOCTXT *pctxt=&gH323ep.msgctxt; + + ret = ooCreateH245Message + (&ph245msg, T_H245MultimediaSystemControlMessage_indication); + + if (ret != OO_OK) { + OOTRACEERR3("Error:H245 message creation failed for - MasterSlave " + "Determination Release (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOMasterSlaveRelease; + indication = ph245msg->h245Msg.u.indication; + + indication->t = T_H245IndicationMessage_masterSlaveDeterminationRelease; + + indication->u.masterSlaveDeterminationRelease = + (H245MasterSlaveDeterminationRelease*) + memAlloc (pctxt, sizeof(H245MasterSlaveDeterminationRelease)); + + if(!indication->u.masterSlaveDeterminationRelease) + { + OOTRACEERR3("Error: Failed to allocate memory for MSDRelease message." + " (%s, %s)\n", call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + OOTRACEDBGA3 ("Built MasterSlave determination Release (%s, %s)\n", + call->callType, call->callToken); + + ret = ooSendH245Msg (call, ph245msg); + + if (ret != OO_OK) { + OOTRACEERR3 + ("Error:Failed to enqueue MasterSlaveDeterminationRelease " + "message to outbound queue.(%s, %s)\n", call->callType, + call->callToken); + } + + ooFreeH245Message (call, ph245msg); + return ret; +} + +int ooHandleMasterSlaveReject + (OOH323CallData *call, H245MasterSlaveDeterminationReject* reject) +{ + if(call->msdRetries < DEFAULT_MAX_RETRIES) + { + call->msdRetries++; + OOTRACEDBGA3("Retrying MasterSlaveDetermination. (%s, %s)\n", + call->callType, call->callToken); + call->masterSlaveState = OO_MasterSlave_Idle; + ooSendMasterSlaveDetermination(call); + return OO_OK; + } + OOTRACEERR3("Error:Failed to complete MasterSlaveDetermination - " + "Ending call. (%s, %s)\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_OK; +} + + +int ooHandleOpenLogicalChannel(OOH323CallData* call, + H245OpenLogicalChannel *olc) +{ + + H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp = + &(olc->forwardLogicalChannelParameters); + +#if 0 + if(!call->logicalChans) + ooOpenLogicalChannels(call); +#endif + + /* Check whether channel type is supported. Only supported channel + type for now is g711ulaw audio channel. + */ + switch(flcp->dataType.t) + { + case T_H245DataType_nonStandard: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_nonStandard' not supported (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_nullData: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_nullData' not supported (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_videoData: + case T_H245DataType_audioData: + ooHandleOpenLogicalChannel_helper(call, olc); + break; + case T_H245DataType_data: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_data' not supported (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_encryptionData: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_encryptionData' not supported (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_h235Control: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_h235Control' not supported (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_h235Media: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_h235Media' not supported (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_multiplexedStream: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_multiplexedStream' not supported(%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_redundancyEncoding: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_redundancyEncoding' not supported (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_multiplePayloadStream: + OOTRACEWARN3("Warn:Media channel data type " + "'T_H245DataType_multiplePayloadStream' not supported (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + case T_H245DataType_fec: + OOTRACEWARN3("Warn:Media channel data type 'T_H245DataType_fec' not " + "supported (%s, %s)\n", call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + break; + default: + OOTRACEERR3("ERROR:Unknown media channel data type (%s, %s)\n", + call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + } + + return OO_OK; +} + +/*TODO: Need to clean logical channel in case of failure after creating one */ +int ooHandleOpenLogicalChannel_helper(OOH323CallData *call, + H245OpenLogicalChannel*olc) +{ + int ret=0; + H245Message *ph245msg=NULL; + H245ResponseMessage *response; + H245OpenLogicalChannelAck *olcAck; + ooH323EpCapability *epCap=NULL; + H245H2250LogicalChannelAckParameters *h2250lcap=NULL; + OOCTXT *pctxt; + H245UnicastAddress *unicastAddrs, *unicastAddrs1; + H245UnicastAddress_iPAddress *iPAddress, *iPAddress1; + ooLogicalChannel *pLogicalChannel = NULL; + H245H2250LogicalChannelParameters *h2250lcp=NULL; + H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp = + &(olc->forwardLogicalChannelParameters); + + if(!flcp || flcp->multiplexParameters.t != T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters) + { + OOTRACEERR3("Error:ooHandleOpenLogicalChannel_helper - invalid forward " + "logical channel parameters. (%s, %s)\n", call->callType, + call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_unspecified); + return OO_FAILED; + } + + h2250lcp = flcp->multiplexParameters.u.h2250LogicalChannelParameters; + + if(!(epCap=ooIsDataTypeSupported(call, &flcp->dataType, OORX))) + { + OOTRACEERR3("ERROR:HandleOpenLogicalChannel_helper - capability not " + "supported (%s, %s)\n", call->callType, call->callToken); + ooSendOpenLogicalChannelReject(call, olc->forwardLogicalChannelNumber, + T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported); + return OO_FAILED; + } + /* Generate an Ack for the open channel request */ + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_response); + if(ret != OO_OK) + { + OOTRACEERR3("Error: H245 message creation failed for - " + "OpenLogicalChannel Ack (%s, %s)\n", call->callType, + call->callToken); + memFreePtr(call->pctxt, epCap); + epCap = NULL; + return OO_FAILED; + } + + ph245msg->msgType = OOOpenLogicalChannelAck; + ph245msg->logicalChannelNo = olc->forwardLogicalChannelNumber; + response = ph245msg->h245Msg.u.response; + pctxt = &gH323ep.msgctxt; + memset(response, 0, sizeof(H245ResponseMessage)); + response->t = T_H245ResponseMessage_openLogicalChannelAck; + response->u.openLogicalChannelAck = (H245OpenLogicalChannelAck*) + memAlloc(pctxt, sizeof(H245OpenLogicalChannelAck)); + olcAck = response->u.openLogicalChannelAck; + memset(olcAck, 0, sizeof(H245OpenLogicalChannelAck)); + olcAck->forwardLogicalChannelNumber = olc->forwardLogicalChannelNumber; + + olcAck->m.forwardMultiplexAckParametersPresent = 1; + olcAck->forwardMultiplexAckParameters.t = + T_H245OpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters; + olcAck->forwardMultiplexAckParameters.u.h2250LogicalChannelAckParameters = + (H245H2250LogicalChannelAckParameters*)ASN1MALLOC(pctxt, + sizeof(H245H2250LogicalChannelAckParameters)); + h2250lcap = + olcAck->forwardMultiplexAckParameters.u.h2250LogicalChannelAckParameters; + memset(h2250lcap, 0, sizeof(H245H2250LogicalChannelAckParameters)); + + h2250lcap->m.mediaChannelPresent = 1; + h2250lcap->m.mediaControlChannelPresent = 1; + h2250lcap->m.sessionIDPresent = 1; + + if(h2250lcp->sessionID == 0) + h2250lcap->sessionID = ooCallGenerateSessionID(call, epCap->capType, "receive"); + else + h2250lcap->sessionID = h2250lcp->sessionID; + + h2250lcap->mediaChannel.t = + T_H245TransportAddress_unicastAddress; + h2250lcap->mediaChannel.u.unicastAddress = (H245UnicastAddress*) + ASN1MALLOC(pctxt, sizeof(H245UnicastAddress)); + + unicastAddrs = h2250lcap->mediaChannel.u.unicastAddress; + memset(unicastAddrs, 0, sizeof(H245UnicastAddress)); + unicastAddrs->t = T_H245UnicastAddress_iPAddress; + unicastAddrs->u.iPAddress = (H245UnicastAddress_iPAddress*) + memAlloc(pctxt, sizeof(H245UnicastAddress_iPAddress)); + iPAddress = unicastAddrs->u.iPAddress; + memset(iPAddress, 0, sizeof(H245UnicastAddress_iPAddress)); + + pLogicalChannel = ooAddNewLogicalChannel(call, + olc->forwardLogicalChannelNumber, h2250lcap->sessionID, + "receive", epCap); + if(!pLogicalChannel) + { + OOTRACEERR3("ERROR:Failed to add new logical channel entry to call " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ooSocketConvertIpToNwAddr(call->localIP, iPAddress->network.data); + + iPAddress->network.numocts = 4; + iPAddress->tsapIdentifier = pLogicalChannel->localRtpPort; + + /* media contrcol channel */ + h2250lcap->mediaControlChannel.t = + T_H245TransportAddress_unicastAddress; + h2250lcap->mediaControlChannel.u.unicastAddress = (H245UnicastAddress*) + ASN1MALLOC(pctxt, sizeof(H245UnicastAddress)); + + unicastAddrs1 = h2250lcap->mediaControlChannel.u.unicastAddress; + memset(unicastAddrs1, 0, sizeof(H245UnicastAddress)); + unicastAddrs1->t = T_H245UnicastAddress_iPAddress; + unicastAddrs1->u.iPAddress = (H245UnicastAddress_iPAddress*) + memAlloc(pctxt, sizeof(H245UnicastAddress_iPAddress)); + iPAddress1 = unicastAddrs1->u.iPAddress; + memset(iPAddress1, 0, sizeof(H245UnicastAddress_iPAddress)); + + ooSocketConvertIpToNwAddr(call->localIP, iPAddress1->network.data); + + iPAddress1->network.numocts = 4; + iPAddress1->tsapIdentifier = pLogicalChannel->localRtcpPort; + + OOTRACEDBGA3("Built OpenLogicalChannelAck (%s, %s)\n", call->callType, + call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue OpenLogicalChannelAck message to " + "outbound queue. (%s, %s)\n", call->callType, + call->callToken); + } + ooFreeH245Message(call, ph245msg); + + + if(epCap->startReceiveChannel) + { + epCap->startReceiveChannel(call, pLogicalChannel); + OOTRACEINFO6("Receive channel of type %s started at %s:%d(%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->localIP, + pLogicalChannel->localRtpPort, call->callType, + call->callToken); + } + else{ + OOTRACEERR3("ERROR:No callback registered to start receive audio " + "channel (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + pLogicalChannel->state = OO_LOGICALCHAN_ESTABLISHED; + return ret; +} + +int ooSendOpenLogicalChannelReject + (OOH323CallData *call, ASN1UINT channelNum, ASN1UINT cause) +{ + int ret=0; + H245ResponseMessage* response=NULL; + H245Message *ph245msg=NULL; + OOCTXT *pctxt=&gH323ep.msgctxt; + + ret = ooCreateH245Message + (&ph245msg, T_H245MultimediaSystemControlMessage_response); + + if (ret != OO_OK) { + OOTRACEERR3("Error:H245 message creation failed for - OpenLogicalChannel" + "Reject (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOOpenLogicalChannelReject; + response = ph245msg->h245Msg.u.response; + + response->t = T_H245ResponseMessage_openLogicalChannelReject; + + response->u.openLogicalChannelReject = + (H245OpenLogicalChannelReject*) + memAlloc (pctxt, sizeof(H245OpenLogicalChannelReject)); + + if(!response->u.openLogicalChannelReject) + { + OOTRACEERR3("Error: Failed to allocate memory for OpenLogicalChannel" + "Reject message. (%s, %s)\n", call->callType, + call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + response->u.openLogicalChannelReject->forwardLogicalChannelNumber = + channelNum; + response->u.openLogicalChannelReject->cause.t = cause; + + OOTRACEDBGA3 ("Built OpenLogicalChannelReject (%s, %s)\n", + call->callType, call->callToken); + + ret = ooSendH245Msg (call, ph245msg); + + if (ret != OO_OK) { + OOTRACEERR3 + ("Error:Failed to enqueue OpenLogicalChannelReject " + "message to outbound queue.(%s, %s)\n", call->callType, + call->callToken); + } + + ooFreeH245Message (call, ph245msg); + + return ret; +} + + +int ooOnReceivedOpenLogicalChannelAck(OOH323CallData *call, + H245OpenLogicalChannelAck *olcAck) +{ + char remoteip[20]; + ooLogicalChannel *pLogicalChannel; + H245H2250LogicalChannelAckParameters *h2250lcap; + H245UnicastAddress *unicastAddr; + H245UnicastAddress_iPAddress *iPAddress; + H245UnicastAddress *unicastAddr1; + H245UnicastAddress_iPAddress *iPAddress1; + + if(!((olcAck->m.forwardMultiplexAckParametersPresent == 1) && + (olcAck->forwardMultiplexAckParameters.t == + T_H245OpenLogicalChannelAck_forwardMultiplexAckParameters_h2250LogicalChannelAckParameters))) + { + OOTRACEERR3("Error: Processing open logical channel ack - LogicalChannel" + "Ack parameters absent (%s, %s)\n", call->callType, + call->callToken); + return OO_OK; /* should send CloseLogicalChannel request */ + } + + h2250lcap = + olcAck->forwardMultiplexAckParameters.u.h2250LogicalChannelAckParameters; + /* Extract media channel address */ + if(h2250lcap->m.mediaChannelPresent != 1) + { + OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media channel " + "absent (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + if(h2250lcap->mediaChannel.t != T_H245TransportAddress_unicastAddress) + { + OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media channel " + "address type is not unicast (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + + unicastAddr = h2250lcap->mediaChannel.u.unicastAddress; + if(unicastAddr->t != T_H245UnicastAddress_iPAddress) + { + OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media channel " + "address type is not IP (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + iPAddress = unicastAddr->u.iPAddress; + + sprintf(remoteip,"%d.%d.%d.%d", iPAddress->network.data[0], + iPAddress->network.data[1], + iPAddress->network.data[2], + iPAddress->network.data[3]); + + /* Extract media control channel address */ + if(h2250lcap->m.mediaControlChannelPresent != 1) + { + OOTRACEERR3("Error: Processing OpenLogicalChannelAck - Missing media " + "control channel (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + if(h2250lcap->mediaControlChannel.t != + T_H245TransportAddress_unicastAddress) + { + OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media control " + "channel addres type is not unicast (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + unicastAddr1 = h2250lcap->mediaControlChannel.u.unicastAddress; + if(unicastAddr1->t != T_H245UnicastAddress_iPAddress) + { + OOTRACEERR3("Error: Processing OpenLogicalChannelAck - media control " + "channel address type is not IP (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + iPAddress1 = unicastAddr1->u.iPAddress; + + /* Set remote destination address for rtp session */ + // strcpy(call->remoteIP, remoteip); + + /* Start channel here */ + pLogicalChannel = ooFindLogicalChannelByLogicalChannelNo(call,olcAck->forwardLogicalChannelNumber); + if(!pLogicalChannel) + { + OOTRACEERR4("ERROR:Logical channel %d not found in the channel list for " + "call (%s, %s)\n", olcAck->forwardLogicalChannelNumber, + call->callType, call->callToken); + return OO_FAILED; + } + + /* Update session id if we were waiting for remote to assign one and remote + did assign one. */ + if(pLogicalChannel->sessionID == 0 && h2250lcap->m.sessionIDPresent) + pLogicalChannel->sessionID = h2250lcap->sessionID; + + /* Populate ports &ip for channel */ + strcpy(pLogicalChannel->remoteIP, remoteip); + pLogicalChannel->remoteMediaPort = iPAddress->tsapIdentifier; + pLogicalChannel->remoteMediaControlPort = iPAddress1->tsapIdentifier; + + if(pLogicalChannel->chanCap->startTransmitChannel) + { + pLogicalChannel->chanCap->startTransmitChannel(call, pLogicalChannel); + OOTRACEINFO4("TransmitLogical Channel of type %s started (%s, %s)\n", + ooGetCapTypeText(pLogicalChannel->chanCap->cap), + call->callType, call->callToken); + } + else{ + OOTRACEERR3("ERROR:No callback registered for starting transmit channel " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + pLogicalChannel->state = OO_LOGICALCHAN_ESTABLISHED; + return OO_OK; +} + +int ooOnReceivedOpenLogicalChannelRejected(OOH323CallData *call, + H245OpenLogicalChannelReject *olcReject) +{ + switch(olcReject->cause.t) + { + case T_H245OpenLogicalChannelReject_cause_unspecified: + OOTRACEINFO4("Open logical channel %d rejected - unspecified (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, call->callType, + call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_unsuitableReverseParameters: + OOTRACEINFO4("Open logical channel %d rejected - " + "unsuitableReverseParameters (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, call->callType, + call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_dataTypeNotSupported: + OOTRACEINFO4("Open logical channel %d rejected - dataTypeNotSupported" + "(%s, %s)\n", olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_dataTypeNotAvailable: + OOTRACEINFO4("Open logical channel %d rejected - dataTypeNotAvailable" + "(%s, %s)\n", olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_unknownDataType: + OOTRACEINFO4("Open logical channel %d rejected - unknownDataType" + "(%s, %s)\n", olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_dataTypeALCombinationNotSupported: + OOTRACEINFO4("Open logical channel %d rejected - " + "dataTypeALCombinationNotSupported(%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_multicastChannelNotAllowed: + OOTRACEINFO4("Open logical channel %d rejected - " + "multicastChannelNotAllowed (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_insufficientBandwidth: + OOTRACEINFO4("Open logical channel %d rejected - insufficientBandwidth" + "(%s, %s)\n", olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_separateStackEstablishmentFailed: + OOTRACEINFO4("Open logical channel %d rejected - " + "separateStackEstablishmentFailed (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_invalidSessionID: + OOTRACEINFO4("Open logical channel %d rejected - " + "invalidSessionID (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_masterSlaveConflict: + OOTRACEINFO4("Open logical channel %d rejected - " + "invalidSessionID (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_waitForCommunicationMode: + OOTRACEINFO4("Open logical channel %d rejected - " + "waitForCommunicationMode (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_invalidDependentChannel: + OOTRACEINFO4("Open logical channel %d rejected - " + "invalidDependentChannel (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + case T_H245OpenLogicalChannelReject_cause_replacementForRejected: + OOTRACEINFO4("Open logical channel %d rejected - " + "replacementForRejected (%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + break; + default: + OOTRACEERR4("Error: OpenLogicalChannel %d rejected - " + "invalid cause(%s, %s)\n", + olcReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + } + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_LOCAL_CLEARED; + } + return OO_OK; +} + +/** + * Currently only disconnect end session command is supported. + **/ +int ooSendEndSessionCommand(OOH323CallData *call) +{ + int ret; + H245CommandMessage * command; + OOCTXT *pctxt; + H245Message *ph245msg=NULL; + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_command); + if(ret != OO_OK) + { + OOTRACEERR3("Error: H245 message creation failed for - End Session " + "Command (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOEndSessionCommand; + + command = ph245msg->h245Msg.u.command; + pctxt = &gH323ep.msgctxt; + memset(command, 0, sizeof(H245CommandMessage)); + command->t = T_H245CommandMessage_endSessionCommand; + command->u.endSessionCommand = (H245EndSessionCommand*) ASN1MALLOC(pctxt, + sizeof(H245EndSessionCommand)); + memset(command->u.endSessionCommand, 0, sizeof(H245EndSessionCommand)); + command->u.endSessionCommand->t = T_H245EndSessionCommand_disconnect; + OOTRACEDBGA3("Built EndSession Command (%s, %s)\n", call->callType, + call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue EndSession message to outbound " + "queue.(%s, %s)\n", call->callType, call->callToken); + } + ooFreeH245Message(call, ph245msg); + return ret; +} + + +int ooHandleH245Command(OOH323CallData *call, + H245CommandMessage *command) +{ + ASN1UINT i; + DListNode *pNode = NULL; + OOTimer *pTimer = NULL; + OOTRACEDBGC3("Handling H.245 command message. (%s, %s)\n", call->callType, + call->callToken); + switch(command->t) + { + case T_H245CommandMessage_endSessionCommand: + OOTRACEINFO3("Received EndSession command (%s, %s)\n", + call->callType, call->callToken); + if(call->h245SessionState == OO_H245SESSION_ENDSENT) + { + /* Disable Session timer */ + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if(((ooTimerCallback*)pTimer->cbData)->timerType & + OO_SESSION_TIMER) + { + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted Session Timer. (%s, %s)\n", + call->callType, call->callToken); + break; + } + } + ooCloseH245Connection(call); + } + else{ + + call->h245SessionState = OO_H245SESSION_ENDRECVD; +#if 0 + if(call->callState < OO_CALL_CLEAR) + call->callState = OO_CALL_CLEAR; +#else + if(call->logicalChans) + { + OOTRACEINFO3("In response to received EndSessionCommand - " + "Clearing all logical channels. (%s, %s)\n", + call->callType, call->callToken); + ooClearAllLogicalChannels(call); + } + ooSendEndSessionCommand(call); +#endif + } + + + break; + case T_H245CommandMessage_sendTerminalCapabilitySet: + OOTRACEWARN3("Warning: Received command Send terminal capability set " + "- Not handled (%s, %s)\n", call->callType, + call->callToken); + break; + case T_H245CommandMessage_flowControlCommand: + OOTRACEWARN3("Warning: Flow control command received - Not handled " + "(%s, %s)\n", call->callType, call->callToken); + break; + default: + OOTRACEWARN3("Warning: Unhandled H245 command message received " + "(%s, %s)\n", call->callType, call->callToken); + } + OOTRACEDBGC3("Handling H.245 command message done. (%s, %s)\n", + call->callType, call->callToken); + return OO_OK; +} + + +int ooOnReceivedTerminalCapabilitySetAck(OOH323CallData* call) +{ + call->localTermCapState = OO_LocalTermCapSetAckRecvd; + if(call->remoteTermCapState != OO_RemoteTermCapSetAckSent) + return OO_OK; + + if(call->masterSlaveState == OO_MasterSlave_Master || + call->masterSlaveState == OO_MasterSlave_Slave) + { + if(gH323ep.h323Callbacks.openLogicalChannels) + gH323ep.h323Callbacks.openLogicalChannels(call); + else{ + if(!call->logicalChans) + ooOpenLogicalChannels(call); + } +#if 0 + if(!call->logicalChans){ + if(!gH323ep.h323Callbacks.openLogicalChannels) + ooOpenLogicalChannels(call); + else + gH323ep.h323Callbacks.openLogicalChannels(call); + } +#endif + } + + return OO_OK; +} + +int ooCloseAllLogicalChannels(OOH323CallData *call) +{ + ooLogicalChannel *temp; + + temp = call->logicalChans; + while(temp) + { + if(temp->state == OO_LOGICALCHAN_ESTABLISHED) + { + /* Sending closelogicalchannel only for outgoing channels*/ + if(!strcmp(temp->dir, "transmit")) + { + ooSendCloseLogicalChannel(call, temp); + } + else{ + ooSendRequestCloseLogicalChannel(call, temp); + } + } + temp = temp->next; + } + return OO_OK; +} + +int ooSendCloseLogicalChannel(OOH323CallData *call, ooLogicalChannel *logicalChan) +{ + int ret = OO_OK, error=0; + H245Message *ph245msg = NULL; + OOCTXT *pctxt; + H245RequestMessage *request; + H245CloseLogicalChannel* clc; + + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_request); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to create H245 message for closeLogicalChannel" + " message (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOCloseLogicalChannel; + ph245msg->logicalChannelNo = logicalChan->channelNo; + pctxt = &gH323ep.msgctxt; + request = ph245msg->h245Msg.u.request; + + request->t = T_H245RequestMessage_closeLogicalChannel; + request->u.closeLogicalChannel = (H245CloseLogicalChannel*)ASN1MALLOC(pctxt, + sizeof(H245CloseLogicalChannel)); + if(!request->u.closeLogicalChannel) + { + OOTRACEERR3("ERROR:Memory allocation for CloseLogicalChannel failed " + "(%s, %s)\n", call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + clc = request->u.closeLogicalChannel; + memset(clc, 0, sizeof(H245CloseLogicalChannel)); + + clc->forwardLogicalChannelNumber = logicalChan->channelNo; + clc->source.t = T_H245CloseLogicalChannel_source_lcse; + clc->m.reasonPresent = 1; + clc->reason.t = T_H245CloseLogicalChannel_reason_unknown; + + OOTRACEDBGA4("Built close logical channel for %d (%s, %s)\n", + logicalChan->channelNo, call->callType, call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue CloseLogicalChannel to outbound queue.(%s, %s)\n", call->callType, + call->callToken); + error++; + } + ooFreeH245Message(call, ph245msg); + + /* Stop the media transmission */ + OOTRACEINFO4("Closing logical channel %d (%s, %s)\n", + clc->forwardLogicalChannelNumber, call->callType, + call->callToken); + ret = ooClearLogicalChannel(call, clc->forwardLogicalChannelNumber); + if(ret != OO_OK) + { + OOTRACEERR4("ERROR:Failed to close logical channel %d (%s, %s)\n", + clc->forwardLogicalChannelNumber, call->callType, call->callToken); + return OO_FAILED; + } + if(error) return OO_FAILED; + return ret; +} + +/*TODO: Need to pass reason as a parameter */ +int ooSendRequestCloseLogicalChannel(OOH323CallData *call, + ooLogicalChannel *logicalChan) +{ + int ret = OO_OK; + H245Message *ph245msg = NULL; + OOCTXT *pctxt; + H245RequestMessage *request; + H245RequestChannelClose *rclc; + + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_request); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to create H245 message for " + "requestCloseLogicalChannel message (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OORequestChannelClose; + ph245msg->logicalChannelNo = logicalChan->channelNo; + pctxt = &gH323ep.msgctxt; + request = ph245msg->h245Msg.u.request; + + request->t = T_H245RequestMessage_requestChannelClose; + request->u.requestChannelClose = (H245RequestChannelClose*)ASN1MALLOC(pctxt, + sizeof(H245RequestChannelClose)); + if(!request->u.requestChannelClose) + { + OOTRACEERR3("ERROR:Memory allocation for RequestCloseLogicalChannel " + " failed (%s, %s)\n", call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + + rclc = request->u.requestChannelClose; + memset(rclc, 0, sizeof(H245RequestChannelClose)); + rclc->forwardLogicalChannelNumber = logicalChan->channelNo; + + rclc->m.reasonPresent = 1; + rclc->reason.t = T_H245RequestChannelClose_reason_unknown; + + OOTRACEDBGA4("Built RequestCloseChannel for %d (%s, %s)\n", + logicalChan->channelNo, call->callType, call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue the RequestCloseChannel to outbound" + " queue (%s, %s)\n", call->callType, + call->callToken); + } + ooFreeH245Message(call, ph245msg); + + return ret; +} + +int ooSendRequestChannelCloseRelease(OOH323CallData *call, int channelNum) +{ + int ret = OO_OK; + H245Message *ph245msg = NULL; + OOCTXT *pctxt; + H245IndicationMessage *indication; + + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_indication); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to create H245 message for " + "RequestChannelCloseRelease message (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OORequestChannelCloseRelease; + ph245msg->logicalChannelNo = channelNum; + pctxt = &gH323ep.msgctxt; + indication = ph245msg->h245Msg.u.indication; + indication->t = T_H245IndicationMessage_requestChannelCloseRelease; + indication->u.requestChannelCloseRelease = (H245RequestChannelCloseRelease*) + ASN1MALLOC(pctxt, sizeof(H245RequestChannelCloseRelease)); + if(!indication->u.requestChannelCloseRelease) + { + OOTRACEERR3("Error:Failed to allocate memory for " + "RequestChannelCloseRelease message. (%s, %s)\n", + call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + } + + indication->u.requestChannelCloseRelease->forwardLogicalChannelNumber = + channelNum; + + OOTRACEDBGA4("Built RequestChannelCloseRelease for %d (%s, %s)\n", + channelNum, call->callType, call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue the RequestChannelCloseRelease to " + "outbound queue (%s, %s)\n", call->callType, call->callToken); + } + ooFreeH245Message(call, ph245msg); + + return ret; +} + + + +int ooOnReceivedRequestChannelClose(OOH323CallData *call, + H245RequestChannelClose *rclc) +{ + int ret=0, error=0; + H245Message *ph245msg=NULL; + H245ResponseMessage *response = NULL; + OOCTXT *pctxt=NULL; + H245RequestChannelCloseAck *rclcAck; + ooLogicalChannel * lChannel=NULL; + /* Send Ack: TODO: Need to send reject, if doesn't exist + */ + lChannel = ooFindLogicalChannelByLogicalChannelNo(call, + rclc->forwardLogicalChannelNumber); + if(!lChannel) + { + OOTRACEERR4("ERROR:Channel %d requested to be closed not found " + "(%s, %s)\n", rclc->forwardLogicalChannelNumber, + call->callType, call->callToken); + return OO_FAILED; + } + else{ + if(strcmp(lChannel->dir, "transmit")) + { + OOTRACEERR4("ERROR:Channel %d requested to be closed, Not a forward " + "channel (%s, %s)\n", rclc->forwardLogicalChannelNumber, + call->callType, call->callToken); + return OO_FAILED; + } + } + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_response); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Memory allocation for RequestChannelCloseAck message " + "failed (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + pctxt = &gH323ep.msgctxt; + ph245msg->msgType = OORequestChannelCloseAck; + ph245msg->logicalChannelNo = rclc->forwardLogicalChannelNumber; + response = ph245msg->h245Msg.u.response; + response->t = T_H245ResponseMessage_requestChannelCloseAck; + response->u.requestChannelCloseAck = (H245RequestChannelCloseAck*)ASN1MALLOC + (pctxt, sizeof(H245RequestChannelCloseAck)); + if(!response->u.requestChannelCloseAck) + { + OOTRACEERR3("ERROR:Failed to allocate memory for RequestChannelCloseAck " + "message (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + rclcAck = response->u.requestChannelCloseAck; + memset(rclcAck, 0, sizeof(H245RequestChannelCloseAck)); + rclcAck->forwardLogicalChannelNumber = rclc->forwardLogicalChannelNumber; + + OOTRACEDBGA3("Built RequestCloseChannelAck message (%s, %s)\n", + call->callType, call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue RequestCloseChannelAck to outbound queue. (%s, %s)\n", call->callType, + call->callToken); + error++; + } + + ooFreeH245Message(call, ph245msg); + + /* Send Close Logical Channel*/ + ret = ooSendCloseLogicalChannel(call, lChannel); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to build CloseLgicalChannel message(%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + if(error) return OO_FAILED; + + return ret; +} + +/* + We clear channel here. Ideally the remote endpoint should send + CloseLogicalChannel and then the channel should be cleared. But there's no + timer for this and if remote endpoint misbehaves, the call will keep waiting + for CloseLogicalChannel and hence, wouldn't be cleared. In case when remote + endpoint sends CloseLogicalChannel, we call ooClearLogicalChannel again, + which simply returns OO_OK as channel was already cleared. Other option is + to start a timer for call cleanup and if call is not cleaned up within + timeout, we clean call forcefully. Note, no such timer is defined in + standards. +*/ +int ooOnReceivedRequestChannelCloseAck + (OOH323CallData *call, H245RequestChannelCloseAck *rccAck) +{ + int ret=OO_OK; + /* Remote endpoint is ok to close channel. So let's do it */ + ret = ooClearLogicalChannel(call, rccAck->forwardLogicalChannelNumber); + if(ret != OO_OK) + { + OOTRACEERR4("Error:Failed to clear logical channel %d. (%s, %s)\n", + rccAck->forwardLogicalChannelNumber, call->callType, + call->callToken); + } + + return ret; +} + +int ooOnReceivedRequestChannelCloseReject + (OOH323CallData *call, H245RequestChannelCloseReject *rccReject) +{ + int ret =0; + switch(rccReject->cause.t) + { + case T_H245RequestChannelCloseReject_cause_unspecified: + OOTRACEDBGA4("Remote endpoint has rejected request to close logical " + "channel %d - cause unspecified. (%s, %s)\n", + rccReject->forwardLogicalChannelNumber, call->callType, + call->callToken); + break; + case T_H245RequestChannelCloseReject_cause_extElem1: + OOTRACEDBGA4("Remote endpoint has rejected request to close logical " + "channel %d - cause propriatory. (%s, %s)\n", + rccReject->forwardLogicalChannelNumber, call->callType, + call->callToken); + break; + default: + OOTRACEDBGA4("Remote endpoint has rejected request to close logical " + "channel %d - cause INVALID. (%s, %s)\n", + rccReject->forwardLogicalChannelNumber, call->callType, + call->callToken); + } + OOTRACEDBGA4("Clearing logical channel %d. (%s, %s)\n", + rccReject->forwardLogicalChannelNumber, call->callType, + call->callToken); + ret = ooClearLogicalChannel(call, rccReject->forwardLogicalChannelNumber); + if(ret != OO_OK) + { + OOTRACEERR4("Error: failed to clear logical channel %d.(%s, %s)\n", + rccReject->forwardLogicalChannelNumber, call->callType, + call->callToken); + } + return ret; +} + +/****/ +int ooOnReceivedCloseLogicalChannel(OOH323CallData *call, + H245CloseLogicalChannel* clc) +{ + int ret=0; + H245Message *ph245msg = NULL; + OOCTXT *pctxt = NULL; + H245CloseLogicalChannelAck * clcAck; + H245ResponseMessage *response; + + OOTRACEINFO4("Closing logical channel number %d (%s, %s)\n", + clc->forwardLogicalChannelNumber, call->callType, call->callToken); + + ret = ooClearLogicalChannel(call, clc->forwardLogicalChannelNumber); + if(ret != OO_OK) + { + OOTRACEERR4("ERROR:Failed to close logical channel %d (%s, %s)\n", + clc->forwardLogicalChannelNumber, call->callType, call->callToken); + return OO_FAILED; + } + + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_response); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to create H245 message for " + "closeLogicalChannelAck (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + pctxt = &gH323ep.msgctxt; + ph245msg->msgType = OOCloseLogicalChannelAck; + ph245msg->logicalChannelNo = clc->forwardLogicalChannelNumber; + response = ph245msg->h245Msg.u.response; + response->t = T_H245ResponseMessage_closeLogicalChannelAck; + response->u.closeLogicalChannelAck = (H245CloseLogicalChannelAck*) + ASN1MALLOC(pctxt, sizeof(H245CloseLogicalChannelAck)); + clcAck = response->u.closeLogicalChannelAck; + if(!clcAck) + { + OOTRACEERR3("ERROR:Failed to allocate memory for closeLogicalChannelAck " + "(%s, %s)\n", call->callType, call->callToken); + return OO_OK; + } + memset(clcAck, 0, sizeof(H245CloseLogicalChannelAck)); + clcAck->forwardLogicalChannelNumber = clc->forwardLogicalChannelNumber; + + OOTRACEDBGA3("Built CloseLogicalChannelAck message (%s, %s)\n", + call->callType, call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue CloseLogicalChannelAck message to " + "outbound queue.(%s, %s)\n", call->callType, call->callToken); + } + + ooFreeH245Message(call, ph245msg); + return ret; +} + +int ooOnReceivedCloseChannelAck(OOH323CallData* call, + H245CloseLogicalChannelAck* clcAck) +{ + int ret = OO_OK; + return ret; +} + +int ooHandleH245Message(OOH323CallData *call, H245Message * pmsg) +{ + ASN1UINT i; + DListNode *pNode = NULL; + OOTimer *pTimer = NULL; + H245Message *pH245 = (H245Message*)pmsg; + /* There are four major types of H.245 messages that can be received. + Request/Response/Command/Indication. Each one of them need to be + handled separately. + */ + H245RequestMessage *request = NULL; + H245ResponseMessage *response = NULL; + H245CommandMessage *command = NULL; + H245IndicationMessage *indication = NULL; + + OOTRACEDBGC3("Handling H245 message. (%s, %s)\n", call->callType, + call->callToken); + + switch(pH245->h245Msg.t) + { + /* H.245 Request message is received */ + case (T_H245MultimediaSystemControlMessage_request): + request = pH245->h245Msg.u.request; + switch(request->t) + { + case T_H245RequestMessage_terminalCapabilitySet: + /* If session isn't marked active yet, do it. possible in case of + tunneling */ + if(call->h245SessionState == OO_H245SESSION_IDLE) + call->h245SessionState = OO_H245SESSION_ACTIVE; + + ooOnReceivedTerminalCapabilitySet(call, pH245); + if(call->localTermCapState == OO_LocalTermCapExchange_Idle) + ooSendTermCapMsg(call); + break; + case T_H245RequestMessage_masterSlaveDetermination: + ooHandleMasterSlave(call, + request->u.masterSlaveDetermination, + OOMasterSlaveDetermination); + break; + case T_H245RequestMessage_openLogicalChannel: + ooHandleOpenLogicalChannel(call, + request->u.openLogicalChannel); + break; + case T_H245RequestMessage_closeLogicalChannel: + OOTRACEINFO4("Received close logical Channel - %d (%s, %s)\n", + request->u.closeLogicalChannel->forwardLogicalChannelNumber, + call->callType, call->callToken); + ooOnReceivedCloseLogicalChannel(call, + request->u.closeLogicalChannel); + break; + case T_H245RequestMessage_requestChannelClose: + OOTRACEINFO4("Received RequestChannelClose - %d (%s, %s)\n", + request->u.requestChannelClose->forwardLogicalChannelNumber, + call->callType, call->callToken); + ooOnReceivedRequestChannelClose(call, + request->u.requestChannelClose); + break; + default: + ; + } /* End of Request Message */ + break; + /* H.245 Response message is received */ + case (T_H245MultimediaSystemControlMessage_response): + response = pH245->h245Msg.u.response; + switch(response->t) + { + case T_H245ResponseMessage_masterSlaveDeterminationAck: + /* Disable MSD timer */ + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if(((ooTimerCallback*)pTimer->cbData)->timerType & OO_MSD_TIMER) + { + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted MSD Timer. (%s, %s)\n", call->callType, + call->callToken); + break; + } + } + + ooHandleMasterSlave(call, + response->u.masterSlaveDeterminationAck, + OOMasterSlaveAck); + break; + case T_H245ResponseMessage_masterSlaveDeterminationReject: + /* Disable MSD timer */ + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if(((ooTimerCallback*)pTimer->cbData)->timerType & OO_MSD_TIMER) + { + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted MSD Timer. (%s, %s)\n", call->callType, + call->callToken); + break; + } + } + ooHandleMasterSlaveReject(call, + response->u.masterSlaveDeterminationReject); + break; + case T_H245ResponseMessage_terminalCapabilitySetAck: + /* Disable TCS timer */ + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if(((ooTimerCallback*)pTimer->cbData)->timerType & OO_TCS_TIMER) + { + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted TCS Timer. (%s, %s)\n", call->callType, + call->callToken); + break; + } + } + ooOnReceivedTerminalCapabilitySetAck(call); + break; + case T_H245ResponseMessage_terminalCapabilitySetReject: + OOTRACEINFO3("TerminalCapabilitySetReject message received." + " (%s, %s)\n", call->callType, call->callToken); + if(response->u.terminalCapabilitySetReject->sequenceNumber != + call->localTermCapSeqNo) + { + OOTRACEINFO5("Ignoring TCSReject with mismatched seqno %d " + "(local - %d). (%s, %s)\n", + response->u.terminalCapabilitySetReject->sequenceNumber, + call->localTermCapSeqNo, call->callType, call->callToken); + break; + } + /* Disable TCS timer */ + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if(((ooTimerCallback*)pTimer->cbData)->timerType & OO_TCS_TIMER) + { + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted TCS Timer. (%s, %s)\n", call->callType, + call->callToken); + break; + } + } + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_NOCOMMON_CAPABILITIES; + } + break; + case T_H245ResponseMessage_openLogicalChannelAck: + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_OLC_TIMER) && + ((ooTimerCallback*)pTimer->cbData)->channelNumber == + response->u.openLogicalChannelAck->forwardLogicalChannelNumber) + { + + memFreePtr(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted OpenLogicalChannel Timer. (%s, %s)\n", + call->callType, call->callToken); + break; + } + } + ooOnReceivedOpenLogicalChannelAck(call, + response->u.openLogicalChannelAck); + break; + case T_H245ResponseMessage_openLogicalChannelReject: + OOTRACEINFO3("Open Logical Channel Reject received (%s, %s)\n", + call->callType, call->callToken); + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_OLC_TIMER) && + ((ooTimerCallback*)pTimer->cbData)->channelNumber == + response->u.openLogicalChannelAck->forwardLogicalChannelNumber) + { + + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted OpenLogicalChannel Timer. (%s, %s)\n", + call->callType, call->callToken); + break; + } + } + ooOnReceivedOpenLogicalChannelRejected(call, + response->u.openLogicalChannelReject); + break; + case T_H245ResponseMessage_closeLogicalChannelAck: + OOTRACEINFO4("CloseLogicalChannelAck received for %d (%s, %s)\n", + response->u.closeLogicalChannelAck->forwardLogicalChannelNumber, + call->callType, call->callToken); + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_CLC_TIMER) && + ((ooTimerCallback*)pTimer->cbData)->channelNumber == + response->u.closeLogicalChannelAck->forwardLogicalChannelNumber) + { + + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted CloseLogicalChannel Timer. (%s, %s)\n", + call->callType, call->callToken); + break; + } + } + ooOnReceivedCloseChannelAck(call, + response->u.closeLogicalChannelAck); + break; + case T_H245ResponseMessage_requestChannelCloseAck: + OOTRACEINFO4("RequestChannelCloseAck received - %d (%s, %s)\n", + response->u.requestChannelCloseAck->forwardLogicalChannelNumber, + call->callType, call->callToken); + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_RCC_TIMER) && + ((ooTimerCallback*)pTimer->cbData)->channelNumber == + response->u.requestChannelCloseAck->forwardLogicalChannelNumber) + { + + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted RequestChannelClose Timer. (%s, %s)\n", + call->callType, call->callToken); + break; + } + } + ooOnReceivedRequestChannelCloseAck(call, + response->u.requestChannelCloseAck); + break; + case T_H245ResponseMessage_requestChannelCloseReject: + OOTRACEINFO4("RequestChannelCloseReject received - %d (%s, %s)\n", + response->u.requestChannelCloseReject->forwardLogicalChannelNumber, + call->callType, call->callToken); + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if((((ooTimerCallback*)pTimer->cbData)->timerType & OO_RCC_TIMER) && + ((ooTimerCallback*)pTimer->cbData)->channelNumber == + response->u.requestChannelCloseReject->forwardLogicalChannelNumber) + { + + ASN1MEMFREEPTR(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted RequestChannelClose Timer. (%s, %s)\n", + call->callType, call->callToken); + break; + } + } + ooOnReceivedRequestChannelCloseReject(call, + response->u.requestChannelCloseReject); + break; + default: + ; + } + break; + /* H.245 command message is received */ + case (T_H245MultimediaSystemControlMessage_command): + command = pH245->h245Msg.u.command; + ooHandleH245Command(call, command); + break; + /* H.245 Indication message received */ + case (T_H245MultimediaSystemControlMessage_indication): + indication = pH245->h245Msg.u.indication; + switch(indication->t) + { + case T_H245IndicationMessage_userInput: + ooOnReceivedUserInputIndication(call, indication->u.userInput); + break; + default: + OOTRACEWARN3("Unhandled indication message received.(%s, %s)\n", + call->callType, call->callToken); + } + break; + default: + ; + } + OOTRACEDBGC3("Finished handling H245 message. (%s, %s)\n", + call->callType, call->callToken); + return OO_OK; +} + + +int ooOnReceivedUserInputIndication + (OOH323CallData *call, H245UserInputIndication *indication) +{ + if((indication->t == T_H245UserInputIndication_alphanumeric) && + (call->dtmfmode & OO_CAP_DTMF_H245_alphanumeric)) + { + if(gH323ep.h323Callbacks.onReceivedDTMF) + gH323ep.h323Callbacks.onReceivedDTMF(call,indication->u.alphanumeric); + } + else if((indication->t == T_H245UserInputIndication_signal) && + (call->dtmfmode & OO_CAP_DTMF_H245_signal)) { + if(gH323ep.h323Callbacks.onReceivedDTMF) + gH323ep.h323Callbacks.onReceivedDTMF(call, + indication->u.signal->signalType); + } + else { + OOTRACEINFO3("Unsupported userInput message type received - ignoring." + "(%s, %s)\n", call->callType, call->callToken); + } + return OO_OK; +} + +int ooOnReceivedTerminalCapabilitySet(OOH323CallData *call, H245Message *pmsg) +{ + int ret = 0,k; + H245TerminalCapabilitySet *tcs=NULL; + DListNode *pNode=NULL; + H245CapabilityTableEntry *capEntry = NULL; + + tcs = pmsg->h245Msg.u.request->u.terminalCapabilitySet; + if(call->remoteTermCapSeqNo >= tcs->sequenceNumber) + { + OOTRACEINFO4("Rejecting TermCapSet message with SeqNo %d, as already " + "acknowledged message with this SeqNo (%s, %s)\n", + call->remoteTermCapSeqNo, call->callType, call->callToken); + ooSendTerminalCapabilitySetReject(call, tcs->sequenceNumber, + T_H245TerminalCapabilitySetReject_cause_unspecified); + return OO_OK; + } + + if(!tcs->m.capabilityTablePresent) + { + // OOTRACEWARN3("Warn:Ignoring TCS as no capability table present(%s, %s)\n", + OOTRACEWARN3("Empty TCS found. Pausing call...(%s, %s)\n", + call->callType, call->callToken); + call->h245SessionState = OO_H245SESSION_PAUSED; + //ooSendTerminalCapabilitySetReject(call, tcs->sequenceNumber, + // T_H245TerminalCapabilitySetReject_cause_unspecified); + //return OO_OK; + } + call->remoteTermCapSeqNo = tcs->sequenceNumber; + + if(tcs->m.capabilityTablePresent) { + for(k=0; k<(int)tcs->capabilityTable.count; k++) + { + pNode = dListFindByIndex(&tcs->capabilityTable, k); + if(pNode) + { + OOTRACEDBGC4("Processing CapabilityTable Entry %d (%s, %s)\n", + k, call->callType, call->callToken); + capEntry = (H245CapabilityTableEntry*) pNode->data; + if(capEntry->m.capabilityPresent){ + ret = ooAddRemoteCapability(call, &capEntry->capability); + if(ret != OO_OK) + { + OOTRACEERR4("Error:Failed to process remote capability in " + "capability table at index %d. (%s, %s)\n", + k, call->callType, call->callToken); + } + ooCapabilityUpdateJointCapabilities(call, &capEntry->capability); + } + } + pNode = NULL; + capEntry=NULL; + } + } + + + /* Update remoteTermCapSetState */ + call->remoteTermCapState = OO_RemoteTermCapSetRecvd; + + ooH245AcknowledgeTerminalCapabilitySet(call); + + /* If we haven't yet send TCS then send it now */ + if(call->localTermCapState == OO_LocalTermCapExchange_Idle) + { + ret = ooSendTermCapMsg(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n", + call->callType, call->callToken); + return ret; + } + } + + if(call->remoteTermCapState != OO_RemoteTermCapSetAckSent || + call->localTermCapState != OO_LocalTermCapSetAckRecvd) + return OO_OK; + + /* Check MasterSlave procedure has finished */ + if(call->masterSlaveState != OO_MasterSlave_Master && + call->masterSlaveState != OO_MasterSlave_Slave) + return OO_OK; + + /* As both MasterSlave and TerminalCapabilitySet procedures have finished, + OpenLogicalChannels */ + + if(gH323ep.h323Callbacks.openLogicalChannels) + gH323ep.h323Callbacks.openLogicalChannels(call); + else{ + if(!call->logicalChans) + ooOpenLogicalChannels(call); + } +#if 0 + if(!call->logicalChans){ + if(!gH323ep.h323Callbacks.openLogicalChannels) + ret = ooOpenLogicalChannels(call); + else + gH323ep.h323Callbacks.openLogicalChannels(call); + } +#endif + return OO_OK; +} + +int ooSendTerminalCapabilitySetReject + (OOH323CallData *call, int seqNo, ASN1UINT cause) +{ + H245Message *ph245msg=NULL; + H245ResponseMessage * response=NULL; + OOCTXT *pctxt=NULL; + int ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_response); + if(ret != OO_OK) + { + OOTRACEERR1("ERROR:H245 message creation failed for - " + "TerminalCapabilitySetReject\n"); + return OO_FAILED; + } + ph245msg->msgType = OOTerminalCapabilitySetReject; + response = ph245msg->h245Msg.u.response; + memset(response, 0, sizeof(H245ResponseMessage)); + pctxt = &gH323ep.msgctxt; + response->t = T_H245ResponseMessage_terminalCapabilitySetReject; + + response->u.terminalCapabilitySetReject = (H245TerminalCapabilitySetReject*) + ASN1MALLOC(pctxt, sizeof(H245TerminalCapabilitySetReject)); + + memset(response->u.terminalCapabilitySetReject, 0, + sizeof(H245TerminalCapabilitySetReject)); + response->u.terminalCapabilitySetReject->sequenceNumber = seqNo; + response->u.terminalCapabilitySetReject->cause.t = cause; + + OOTRACEDBGA3("Built TerminalCapabilitySetReject (%s, %s)\n", + call->callType, call->callToken); + + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue TCSReject to outbound queue. " + "(%s, %s)\n", call->callType, call->callToken); + } + else + call->remoteTermCapState = OO_RemoteTermCapExchange_Idle; + + ooFreeH245Message(call, ph245msg); + return ret; +} + +int ooH245AcknowledgeTerminalCapabilitySet(OOH323CallData *call) +{ + H245Message *ph245msg=NULL; + H245ResponseMessage * response=NULL; + OOCTXT *pctxt=NULL; + int ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_response); + if(ret != OO_OK) + { + OOTRACEERR1("ERROR:H245 message creation failed for - " + "TerminalCapability Set Ack\n"); + return OO_FAILED; + } + ph245msg->msgType = OOTerminalCapabilitySetAck; + response = ph245msg->h245Msg.u.response; + memset(response, 0, sizeof(H245ResponseMessage)); + pctxt = &gH323ep.msgctxt; + response->t = T_H245ResponseMessage_terminalCapabilitySetAck; + + response->u.terminalCapabilitySetAck = (H245TerminalCapabilitySetAck*) + ASN1MALLOC(pctxt, sizeof(H245TerminalCapabilitySetAck)); + + memset(response->u.terminalCapabilitySetAck, 0, + sizeof(H245TerminalCapabilitySetAck)); + response->u.terminalCapabilitySetAck->sequenceNumber = call->remoteTermCapSeqNo; + + OOTRACEDBGA3("Built TerminalCapabilitySet Ack (%s, %s)\n", + call->callType, call->callToken); + ret = ooSendH245Msg(call, ph245msg); + + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue TCSAck to outbound queue. (%s, %s)\n", call->callType, call->callToken); + } + else + call->remoteTermCapState = OO_RemoteTermCapSetAckSent; + + ooFreeH245Message(call, ph245msg); + return ret; +} + + +int ooSendTerminalCapabilitySetRelease(OOH323CallData * call) +{ + int ret=0; + H245IndicationMessage* indication=NULL; + H245Message *ph245msg=NULL; + OOCTXT *pctxt=&gH323ep.msgctxt; + + ret = ooCreateH245Message + (&ph245msg, T_H245MultimediaSystemControlMessage_indication); + + if (ret != OO_OK) { + OOTRACEERR3("Error:H245 message creation failed for - Terminal" + "CapabilitySetRelease (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOTerminalCapabilitySetRelease; + indication = ph245msg->h245Msg.u.indication; + + indication->t = T_H245IndicationMessage_terminalCapabilitySetRelease; + + indication->u.terminalCapabilitySetRelease = + (H245TerminalCapabilitySetRelease*) + memAlloc (pctxt, sizeof(H245TerminalCapabilitySetRelease)); + + if(!indication->u.terminalCapabilitySetRelease) + { + OOTRACEERR3("Error: Failed to allocate memory for TCSRelease message." + " (%s, %s)\n", call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + OOTRACEDBGA3 ("Built TerminalCapabilitySetRelease (%s, %s)\n", + call->callType, call->callToken); + + ret = ooSendH245Msg (call, ph245msg); + + if (ret != OO_OK) { + OOTRACEERR3 + ("Error:Failed to enqueue TerminalCapabilitySetRelease " + "message to outbound queue.(%s, %s)\n", call->callType, + call->callToken); + } + + ooFreeH245Message (call, ph245msg); + return ret; +} + + +int ooSendH245UserInputIndication_alphanumeric + (OOH323CallData *call, const char *data) +{ + int ret=0; + H245IndicationMessage* indication=NULL; + H245Message *ph245msg=NULL; + OOCTXT *pctxt=&gH323ep.msgctxt; + + ret = ooCreateH245Message + (&ph245msg, T_H245MultimediaSystemControlMessage_indication); + + if (ret != OO_OK) { + OOTRACEERR3("Error:H245 message creation failed for - H245UserInput" + "Indication_alphanumeric (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOUserInputIndication; + indication = ph245msg->h245Msg.u.indication; + + indication->t = T_H245IndicationMessage_userInput; + indication->u.userInput = + (H245UserInputIndication*) + memAllocZ (pctxt, sizeof(H245UserInputIndication)); + + if(!indication->u.userInput) + { + OOTRACEERR3("Error: Memory - ooH245UserInputIndication_alphanumeric - " + " userInput (%s, %s)\n", call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + indication->u.userInput->t = T_H245UserInputIndication_alphanumeric; + indication->u.userInput->u.alphanumeric = (ASN1GeneralString) + memAlloc(pctxt, strlen(data)+1); + if(!indication->u.userInput->u.alphanumeric) + { + OOTRACEERR3("Error: Memory - ooH245UserInputIndication-alphanumeric - " + "alphanumeric (%s, %s).\n", call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + strcpy((char*)indication->u.userInput->u.alphanumeric, data); + OOTRACEDBGA3 ("Built UserInputIndication_alphanumeric (%s, %s)\n", + call->callType, call->callToken); + + ret = ooSendH245Msg (call, ph245msg); + + if (ret != OO_OK) { + OOTRACEERR3 + ("Error:Failed to enqueue UserInputIndication_alphanumeric " + "message to outbound queue.(%s, %s)\n", call->callType, + call->callToken); + } + + ooFreeH245Message (call, ph245msg); + return ret; +} + +int ooSendH245UserInputIndication_signal + (OOH323CallData *call, const char *data) +{ + int ret=0; + H245IndicationMessage* indication=NULL; + H245Message *ph245msg=NULL; + OOCTXT *pctxt=&gH323ep.msgctxt; + + ret = ooCreateH245Message + (&ph245msg, T_H245MultimediaSystemControlMessage_indication); + + if (ret != OO_OK) { + OOTRACEERR3("Error:H245 message creation failed for - H245UserInput" + "Indication_signal (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + ph245msg->msgType = OOUserInputIndication; + indication = ph245msg->h245Msg.u.indication; + + indication->t = T_H245IndicationMessage_userInput; + indication->u.userInput = + (H245UserInputIndication*) + memAllocZ (pctxt, sizeof(H245UserInputIndication)); + + if(!indication->u.userInput) + { + OOTRACEERR3("Error: Memory - ooH245UserInputIndication_signal - " + " userInput (%s, %s)\n", call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + indication->u.userInput->t = T_H245UserInputIndication_signal; + indication->u.userInput->u.signal = (H245UserInputIndication_signal*) + memAllocZ(pctxt, sizeof(H245UserInputIndication_signal)); + indication->u.userInput->u.signal->signalType = (ASN1IA5String) + memAlloc(pctxt, strlen(data)+1); + if(!indication->u.userInput->u.signal || + !indication->u.userInput->u.signal->signalType) + { + OOTRACEERR3("Error: Memory - ooH245UserInputIndication_signal - " + "signal (%s, %s).\n", call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + strcpy((char*)indication->u.userInput->u.signal->signalType, data); + OOTRACEDBGA3 ("Built UserInputIndication_signal (%s, %s)\n", + call->callType, call->callToken); + + ret = ooSendH245Msg (call, ph245msg); + + if (ret != OO_OK) { + OOTRACEERR3 + ("Error:Failed to enqueue UserInputIndication_signal " + "message to outbound queue.(%s, %s)\n", call->callType, + call->callToken); + } + + ooFreeH245Message (call, ph245msg); + return ret; +} + + +int ooOpenLogicalChannels(OOH323CallData *call) +{ + int ret=0; + OOTRACEINFO3("Opening logical channels (%s, %s)\n", call->callType, + call->callToken); + + /* Audio channels */ + if(gH323ep.callMode == OO_CALLMODE_AUDIOCALL || + gH323ep.callMode == OO_CALLMODE_AUDIOTX) + { + //if (!OO_TESTFLAG (call->flags, OO_M_AUDIOSESSION)) + //{ + ret = ooOpenLogicalChannel(call, OO_CAP_TYPE_AUDIO); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to open audio channels. Clearing call." + "(%s, %s)\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return ret; + } + // } + } + + if(gH323ep.callMode == OO_CALLMODE_VIDEOCALL) + { + /* if (!OO_TESTFLAG (call->flags, OO_M_AUDIOSESSION)) + {*/ + ret = ooOpenLogicalChannel(call, OO_CAP_TYPE_AUDIO); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to open audio channel. Clearing call." + "(%s, %s)\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return ret; + } + //} + /* if(!OO_TESTFLAG(call->flags, OO_M_VIDEOSESSION)) + {*/ + ret = ooOpenLogicalChannel(call, OO_CAP_TYPE_VIDEO); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to open video channel. Clearing call." + "(%s, %s)\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return ret; + } + //} + } + return OO_OK; +} + +/* CapType indicates whether to Open Audio or Video channel */ +int ooOpenLogicalChannel(OOH323CallData *call, enum OOCapType capType ) +{ + ooH323EpCapability *epCap=NULL; + int k=0; + + /* Check whether local endpoint has audio capability */ + if(gH323ep.myCaps == 0 && call->ourCaps == 0) + { + OOTRACEERR3("ERROR:Local endpoint does not have any audio capabilities" + " (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + /* Go through local endpoints capabilities sequentially, and find out the + first one which has a match in the remote endpoints receive capabilities. + */ + OOTRACEINFO3("Looking for matching capabilities. (%s, %s)\n", + call->callType, call->callToken); + if(call->masterSlaveState == OO_MasterSlave_Master) + { + for(k=0; kcapPrefs.index; k++) + { + /*Search for audio caps only */ + if(capType == OO_CAP_TYPE_AUDIO && + call->capPrefs.order[k] > OO_CAP_VIDEO_BASE) + continue; + /* Search for video caps only */ + if(capType == OO_CAP_TYPE_VIDEO && + call->capPrefs.order[k] <= OO_CAP_VIDEO_BASE) + continue; + + epCap = call->jointCaps; + + while(epCap){ + if(epCap->cap == call->capPrefs.order[k] && (epCap->dir & OOTX)) + break; + epCap = epCap->next; + } + if(!epCap) + { + OOTRACEDBGA4("Prefereed capability %d is not a local transmit " + "capability(%s, %s)\n", call->capPrefs.order[k], + call->callType, call->callToken); + continue; + } + break; + } + if(!epCap) + { + OOTRACEERR4("ERROR:Incompatible capabilities - Can not open " + "%s channel (%s, %s)\n", + (capType==OO_CAP_TYPE_AUDIO)?"audio":"video", call->callType, + call->callToken); + return OO_FAILED; + } + + } + else if(call->masterSlaveState == OO_MasterSlave_Slave) + { + epCap = call->jointCaps; + + while(epCap){ + if(epCap->capType == capType && epCap->dir & OOTX) { break; } + epCap = epCap->next; + } + if(!epCap) + { + OOTRACEERR4("ERROR:Incompatible audio capabilities - Can not open " + "%s channel (%s, %s)\n", + (capType==OO_CAP_TYPE_AUDIO)?"audio":"video", call->callType, + call->callToken); + return OO_FAILED; + } + + } + + switch(epCap->cap) + { + case OO_G711ALAW64K: + case OO_G711ALAW56K: + case OO_G711ULAW64K: + case OO_G711ULAW56K: + /*case OO_G726:*/ + case OO_G728: + case OO_G729: + case OO_G729A: + case OO_G7231: + case OO_GSMFULLRATE: + case OO_H263VIDEO: + ooOpenChannel(call, epCap); + break; + case OO_GSMHALFRATE: + case OO_GSMENHANCEDFULLRATE: + + + default: + OOTRACEERR3("ERROR:Unknown Audio Capability type (%s, %s)\n", + call->callType, call->callToken); + } + return OO_OK; +} + +int ooOpenChannel(OOH323CallData* call, ooH323EpCapability *epCap) +{ + int ret; + H245Message *ph245msg = NULL; + H245RequestMessage * request; + OOCTXT *pctxt = NULL; + H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp = NULL; + H245AudioCapability *audioCap = NULL; + H245VideoCapability *videoCap = NULL; + H245H2250LogicalChannelParameters *h2250lcp = NULL; + H245UnicastAddress *unicastAddrs = NULL; + H245UnicastAddress_iPAddress *iPAddress = NULL; + unsigned session_id=0; + ooLogicalChannel *pLogicalChannel = NULL; + + OOTRACEDBGC4("Doing Open Channel for %s. (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + + ret = ooCreateH245Message(&ph245msg, + T_H245MultimediaSystemControlMessage_request); + if(ret != OO_OK) + { + OOTRACEERR4("Error: H245 message creation failed for - Open %s" + "channel (%s, %s)\n", ooGetCapTypeText(epCap->cap), + call->callType, call->callToken); + return OO_FAILED; + } + + ph245msg->msgType = OOOpenLogicalChannel; + + ph245msg->logicalChannelNo = call->logicalChanNoCur++; + if(call->logicalChanNoCur > call->logicalChanNoMax) + call->logicalChanNoCur = call->logicalChanNoBase; + + request = ph245msg->h245Msg.u.request; + pctxt = &gH323ep.msgctxt; + memset(request, 0, sizeof(H245RequestMessage)); + + request->t = T_H245RequestMessage_openLogicalChannel; + request->u.openLogicalChannel = (H245OpenLogicalChannel*) + memAlloc(pctxt, sizeof(H245OpenLogicalChannel)); + if(!request->u.openLogicalChannel) + { + OOTRACEERR3("Error:Memory - ooOpenChannel - openLogicalChannel." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + + } + memset(request->u.openLogicalChannel, 0, + sizeof(H245OpenLogicalChannel)); + request->u.openLogicalChannel->forwardLogicalChannelNumber = + ph245msg->logicalChannelNo; + + + session_id = ooCallGenerateSessionID(call, epCap->capType, "transmit"); + + + pLogicalChannel = ooAddNewLogicalChannel(call, + request->u.openLogicalChannel->forwardLogicalChannelNumber, + session_id, "transmit", epCap); + + if(!pLogicalChannel) + { + OOTRACEERR3("ERROR:Failed to add new logical channel entry (%s, %s)\n", + call->callType, call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + /* Populate H245OpenLogicalChannel_ForwardLogicalChannel Parameters*/ + flcp = &(request->u.openLogicalChannel->forwardLogicalChannelParameters); + flcp->m.portNumberPresent = 0; + flcp->m.forwardLogicalChannelDependencyPresent = 0; + flcp->m.replacementForPresent = 0; + + /* data type of channel */ + if(epCap->capType == OO_CAP_TYPE_AUDIO) + { + flcp->dataType.t = T_H245DataType_audioData; + /* set audio capability for channel */ + audioCap = ooCapabilityCreateAudioCapability(epCap,pctxt, OOTX); + if(!audioCap) + { + OOTRACEERR4("Error:Failed to create duplicate audio capability in " + "ooOpenChannel- %s (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + + flcp->dataType.u.audioData = audioCap; + } + else if(epCap->capType == OO_CAP_TYPE_VIDEO) + { + flcp->dataType.t = T_H245DataType_videoData; + videoCap = ooCapabilityCreateVideoCapability(epCap, pctxt, OOTX); + if(!videoCap) + { + OOTRACEERR4("Error:Failed to create duplicate video capability in " + "ooOpenChannel- %s (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + ooFreeH245Message(call, ph245msg); + return OO_FAILED; + } + + flcp->dataType.u.videoData = videoCap; + } + else{ + OOTRACEERR1("Error: Unhandled media type in ooOpenChannel\n"); + return OO_FAILED; + } + + + flcp->multiplexParameters.t = + T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters; + flcp->multiplexParameters.u.h2250LogicalChannelParameters = + (H245H2250LogicalChannelParameters*)ASN1MALLOC(pctxt, + sizeof(H245H2250LogicalChannelParameters)); + + h2250lcp = flcp->multiplexParameters.u.h2250LogicalChannelParameters; + memset(h2250lcp, 0, sizeof(H245H2250LogicalChannelParameters)); + + h2250lcp->sessionID = session_id; + + h2250lcp->mediaGuaranteedDelivery = 0; + h2250lcp->silenceSuppression = 0; + h2250lcp->m.mediaControlChannelPresent = 1; + + h2250lcp->mediaControlChannel.t = + T_H245TransportAddress_unicastAddress; + h2250lcp->mediaControlChannel.u.unicastAddress = (H245UnicastAddress*) + ASN1MALLOC(pctxt, sizeof(H245UnicastAddress)); + + unicastAddrs = h2250lcp->mediaControlChannel.u.unicastAddress; + memset(unicastAddrs, 0, sizeof(H245UnicastAddress)); + unicastAddrs->t = T_H245UnicastAddress_iPAddress; + unicastAddrs->u.iPAddress = (H245UnicastAddress_iPAddress*) + ASN1MALLOC(pctxt, sizeof(H245UnicastAddress_iPAddress)); + iPAddress = unicastAddrs->u.iPAddress; + memset(iPAddress, 0, sizeof(H245UnicastAddress_iPAddress)); + + ooSocketConvertIpToNwAddr(pLogicalChannel->localIP,iPAddress->network.data); + + iPAddress->network.numocts = 4; + iPAddress->tsapIdentifier = pLogicalChannel->localRtcpPort; + pLogicalChannel->state = OO_LOGICALCHAN_PROPOSED; + OOTRACEDBGA4("Built OpenLogicalChannel-%s (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + ret = ooSendH245Msg(call, ph245msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue OpenLogicalChannel to outbound " + "queue. (%s, %s)\n", call->callType, + call->callToken); + } + ooFreeH245Message(call, ph245msg); + + return ret; +} + + +/* Used to build OLCs for fast connect. Keep in mind that forward and + reverse + are always with respect to the endpoint which proposes channels + TODO: Need to clean logical channel in case of failure. */ +int ooBuildFastStartOLC + (OOH323CallData *call, H245OpenLogicalChannel *olc, + ooH323EpCapability *epCap, OOCTXT*pctxt, int dir) +{ + OOBOOL reverse=FALSE, forward=FALSE; + unsigned sessionID=0; + H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp=NULL; + H245OpenLogicalChannel_reverseLogicalChannelParameters *rlcp=NULL; + H245H2250LogicalChannelParameters *pH2250lcp1=NULL, *pH2250lcp2=NULL; + H245UnicastAddress *pUnicastAddrs=NULL, *pUniAddrs=NULL; + H245UnicastAddress_iPAddress *pIpAddrs=NULL, *pUniIpAddrs=NULL; + unsigned session_id = 0; + ooLogicalChannel *pLogicalChannel = NULL; + int outgoing=FALSE; + + if(!strcmp(call->callType, "outgoing")) + outgoing = TRUE; + + if(dir & OORX) + { + OOTRACEDBGA3("Building OpenLogicalChannel for Receive Capability " + "(%s, %s)\n", call->callType, call->callToken); + session_id = ooCallGenerateSessionID(call, epCap->capType, "receive"); + pLogicalChannel = ooAddNewLogicalChannel(call, + olc->forwardLogicalChannelNumber, session_id, + "receive", epCap); + if(outgoing) + reverse = TRUE; + else + forward = TRUE; + } + else if(dir & OOTX) + { + OOTRACEDBGA3("Building OpenLogicalChannel for transmit Capability " + "(%s, %s)\n", call->callType, call->callToken); + session_id = ooCallGenerateSessionID(call, epCap->capType, "transmit"); + pLogicalChannel = ooAddNewLogicalChannel(call, + olc->forwardLogicalChannelNumber, session_id, + "transmit", epCap); + if(outgoing) + forward = TRUE; + else + reverse = TRUE; + } + else if(dir & OORXTX) + { + OOTRACEDBGA3("Building OpenLogicalChannel for ReceiveAndTransmit " + "Capability (%s, %s)\n", call->callType, call->callToken); + reverse = 1; + forward = 1; + OOTRACEERR3("Symmetric capability is not supported as of now (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + if(forward) + { + OOTRACEDBGC3("Building forward olc. (%s, %s)\n", call->callType, + call->callToken); + flcp = &(olc->forwardLogicalChannelParameters); + memset(flcp, 0, + sizeof(H245OpenLogicalChannel_forwardLogicalChannelParameters)); + + if(epCap->capType == OO_CAP_TYPE_AUDIO) { + sessionID =1; + flcp->dataType.t = T_H245DataType_audioData; + flcp->dataType.u.audioData = ooCapabilityCreateAudioCapability(epCap, + pctxt, dir); + } + else if(epCap->capType == OO_CAP_TYPE_VIDEO) { + sessionID = 2; + flcp->dataType.t = T_H245DataType_videoData; + flcp->dataType.u.videoData = ooCapabilityCreateVideoCapability(epCap, + pctxt, dir); + } + flcp->multiplexParameters.t = T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters; + pH2250lcp1 = (H245H2250LogicalChannelParameters*)ASN1MALLOC(pctxt, + sizeof(H245H2250LogicalChannelParameters)); + memset(pH2250lcp1, 0, sizeof(H245H2250LogicalChannelParameters)); + flcp->multiplexParameters.t = T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters; + + flcp->multiplexParameters.u.h2250LogicalChannelParameters = pH2250lcp1; + + pH2250lcp1->sessionID = sessionID; + if(!outgoing) + { + pH2250lcp1->m.mediaChannelPresent = 1; + pH2250lcp1->mediaChannel.t = + T_H245TransportAddress_unicastAddress; + pUniAddrs = (H245UnicastAddress*) ASN1MALLOC(pctxt, + sizeof(H245UnicastAddress)); + memset(pUniAddrs, 0, sizeof(H245UnicastAddress)); + pH2250lcp1->mediaChannel.u.unicastAddress = pUniAddrs; + pUniAddrs->t = T_H245UnicastAddress_iPAddress; + pUniIpAddrs = (H245UnicastAddress_iPAddress*) ASN1MALLOC(pctxt, + sizeof(H245UnicastAddress_iPAddress)); + memset(pUniIpAddrs, 0, sizeof(H245UnicastAddress_iPAddress)); + pUniAddrs->u.iPAddress = pUniIpAddrs; + + ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, + pUniIpAddrs->network.data); + + pUniIpAddrs->network.numocts = 4; + pUniIpAddrs->tsapIdentifier = pLogicalChannel->localRtpPort; + } + pH2250lcp1->m.mediaControlChannelPresent = 1; + pH2250lcp1->mediaControlChannel.t = + T_H245TransportAddress_unicastAddress; + pUnicastAddrs = (H245UnicastAddress*) ASN1MALLOC(pctxt, + sizeof(H245UnicastAddress)); + memset(pUnicastAddrs, 0, sizeof(H245UnicastAddress)); + pH2250lcp1->mediaControlChannel.u.unicastAddress = pUnicastAddrs; + pUnicastAddrs->t = T_H245UnicastAddress_iPAddress; + pIpAddrs = (H245UnicastAddress_iPAddress*) ASN1MALLOC(pctxt, + sizeof(H245UnicastAddress_iPAddress)); + memset(pIpAddrs, 0, sizeof(H245UnicastAddress_iPAddress)); + pUnicastAddrs->u.iPAddress = pIpAddrs; + + ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, + pIpAddrs->network.data); + + pIpAddrs->network.numocts = 4; + pIpAddrs->tsapIdentifier = pLogicalChannel->localRtcpPort; + if(!outgoing) + { + if(epCap->startReceiveChannel) + { + epCap->startReceiveChannel(call, pLogicalChannel); + OOTRACEINFO4("Receive channel of type %s started (%s, %s)\n", + (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", + call->callType, call->callToken); + } + else{ + OOTRACEERR4("ERROR:No callback registered to start receive %s" + " channel (%s, %s)\n", + (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", + call->callType, call->callToken); + return OO_FAILED; + } + } + } + + if(reverse) + { + OOTRACEDBGC3("Building reverse olc. (%s, %s)\n", call->callType, + call->callToken); + olc->forwardLogicalChannelParameters.dataType.t = + T_H245DataType_nullData; + olc->forwardLogicalChannelParameters.multiplexParameters.t = + T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_none; + olc->m.reverseLogicalChannelParametersPresent = 1; + rlcp = &(olc->reverseLogicalChannelParameters); + memset(rlcp, 0, sizeof(H245OpenLogicalChannel_reverseLogicalChannelParameters)); + if(epCap->capType == OO_CAP_TYPE_AUDIO) { + sessionID = 1; + rlcp->dataType.t = T_H245DataType_audioData; + + rlcp->dataType.u.audioData = ooCapabilityCreateAudioCapability(epCap, + pctxt, dir); + } + else if(epCap->capType == OO_CAP_TYPE_VIDEO) { + sessionID = 2; + rlcp->dataType.t = T_H245DataType_videoData; + + rlcp->dataType.u.videoData = ooCapabilityCreateVideoCapability(epCap, + pctxt, dir); + } + + rlcp->m.multiplexParametersPresent = 1; + rlcp->multiplexParameters.t = T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters; + pH2250lcp2 = (H245H2250LogicalChannelParameters*) ASN1MALLOC(pctxt, sizeof(H245H2250LogicalChannelParameters)); + rlcp->multiplexParameters.u.h2250LogicalChannelParameters = pH2250lcp2; + memset(pH2250lcp2, 0, sizeof(H245H2250LogicalChannelParameters)); + pH2250lcp2->sessionID = sessionID; + + if(outgoing) + { + pH2250lcp2->m.mediaChannelPresent = 1; + + pH2250lcp2->mediaChannel.t = + T_H245TransportAddress_unicastAddress; + pUnicastAddrs = (H245UnicastAddress*) memAlloc(pctxt, + sizeof(H245UnicastAddress)); + memset(pUnicastAddrs, 0, sizeof(H245UnicastAddress)); + pH2250lcp2->mediaChannel.u.unicastAddress = pUnicastAddrs; + + pUnicastAddrs->t = T_H245UnicastAddress_iPAddress; + pIpAddrs = (H245UnicastAddress_iPAddress*) memAlloc(pctxt, + sizeof(H245UnicastAddress_iPAddress)); + memset(pIpAddrs, 0, sizeof(H245UnicastAddress_iPAddress)); + pUnicastAddrs->u.iPAddress = pIpAddrs; + + ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, + pIpAddrs->network.data); + + pIpAddrs->network.numocts = 4; + pIpAddrs->tsapIdentifier = pLogicalChannel->localRtpPort; + } + pH2250lcp2->m.mediaControlChannelPresent = 1; + pH2250lcp2->mediaControlChannel.t = + T_H245TransportAddress_unicastAddress; + pUniAddrs = (H245UnicastAddress*) ASN1MALLOC(pctxt, sizeof(H245UnicastAddress)); + + memset(pUniAddrs, 0, sizeof(H245UnicastAddress)); + pH2250lcp2->mediaControlChannel.u.unicastAddress = pUniAddrs; + + + pUniAddrs->t = T_H245UnicastAddress_iPAddress; + pUniIpAddrs = (H245UnicastAddress_iPAddress*) ASN1MALLOC(pctxt, sizeof(H245UnicastAddress_iPAddress)); + memset(pUniIpAddrs, 0, sizeof(H245UnicastAddress_iPAddress)); + pUniAddrs->u.iPAddress = pUniIpAddrs; + + ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, + pUniIpAddrs->network.data); + pUniIpAddrs->network.numocts = 4; + pUniIpAddrs->tsapIdentifier = pLogicalChannel->localRtcpPort; + + /* + In case of fast start, the local endpoint need to be ready to + receive all the media types proposed in the fast connect, before + the actual call is established. + */ + if(outgoing) + { + if(epCap->startReceiveChannel) + { + epCap->startReceiveChannel(call, pLogicalChannel); + OOTRACEINFO4("Receive channel of type %s started (%s, %s)\n", + (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", + call->callType, call->callToken); + } + else{ + OOTRACEERR4("ERROR:No callback registered to start receive %s " + "channel (%s, %s)\n", + (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", + call->callType, call->callToken); + return OO_FAILED; + } + } + } + + /* State of logical channel. for out going calls, as we are sending setup, + state of all channels are proposed, for incoming calls, state is + established. */ + if(!outgoing) { + pLogicalChannel->state = OO_LOGICALCHAN_ESTABLISHED; + } + else { + /* Calling other ep, with SETUP message */ + /* Call is "outgoing */ + pLogicalChannel->state = OO_LOGICALCHAN_PROPOSED; + } + + return OO_OK; +} + + + +int ooMSDTimerExpired(void *data) +{ + ooTimerCallback *cbData = (ooTimerCallback*)data; + OOH323CallData *call = cbData->call; + OOTRACEINFO3("MasterSlaveDetermination timeout. (%s, %s)\n", call->callType, + call->callToken); + ASN1MEMFREEPTR(call->pctxt, cbData); + ooSendMasterSlaveDeterminationRelease(call); + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_LOCAL_CLEARED; + } + + return OO_OK; +} + +int ooTCSTimerExpired(void *data) +{ + ooTimerCallback *cbData = (ooTimerCallback*)data; + OOH323CallData *call = cbData->call; + OOTRACEINFO3("TerminalCapabilityExchange timeout. (%s, %s)\n", + call->callType, call->callToken); + ASN1MEMFREEPTR(call->pctxt, cbData); + ooSendTerminalCapabilitySetRelease(call); + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_LOCAL_CLEARED; + } + + return OO_OK; +} + +int ooOpenLogicalChannelTimerExpired(void *pdata) +{ + ooTimerCallback *cbData = (ooTimerCallback*)pdata; + OOH323CallData *call = cbData->call; + ooLogicalChannel *pChannel = NULL; + OOTRACEINFO3("OpenLogicalChannelTimer expired. (%s, %s)\n", call->callType, + call->callToken); + pChannel = ooFindLogicalChannelByLogicalChannelNo(call, + cbData->channelNumber); + if(pChannel) + ooSendCloseLogicalChannel(call, pChannel); + + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_LOCAL_CLEARED; + } + ASN1MEMFREEPTR(call->pctxt, cbData); + return OO_OK; +} + +int ooCloseLogicalChannelTimerExpired(void *pdata) +{ + ooTimerCallback *cbData = (ooTimerCallback*)pdata; + OOH323CallData *call = cbData->call; + + OOTRACEINFO3("CloseLogicalChannelTimer expired. (%s, %s)\n", call->callType, + call->callToken); + + ooClearLogicalChannel(call, cbData->channelNumber); + + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_LOCAL_CLEARED; + } + ASN1MEMFREEPTR(call->pctxt, cbData); + return OO_OK; +} + +int ooRequestChannelCloseTimerExpired(void *pdata) +{ + int ret = 0; + ooTimerCallback *cbData = (ooTimerCallback*)pdata; + OOH323CallData *call = cbData->call; + + OOTRACEINFO3("OpenLogicalChannelTimer expired. (%s, %s)\n", call->callType, + call->callToken); + + ooSendRequestChannelCloseRelease(call, cbData->channelNumber); + + ret = ooClearLogicalChannel(call, cbData->channelNumber); + if(ret != OO_OK) + { + OOTRACEERR4("Error:Failed to clear logical channel %d. (%s, %s)\n", + cbData->channelNumber, call->callType, call->callToken); + } + + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_LOCAL_CLEARED; + } + ASN1MEMFREEPTR(call->pctxt, cbData); + return OO_OK; +} + +int ooSessionTimerExpired(void *pdata) +{ + int ret = 0; + ooTimerCallback *cbData = (ooTimerCallback*)pdata; + OOH323CallData *call = cbData->call; + + OOTRACEINFO3("SessionTimer expired. (%s, %s)\n", call->callType, + call->callToken); + + if(call->h245SessionState != OO_H245SESSION_IDLE && + call->h245SessionState != OO_H245SESSION_CLOSED && + call->h245SessionState != OO_H245SESSION_PAUSED) { + + ret = ooCloseH245Connection(call); + + if(ret != OO_OK) { + OOTRACEERR3("Error:Failed to close H.245 connection (%s, %s)\n", + call->callType, call->callToken); + } + } + + memFreePtr(call->pctxt, cbData); + + if(call->callState == OO_CALL_CLEAR_RELEASESENT) + call->callState = OO_CALL_CLEARED; + + return OO_OK; +} + + +int ooGetIpPortFromH245TransportAddress + (OOH323CallData *call, H245TransportAddress *h245Address, char *ip, + int *port) +{ + H245UnicastAddress *unicastAddress = NULL; + H245UnicastAddress_iPAddress *ipAddress = NULL; + + if(h245Address->t != T_H245TransportAddress_unicastAddress) + { + OOTRACEERR3("ERROR:Unsupported H245 address type " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + unicastAddress = h245Address->u.unicastAddress; + if(unicastAddress->t != T_H245UnicastAddress_iPAddress) + { + OOTRACEERR3("ERROR:H245 Address type is not IP" + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ipAddress = unicastAddress->u.iPAddress; + + *port = ipAddress->tsapIdentifier; + + sprintf(ip, "%d.%d.%d.%d", ipAddress->network.data[0], + ipAddress->network.data[1], + ipAddress->network.data[2], + ipAddress->network.data[3]); + return OO_OK; +} + + +int ooPrepareFastStartResponseOLC + (OOH323CallData *call, H245OpenLogicalChannel *olc, + ooH323EpCapability *epCap, OOCTXT*pctxt, int dir) +{ + OOBOOL reverse=FALSE, forward=FALSE; + H245OpenLogicalChannel_forwardLogicalChannelParameters *flcp=NULL; + H245OpenLogicalChannel_reverseLogicalChannelParameters *rlcp=NULL; + H245H2250LogicalChannelParameters *pH2250lcp1=NULL, *pH2250lcp2=NULL; + H245UnicastAddress *pUnicastAddrs=NULL, *pUniAddrs=NULL; + H245UnicastAddress_iPAddress *pIpAddrs=NULL, *pUniIpAddrs=NULL; + unsigned session_id = 0; + ooLogicalChannel *pLogicalChannel = NULL; + + if(dir & OORX) + { + OOTRACEDBGA3("ooPrepareFastStartResponseOLC for Receive Capability " + "(%s, %s)\n", call->callType, call->callToken); + session_id = ooCallGenerateSessionID(call, epCap->capType, "receive"); + pLogicalChannel = ooAddNewLogicalChannel(call, + olc->forwardLogicalChannelNumber, session_id, + "receive", epCap); + forward = TRUE; + } + else if(dir & OOTX) + { + OOTRACEDBGA3("ooPrepareFastStartResponseOLC for transmit Capability " + "(%s, %s)\n", call->callType, call->callToken); + session_id = ooCallGenerateSessionID(call, epCap->capType, "transmit"); + pLogicalChannel = ooAddNewLogicalChannel(call, + olc->forwardLogicalChannelNumber, session_id, + "transmit", epCap); + reverse = TRUE; + } + else if(dir & OORXTX) + { + OOTRACEDBGA3("ooPrepareFastStartResponseOLC for ReceiveAndTransmit " + "Capability (%s, %s)\n", call->callType, call->callToken); + reverse = 1; + forward = 1; + OOTRACEERR3("Symmetric capability is not supported as of now (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + if(forward) + { + OOTRACEDBGC3("Preparing olc for receive channel. (%s, %s)\n", + call->callType, call->callToken); + flcp = &(olc->forwardLogicalChannelParameters); + + pH2250lcp1 = flcp->multiplexParameters.u.h2250LogicalChannelParameters; + + + pH2250lcp1->m.mediaChannelPresent = 1; + pH2250lcp1->mediaChannel.t = T_H245TransportAddress_unicastAddress; + pUniAddrs = (H245UnicastAddress*) memAlloc(pctxt, + sizeof(H245UnicastAddress)); + pUniIpAddrs = (H245UnicastAddress_iPAddress*) memAlloc(pctxt, + sizeof(H245UnicastAddress_iPAddress)); + if(!pUniAddrs || !pUniIpAddrs) + { + OOTRACEERR3("Error:Memory - ooPrepareFastStartResponseOLC - pUniAddrs" + "/pUniIpAddrs (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + + pH2250lcp1->mediaChannel.u.unicastAddress = pUniAddrs; + pUniAddrs->t = T_H245UnicastAddress_iPAddress; + pUniAddrs->u.iPAddress = pUniIpAddrs; + + ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, + pUniIpAddrs->network.data); + + pUniIpAddrs->network.numocts = 4; + pUniIpAddrs->tsapIdentifier = pLogicalChannel->localRtpPort; + + pH2250lcp1->m.mediaControlChannelPresent = 1; + pH2250lcp1->mediaControlChannel.t = + T_H245TransportAddress_unicastAddress; + pUnicastAddrs = (H245UnicastAddress*) memAlloc(pctxt, + sizeof(H245UnicastAddress)); + pIpAddrs = (H245UnicastAddress_iPAddress*) memAlloc(pctxt, + sizeof(H245UnicastAddress_iPAddress)); + if(!pUnicastAddrs || !pIpAddrs) + { + OOTRACEERR3("Error:Memory - ooPrepareFastStartResponseOLC - " + "pUnicastAddrs/pIpAddrs (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + memset(pUnicastAddrs, 0, sizeof(H245UnicastAddress)); + pH2250lcp1->mediaControlChannel.u.unicastAddress = pUnicastAddrs; + pUnicastAddrs->t = T_H245UnicastAddress_iPAddress; + + pUnicastAddrs->u.iPAddress = pIpAddrs; + + ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, + pIpAddrs->network.data); + + pIpAddrs->network.numocts = 4; + pIpAddrs->tsapIdentifier = pLogicalChannel->localRtcpPort; + } + + if(reverse) + { + OOTRACEDBGC3("Building reverse olc. (%s, %s)\n", call->callType, + call->callToken); + + rlcp = &(olc->reverseLogicalChannelParameters); + + pH2250lcp2 = rlcp->multiplexParameters.u.h2250LogicalChannelParameters; + pH2250lcp2->m.mediaChannelPresent = 0; + memset(&pH2250lcp2->mediaChannel, 0, sizeof(H245TransportAddress)); + + pH2250lcp2->m.mediaControlChannelPresent = 1; + pH2250lcp2->mediaControlChannel.t = + T_H245TransportAddress_unicastAddress; + pUniAddrs = (H245UnicastAddress*) memAlloc(pctxt, + sizeof(H245UnicastAddress)); + pUniIpAddrs = (H245UnicastAddress_iPAddress*) memAlloc(pctxt, + sizeof(H245UnicastAddress_iPAddress)); + if(!pUniAddrs || !pUniIpAddrs) + { + OOTRACEERR3("Error:Memory - ooPrepareFastStartResponseOLC - " + "pUniAddrs/pUniIpAddrs (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + + pH2250lcp2->mediaControlChannel.u.unicastAddress = pUniAddrs; + + pUniAddrs->t = T_H245UnicastAddress_iPAddress; + + pUniAddrs->u.iPAddress = pUniIpAddrs; + + ooSocketConvertIpToNwAddr(pLogicalChannel->localIP, + pUniIpAddrs->network.data); + pUniIpAddrs->network.numocts = 4; + pUniIpAddrs->tsapIdentifier = pLogicalChannel->localRtcpPort; + + } + + pLogicalChannel->state = OO_LOGICALCHAN_ESTABLISHED; + + return OO_OK; +} + + + diff --git a/addons/ooh323c/src/ooh245.h b/addons/ooh323c/src/ooh245.h new file mode 100644 index 000000000..10a8750a8 --- /dev/null +++ b/addons/ooh323c/src/ooh245.h @@ -0,0 +1,636 @@ +/* + * 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. + * + *****************************************************************************/ + +/** + * @file ooh245.h + * This file contains functions to support H245 negotiations. + */ +#ifndef _OOH245HDR_H_ +#define _OOH245HDR_H_ + +#include "ooasn1.h" +#include "ooCapability.h" +#include "oochannels.h" +#include "ootrace.h" + +#include "ooq931.h" +#include "MULTIMEDIA-SYSTEM-CONTROL.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +struct OOH323CallData; + +/** + * @defgroup h245 H.245 Message Handling + * @{ + */ +/** + * Defines the H.245 message structure. All request/response + * and command messages are represented using this structure. + */ +typedef struct H245Message { + H245MultimediaSystemControlMessage h245Msg; + ASN1UINT msgType; + ASN1INT logicalChannelNo; +} H245Message; + +/** + * Creates an outgoing H245 message of the type specified by the type + * argument for the Application context. + * + * @param msg A pointer to pointer to message which will be assigned to + * allocated memory. + * @param type Type of the message to be created. + * (Request/Response/Command/Indication) + * + * @return Completion status of operation: 0 (OO_OK) = success, + * negative return value is error. + */ +EXTERN int ooCreateH245Message(H245Message **msg, int type); + +/** + * Frees up the memory used by the H245 message. + * + * @param call Handle to the call + * @param pmsg Pointer to an H245 message structure. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooFreeH245Message(struct OOH323CallData *call, H245Message *pmsg); + +/** + * This function is used to enqueue an H.245 message into an outgoing queue for + * the call. + * @param call Pointer to call for which message has to be enqueued. + * @param msg Pointer to the H.245 message to be sent. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendH245Msg(struct OOH323CallData *call, H245Message *msg); + +/** + * This function is used to retrieve an H.245 message enqueued in the outgoing + * queue. + * @param call Pointer to the call for which message has to be retrieved. + * @param msgbuf Pointer to a buffer in which the message will be returned. + * @param len Pointer to an int variable which will contain length of + * the message data after returning. + * @param msgType Pointer to an int variable, which will contain message type + * on return from the function. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGetOutgoingH245Msgbuf(struct OOH323CallData *call, + ASN1OCTET *msgbuf, + int *len, int *msgType); + +/** + * This function is used to send out a terminal capability set message. + * + * @param call Pointer to a call for which TerminalCapabilitySet message + * will be sent. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendTermCapMsg(struct OOH323CallData *call); + +/** + * This function is used to generate a random status determination number + * for MSD procedure. + * + * @return Generated status determination number. + */ +EXTERN ASN1UINT ooGenerateStatusDeterminationNumber(); + +/** + * This fuction is used to handle received MasterSlaveDetermination procedure + * messages. + * @param call Pointer to the call for which a message is received. + * @param pmsg Pointer to MSD message + * @param msgType Message type indicating whether received message is MSD, + * MSDAck, MSDReject etc... + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooHandleMasterSlave +(struct OOH323CallData *call, void * pmsg, int msgType); + +/** + * This function is used to send MSD message. + * @param call Pointer to call for which MasterSlaveDetermination has to + * be sent. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendMasterSlaveDetermination(struct OOH323CallData *call); + +/** + * This function is used to send a MasterSlaveDeterminationAck message. + * @param call Pointer to call for which MasterSlaveDeterminationAck has + * to be sent. + * @param status Result of the determination process(Master/Slave as it + * applies to remote endpoint) + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendMasterSlaveDeterminationAck +(struct OOH323CallData* call, char * status); + +/** + * This function is used to send a MasterSlaveDeterminationReject message. + * @param call Pointer to call for which message is to be sent. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendMasterSlaveDeterminationReject (struct OOH323CallData* call); + + +/** + * This function is used to handle MasterSlaveReject message. If number of + * retries is less than max allowed, then it restarts the + * MasterSlaveDetermination procedure. + * @param call Handle to the call for which MasterSlaveReject is + * received. + * @param reject Poinetr to the received reject message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooHandleMasterSlaveReject + (struct OOH323CallData *call, H245MasterSlaveDeterminationReject* reject); + +/** + * This function is used to handle received OpenLogicalChannel message. + * @param call Pointer to call for which OpenLogicalChannel message is + * received. + * @param olc Pointer to the received OpenLogicalChannel message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooHandleOpenLogicalChannel + (struct OOH323CallData* call, H245OpenLogicalChannel *olc); + +/** + * This is a helper function used to handle a received OpenLogicalChannel + * message. It builds an OpenLogicalChannelAck message and sends it. + * + * @param call Pointer to cll for which OLC was received. + * @param olc The received OpenLogicalChannel message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooHandleOpenLogicalChannel_helper +(struct OOH323CallData *call, H245OpenLogicalChannel*olc); + +/** + * This function is used to build and send OpenLogicalChannelReject message. + * @param call Pointer to call for which OLCReject has to be sent. + * @param channelNum LogicalChannelNumber to be rejected. + * @param cause Cause of rejection. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooSendOpenLogicalChannelReject + (struct OOH323CallData *call, ASN1UINT channelNum, ASN1UINT cause); + +/** + * This function is used to handle a received OpenLogicalChannelAck message. + * @param call Pointer to call for which OLCAck is received + * @param olcAck Pointer to received olcAck message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedOpenLogicalChannelAck(struct OOH323CallData *call, + H245OpenLogicalChannelAck *olcAck); + + +/** + * This function is used to handle the received OpenLogicalChannelReject + * message. + * @param call Handle to the call for which the message is received. + * @param olcRejected Pointer to received OpenLogicalChannelReject message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooOnReceivedOpenLogicalChannelRejected(struct OOH323CallData *call, + H245OpenLogicalChannelReject *olcRejected); +/** + * This message is used to send an EndSession command. It builds a EndSession + * command message and queues it into the calls outgoing queue. + * @param call Pointer to call for which EndSession command has to be + * sent. + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendEndSessionCommand(struct OOH323CallData *call); + +/** + * This function is used to handle a received H245Command message. + * @param call Pointer to call for which an H245Command is received. + * @param command Pointer to a command message. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooHandleH245Command +(struct OOH323CallData *call, H245CommandMessage *command); + + +/** + * This function is used to handle a received UserInput Indication message. + * It extracts the dtmf received through user-input message and calls endpoints + * onReceivedDTMF callback function, if such a function is registered by the + * endpoint. + * @param call Handle to the call for which user-input indication + * message is received. + * @param indication Handle to the received user-input indication message. + * + * @return OO_OK, on success; OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedUserInputIndication + (OOH323CallData *call, H245UserInputIndication *indication); + +/** + * This function is called on receiving a TreminalCapabilitySetAck message. + * If the MasterSlaveDetermination process is also over, this function + * initiates the process of opening logical channels. + * @param call Pointer to call for which TCSAck is received. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedTerminalCapabilitySetAck(struct OOH323CallData* call); + +/** + * This function is called to close all the open logical channels. It sends + * CloseLogicalChannel message for all the forward channels and sends + * RequestCloseLogicalChannel message for all the reverse channels. + * @param call Pointer to call for which logical channels have to be + * closed. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooCloseAllLogicalChannels(struct OOH323CallData *call); + + +/** + * This function is used to send out a CloseLogicalChannel message for a particular + * logical channel. + * @param call Pointer to a call, to which logical channel to be closed belongs. + * @param logicalChan Pointer to the logical channel to be closed. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendCloseLogicalChannel +(struct OOH323CallData *call, ooLogicalChannel *logicalChan); + +/** + * This function is used to process a received closeLogicalChannel request. It closes the + * logical channel and removes the logical channel entry from the list. It also, sends + * closeLogicalChannelAck message to the remote endpoint. + * @param call Pointer to call for which CloseLogicalChannel message is received. + * @param clc Pointer to received CloseLogicalChannel message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedCloseLogicalChannel(struct OOH323CallData *call, + H245CloseLogicalChannel* clc); + +/** + * This function is used to process a received CloseLogicalChannelAck message. It closes the + * channel and removes it from the list of active logical channels. + * @param call Pointer to call for which CLCAck message is received. + * @param clcAck Pointer to the received CloseLogicalChannelAck message. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooOnReceivedCloseChannelAck(struct OOH323CallData* call, + H245CloseLogicalChannelAck* clcAck); + +/** + * This function is used to handle received H245 message. Based on the type of message received, + * it calls helper functions to process those messages. + * @param call Pointer to call for which a message is received. + * @param pmsg Pointer to the received H245 message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooHandleH245Message +(struct OOH323CallData *call, H245Message * pmsg); + +/** + * This function is used to process received TCS message. It builds TCSAck message and queues it + * into the calls outgoing queue. Also, starts Logical channel opening procedure if TCS and MSD + * procedures have finished. + * @param call Pointer to call for which TCS is received. + * @param pmsg Pointer to the received message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedTerminalCapabilitySet +(struct OOH323CallData *call, H245Message *pmsg); + +/** + * This function is used to send a TCSAck message to remote endpoint. + * @param call Pointer to call on which TCSAck has to be sent. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooH245AcknowledgeTerminalCapabilitySet(struct OOH323CallData *call); + +/** + * This function is used to start OpenLogicalChannel procedure for all the + * channels to be opened for the call. + * @param call Pointer to call for which logical channels have to be opened. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOpenLogicalChannels(struct OOH323CallData *call); + +/** + * This function is used to send OpenLogicalChannel message for audio/video + * channel. + * @param call Pointer to call for which channel has to be opened. + * @param capType Type of media channel. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOpenLogicalChannel(struct OOH323CallData *call, + enum OOCapType capType); + +/** + * This function is used to build and send OpenLogicalChannel message using + * capability passed as parameter. + * @param call Pointer to call for which OpenLogicalChannel message + * has to be built. + * @param epCap Pointer to capability + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOpenChannel +(struct OOH323CallData* call, ooH323EpCapability *epCap); + +/** + * This function is used to send dtmf digits as user input indication message + * contating alphanumeric string. + * @param call Handle to the call for which dtmf has to be sent. + * @param data DTMF data + * + * @return OO_OK, on success; OO_FAILED, on failure. + */ +EXTERN int ooSendH245UserInputIndication_alphanumeric + (OOH323CallData *call, const char *data); + +/** + * This function is used to send dtmf digits as user input indication message + * contating dtmf signal type. + * @param call Handle to the call for which dtmf has to be sent. + * @param data DTMF data + * + * @return OO_OK, on success; OO_FAILED, on failure. + */ +EXTERN int ooSendH245UserInputIndication_signal + (OOH323CallData *call, const char *data); + +/** + * This function is used to request a remote end point to close a logical + * channel. + * @param call Pointer to call for which the logical channel has to + * be closed. + * @param logicalChan Pointer to the logical channel structure which needs + * to be closed. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendRequestCloseLogicalChannel(struct OOH323CallData *call, + ooLogicalChannel *logicalChan); + +/** + * This function is used to send a RequestChannelCloseRelease message when the + * corresponding timer has expired. + * @param call Handle to the call + * @param channelNum Channel number. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooSendRequestChannelCloseRelease +(struct OOH323CallData *call, int channelNum); + +/** + * This function handles the received RequestChannelClose message, verifies + * that the requested channel is forward channel. It sends an acknowledgement + * for the message followed by CloseLogicalChannel message. + * @param call Pointer to the call for which RequestChannelClose is + * received. + * @param rclc Pointer to the received message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedRequestChannelClose(struct OOH323CallData *call, + H245RequestChannelClose *rclc); + +/** + * This function is used to handle a received RequestChannelCloseReject + * response message. + * @param call Handle to the call. + * @param rccReject Pointer to the received reject response message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooOnReceivedRequestChannelCloseReject + (struct OOH323CallData *call, H245RequestChannelCloseReject *rccReject); + +/** + * This function is used to handle a received RequestChannelCloseAck + * response message. + * @param call Handle to the call. + * @param rccAck Pointer to the received ack response message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooOnReceivedRequestChannelCloseAck + (struct OOH323CallData *call, H245RequestChannelCloseAck *rccAck); + +/** + * Builds an OLC for faststart with an audio/video capability passed as + * parameter. + * @param call Handle to call for which OLC has to be built. + * @param olc Pointer to an OLC structure which will be populated. + * @param epCap Pointer to the capability which will be used to + * build OLC. + * @param pctxt Pointer to an OOCTXT structure which will be used + * to allocate additional memory for OLC. + * @param dir Direction of OLC + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooBuildFastStartOLC(struct OOH323CallData *call, + H245OpenLogicalChannel *olc, + ooH323EpCapability *epCap, + OOCTXT*pctxt, int dir); + +/** + * Prepares a faststart response olc from the olc received in SETUP message. + * This function just changes the mediaChannel and mediaControl channel part + * of the olc received in SETUP. + * @param call Handle to call for which OLC has to be built. + * @param olc Pointer to an received OLC structure. + * @param epCap Pointer to the capability which will be used for + * this channel. + * @param pctxt Pointer to an OOCTXT structure which will be used + * to allocate additional memory for OLC. + * @param dir Direction of channel OORX, OOTX etc. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooPrepareFastStartResponseOLC + (OOH323CallData *call, H245OpenLogicalChannel *olc, + ooH323EpCapability *epCap, OOCTXT*pctxt, int dir); + +/** + * This function is used to encode an H245 message and return encoded data + * into the buffer passed as a parameter to the function. + * @param call Handle to the call + * @param ph245Msg Handle to the message to be encoded. + * @param msgbuf buffer in which encoded message will be returned. + * @param size Size of the buffer. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooEncodeH245Message +(struct OOH323CallData *call, H245Message *ph245Msg, char *msgbuf, int size); + +/** + * This function is used to send a master-slave determination release message. + * @param call Handle to call, for which MSDRelease message has + * to be sent. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooSendMasterSlaveDeterminationRelease(struct OOH323CallData * call); + +/** + * This function is used to send a terminal capability set reject message + * to the remote endpoint. + * @param call Handle to the call for which reject message has to + * be sent. + * @param seqNo Sequence number of the TCS message to be rejected. + * @param cause Cause for rejecting a TCS message. + * + * @return OO_OK, on success; OO_FAILED, otherwise. + */ +int ooSendTerminalCapabilitySetReject + (struct OOH323CallData *call, int seqNo, ASN1UINT cause); + +/** + * This function is used to send a TerminalCapabilitySetRelease message after + * capability exchange timer has expired. + * @param call Handle to call for which release message has to be + * sent. + * + * @return OO_OK, on success; OO_FAILED, on failure. + */ +int ooSendTerminalCapabilitySetRelease(struct OOH323CallData * call); + + +/** + * This is an helper function used to extract ip address and port info from + * H245TransportAddress structure. + * @param call Handle to associated call. + * @param h245Address Handle to H245TransportAddress structure from which + * information has to be extracted. + * @param ip Pointer to buffer in which ip address will be + * returned. Make sure that buffer has sufficient length. + * @param port Pointer to integer in which port number will be + * returned. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooGetIpPortFromH245TransportAddress + (OOH323CallData *call, H245TransportAddress *h245Address, char *ip, + int *port); + +/** + * This is a callback function for handling an expired master-slave + * determination timer. + * @param data Callback data registered at the time of creation of + * the timer. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooMSDTimerExpired(void *data); + +/** + * This is a callback function for handling an expired capability exchange + * timer. + * @param data Callback data registered at the time of creation of + * the timer. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooTCSTimerExpired(void *data); + +/** + * This is a callback function for handling an expired OpenLogicalChannel + * timer. + * @param pdata Callback data registered at the time of creation of + * the timer. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooOpenLogicalChannelTimerExpired(void *pdata); + +/** + * This is a callback function for handling an expired CloseLogicalChannel + * timer. + * @param pdata Callback data registered at the time of creation of + * the timer. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooCloseLogicalChannelTimerExpired(void *pdata); + +/** + * This is a callback function for handling an expired RequestChannelClose + * timer. + * @param pdata Callback data registered at the time of creation of + * the timer. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooRequestChannelCloseTimerExpired(void *pdata); + +/** + * This is a callback function for handling an expired EndSession timer. + * @param pdata Callback data registered at the time of creation of + * the timer. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +int ooSessionTimerExpired(void *pdata); +/** + * @} + */ +#ifdef __cplusplus +} +#endif + +#endif diff --git a/addons/ooh323c/src/ooh323.c b/addons/ooh323c/src/ooh323.c new file mode 100644 index 000000000..1cefa1d0b --- /dev/null +++ b/addons/ooh323c/src/ooh323.c @@ -0,0 +1,1843 @@ +/* + * 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 "ootypes.h" +#include "ooq931.h" +#include "ootrace.h" +#include "oochannels.h" +#include "ooh245.h" +#include "ooCalls.h" +#include "printHandler.h" +#include "ooh323.h" +#include "ooh323ep.h" +#include "ooGkClient.h" +#include "ooTimer.h" + +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + + +int ooOnReceivedReleaseComplete(OOH323CallData *call, Q931Message *q931Msg) +{ + int ret = OO_OK; + H225ReleaseComplete_UUIE * releaseComplete = NULL; + ASN1UINT i; + DListNode *pNode = NULL; + OOTimer *pTimer = NULL; + unsigned reasonCode=T_H225ReleaseCompleteReason_undefinedReason; + enum Q931CauseValues cause= Q931ErrorInCauseIE; + + if(q931Msg->causeIE) + { + cause = q931Msg->causeIE->data[1]; + /* Get rid of the extension bit.For more info, check ooQ931SetCauseIE */ + cause = cause & 0x7f; + OOTRACEDBGA4("Cause of Release Complete is %x. (%s, %s)\n", cause, + call->callType, call->callToken); + } + + /* Remove session timer, if active*/ + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if(((ooTimerCallback*)pTimer->cbData)->timerType & + OO_SESSION_TIMER) + { + memFreePtr(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted Session Timer. (%s, %s)\n", + call->callType, call->callToken); + break; + } + } + + + if(!q931Msg->userInfo) + { + OOTRACEERR3("ERROR:No User-User IE in received ReleaseComplete message " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + releaseComplete = q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.releaseComplete; + if(!releaseComplete) + { + OOTRACEWARN3("WARN: ReleaseComplete UUIE not found in received " + "ReleaseComplete message - %s " + "%s\n", call->callType, call->callToken); + } + else{ + + if(releaseComplete->m.reasonPresent) + { + OOTRACEINFO4("Release complete reason code %d. (%s, %s)\n", + releaseComplete->reason.t, call->callType, call->callToken); + reasonCode = releaseComplete->reason.t; + } + } + + if(call->callEndReason == OO_REASON_UNKNOWN) + call->callEndReason = ooGetCallClearReasonFromCauseAndReasonCode(cause, + reasonCode); +#if 0 + if (q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent && + q931Msg->userInfo->h323_uu_pdu.h245Tunneling && + OO_TESTFLAG (call->flags, OO_M_TUNNELING) ) + { + OOTRACEDBGB3("Handling tunneled messages in ReleaseComplete. (%s, %s)\n", + call->callType, call->callToken); + ret = ooHandleTunneledH245Messages + (call, &q931Msg->userInfo->h323_uu_pdu); + OOTRACEDBGB3("Finished handling tunneled messages in ReleaseComplete." + " (%s, %s)\n", call->callType, call->callToken); + } +#endif + if(call->h245SessionState != OO_H245SESSION_IDLE && + call->h245SessionState != OO_H245SESSION_CLOSED) + { + ooCloseH245Connection(call); + } + + if(call->callState != OO_CALL_CLEAR_RELEASESENT) + { + if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK)) + { + if(gH323ep.gkClient->state == GkClientRegistered){ + OOTRACEDBGA3("Sending DRQ after received ReleaseComplete." + "(%s, %s)\n", call->callType, call->callToken); + ooGkClientSendDisengageRequest(gH323ep.gkClient, call); + } + } + } + call->callState = OO_CALL_CLEARED; + + return ret; +} + +int ooOnReceivedSetup(OOH323CallData *call, Q931Message *q931Msg) +{ + H225Setup_UUIE *setup=NULL; + int i=0, ret=0; + H245OpenLogicalChannel* olc; + ASN1OCTET msgbuf[MAXMSGLEN]; + H225TransportAddress_ipAddress_ip *ip = NULL; + Q931InformationElement* pDisplayIE=NULL; + OOAliases *pAlias=NULL; + + call->callReference = q931Msg->callReference; + + if(!q931Msg->userInfo) + { + OOTRACEERR3("ERROR:No User-User IE in received SETUP message (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + setup = q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.setup; + if(!setup) + { + OOTRACEERR3("Error: Setup UUIE not found in received setup message - %s " + "%s\n", call->callType, call->callToken); + return OO_FAILED; + } + memcpy(call->callIdentifier.guid.data, setup->callIdentifier.guid.data, + setup->callIdentifier.guid.numocts); + call->callIdentifier.guid.numocts = setup->callIdentifier.guid.numocts; + + memcpy(call->confIdentifier.data, setup->conferenceID.data, + setup->conferenceID.numocts); + call->confIdentifier.numocts = setup->conferenceID.numocts; + + /* check for display ie */ + pDisplayIE = ooQ931GetIE(q931Msg, Q931DisplayIE); + if(pDisplayIE) + { + call->remoteDisplayName = (ASN1OCTET*) memAlloc(call->pctxt, + pDisplayIE->length*sizeof(ASN1OCTET)+1); + strcpy(call->remoteDisplayName, pDisplayIE->data); + } + /*Extract Remote Aliases, if present*/ + if(setup->m.sourceAddressPresent) + { + if(setup->sourceAddress.count>0) + { + ooH323RetrieveAliases(call, &setup->sourceAddress, + &call->remoteAliases); + pAlias = call->remoteAliases; + while(pAlias) + { + if(pAlias->type == T_H225AliasAddress_dialedDigits) + { + if(!call->callingPartyNumber) + { + call->callingPartyNumber = (char*)memAlloc(call->pctxt, + strlen(pAlias->value)*+1); + if(call->callingPartyNumber) + { + strcpy(call->callingPartyNumber, pAlias->value); + } + } + break; + } + pAlias = pAlias->next; + } + } + } + /* Extract, aliases used for us, if present. Also, + Populate calledPartyNumber from dialedDigits, if not yet populated using + calledPartyNumber Q931 IE. + */ + if(setup->m.destinationAddressPresent) + { + if(setup->destinationAddress.count>0) + { + ooH323RetrieveAliases(call, &setup->destinationAddress, + &call->ourAliases); + pAlias = call->ourAliases; + while(pAlias) + { + if(pAlias->type == T_H225AliasAddress_dialedDigits) + { + if(!call->calledPartyNumber) + { + call->calledPartyNumber = (char*)memAlloc(call->pctxt, + strlen(pAlias->value)*+1); + if(call->calledPartyNumber) + { + strcpy(call->calledPartyNumber, pAlias->value); + } + } + break; + } + pAlias = pAlias->next; + } + } + } + + /* Check for tunneling */ + if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent) + { + /* Tunneling enabled only when tunneling is set to true and h245 + address is absent. In the presence of H.245 address in received + SETUP message, tunneling is disabled, irrespective of tunneling + flag in the setup message*/ + if(q931Msg->userInfo->h323_uu_pdu.h245Tunneling && + !setup->m.h245AddressPresent) + { + if(OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING)) + { + OO_SETFLAG (call->flags, OO_M_TUNNELING); + OOTRACEINFO3("Call has tunneling active (%s,%s)\n", call->callType, + call->callToken); + } + else + OOTRACEINFO3("ERROR:Remote endpoint wants to use h245Tunneling, " + "local endpoint has it disabled (%s,%s)\n", + call->callType, call->callToken); + } + else { + if(OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING)) + { + OOTRACEINFO3("Tunneling disabled by remote endpoint. (%s, %s)\n", + call->callType, call->callToken); + } + OO_CLRFLAG (call->flags, OO_M_TUNNELING); + } + } + else { + if(OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING)) + { + OOTRACEINFO3("Tunneling disabled by remote endpoint. (%s, %s)\n", + call->callType, call->callToken); + } + OO_CLRFLAG (call->flags, OO_M_TUNNELING); + } + + /* Extract Remote IP address */ + if(!setup->m.sourceCallSignalAddressPresent) + { + OOTRACEWARN3("WARNING:Missing source call signal address in received " + "setup (%s, %s)\n", call->callType, call->callToken); + } + else{ + + if(setup->sourceCallSignalAddress.t != T_H225TransportAddress_ipAddress) + { + OOTRACEERR3("ERROR: Source call signalling address type not ip " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + ip = &setup->sourceCallSignalAddress.u.ipAddress->ip; + sprintf(call->remoteIP, "%d.%d.%d.%d", ip->data[0], ip->data[1], + ip->data[2], ip->data[3]); + call->remotePort = setup->sourceCallSignalAddress.u.ipAddress->port; + } + + /* check for fast start */ + + if(setup->m.fastStartPresent) + { + if(!OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART)) + { + OOTRACEINFO3("Local endpoint does not support fastStart. Ignoring " + "fastStart. (%s, %s)\n", call->callType, call->callToken); + OO_CLRFLAG (call->flags, OO_M_FASTSTART); + } + else if(setup->fastStart.n == 0) + { + OOTRACEINFO3("Empty faststart element received. Ignoring fast start. " + "(%s, %s)\n", call->callType, call->callToken); + OO_CLRFLAG (call->flags, OO_M_FASTSTART); + } + else{ + OO_SETFLAG (call->flags, OO_M_FASTSTART); + OOTRACEINFO3("FastStart enabled for call(%s, %s)\n", call->callType, + call->callToken); + } + } + + if (OO_TESTFLAG (call->flags, OO_M_FASTSTART)) + { + /* For printing the decoded message to log, initialize handler. */ + initializePrintHandler(&printHandler, "FastStart Elements"); + + /* Set print handler */ + setEventHandler (call->pctxt, &printHandler); + + for(i=0; i<(int)setup->fastStart.n; i++) + { + olc = NULL; + /* memset(msgbuf, 0, sizeof(msgbuf));*/ + olc = (H245OpenLogicalChannel*)memAlloc(call->pctxt, + sizeof(H245OpenLogicalChannel)); + if(!olc) + { + OOTRACEERR3("ERROR:Memory - ooOnReceivedSetup - olc (%s, %s)\n", + call->callType, call->callToken); + /*Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + memset(olc, 0, sizeof(H245OpenLogicalChannel)); + memcpy(msgbuf, setup->fastStart.elem[i].data, + setup->fastStart.elem[i].numocts); + + setPERBuffer(call->pctxt, msgbuf, + setup->fastStart.elem[i].numocts, 1); + ret = asn1PD_H245OpenLogicalChannel(call->pctxt, olc); + if(ret != ASN_OK) + { + OOTRACEERR3("ERROR:Failed to decode fast start olc element " + "(%s, %s)\n", call->callType, call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + /* For now, just add decoded fast start elemts to list. This list + will be processed at the time of sending CONNECT message. */ + dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc); + } + finishPrint(); + removeEventHandler(call->pctxt); + } + + return OO_OK; +} + + + +int ooOnReceivedCallProceeding(OOH323CallData *call, Q931Message *q931Msg) +{ + H225CallProceeding_UUIE *callProceeding=NULL; + H245OpenLogicalChannel* olc; + ASN1OCTET msgbuf[MAXMSGLEN]; + ooLogicalChannel * pChannel = NULL; + H245H2250LogicalChannelParameters * h2250lcp = NULL; + int i=0, ret=0; + + if(!q931Msg->userInfo) + { + OOTRACEERR3("ERROR:No User-User IE in received CallProceeding message." + " (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + callProceeding = + q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.callProceeding; + if(callProceeding == NULL) + { + OOTRACEERR3("Error: Received CallProceeding message does not have " + "CallProceeding UUIE (%s, %s)\n", call->callType, + call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + + /* Handle fast-start */ + if(OO_TESTFLAG (call->flags, OO_M_FASTSTART)) + { + if(callProceeding->m.fastStartPresent) + { + /* For printing the decoded message to log, initialize handler. */ + initializePrintHandler(&printHandler, "FastStart Elements"); + + /* Set print handler */ + setEventHandler (call->pctxt, &printHandler); + + for(i=0; i<(int)callProceeding->fastStart.n; i++) + { + olc = NULL; + + olc = (H245OpenLogicalChannel*)memAlloc(call->pctxt, + sizeof(H245OpenLogicalChannel)); + if(!olc) + { + OOTRACEERR3("ERROR:Memory - ooOnReceivedCallProceeding - olc" + "(%s, %s)\n", call->callType, call->callToken); + /*Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + memset(olc, 0, sizeof(H245OpenLogicalChannel)); + memcpy(msgbuf, callProceeding->fastStart.elem[i].data, + callProceeding->fastStart.elem[i].numocts); + setPERBuffer(call->pctxt, msgbuf, + callProceeding->fastStart.elem[i].numocts, 1); + ret = asn1PD_H245OpenLogicalChannel(call->pctxt, olc); + if(ret != ASN_OK) + { + OOTRACEERR3("ERROR:Failed to decode fast start olc element " + "(%s, %s)\n", call->callType, call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + + dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc); + + pChannel = ooFindLogicalChannelByOLC(call, olc); + if(!pChannel) + { + OOTRACEERR4("ERROR: Logical Channel %d not found, fast start. " + "(%s, %s)\n", + olc->forwardLogicalChannelNumber, call->callType, + call->callToken); + return OO_FAILED; + } + if(pChannel->channelNo != olc->forwardLogicalChannelNumber) + { + OOTRACEINFO5("Remote endpoint changed forwardLogicalChannel" + "Number from %d to %d (%s, %s)\n", + pChannel->channelNo, + olc->forwardLogicalChannelNumber, call->callType, + call->callToken); + pChannel->channelNo = olc->forwardLogicalChannelNumber; + } + if(!strcmp(pChannel->dir, "transmit")) + { + if(olc->forwardLogicalChannelParameters.multiplexParameters.t != + T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters) + { + OOTRACEERR4("ERROR:Unknown multiplex parameter type for " + "channel %d (%s, %s)\n", + olc->forwardLogicalChannelNumber, call->callType, + call->callToken); + continue; + } + + /* Extract the remote media endpoint address */ + h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters; + if(!h2250lcp) + { + OOTRACEERR3("ERROR:Invalid OLC received in fast start. No " + "forward Logical Channel Parameters found. " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + if(!h2250lcp->m.mediaChannelPresent) + { + OOTRACEERR3("ERROR:Invalid OLC received in fast start. No " + "reverse media channel information found." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ret = ooGetIpPortFromH245TransportAddress(call, + &h2250lcp->mediaChannel, pChannel->remoteIP, + &pChannel->remoteMediaPort); + + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Unsupported media channel address type " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + if(!pChannel->chanCap->startTransmitChannel) + { + OOTRACEERR3("ERROR:No callback registered to start transmit " + "channel (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + pChannel->chanCap->startTransmitChannel(call, pChannel); + } + /* Mark the current channel as established and close all other + logical channels with same session id and in same direction. + */ + ooOnLogicalChannelEstablished(call, pChannel); + } + finishPrint(); + removeEventHandler(call->pctxt); + OO_SETFLAG(call->flags, OO_M_FASTSTARTANSWERED); + } + + } + + /* Retrieve the H.245 control channel address from the connect msg */ + if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent && + q931Msg->userInfo->h323_uu_pdu.h245Tunneling && + callProceeding->m.h245AddressPresent) { + OOTRACEINFO3("Tunneling and h245address provided." + "Using Tunneling for H.245 messages (%s, %s)\n", + call->callType, call->callToken); + } + else if(callProceeding->m.h245AddressPresent) + { + if (OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + OO_CLRFLAG (call->flags, OO_M_TUNNELING); + OOTRACEINFO3("Tunneling is disabled for call as H245 address is " + "provided in callProceeding message (%s, %s)\n", + call->callType, call->callToken); + } + ret = ooH323GetIpPortFromH225TransportAddress(call, + &callProceeding->h245Address, call->remoteIP, + &call->remoteH245Port); + if(ret != OO_OK) + { + OOTRACEERR3("Error: Unknown H245 address type in received " + "CallProceeding message (%s, %s)", call->callType, + call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + } + return OO_OK; +} + + +int ooOnReceivedAlerting(OOH323CallData *call, Q931Message *q931Msg) +{ + H225Alerting_UUIE *alerting=NULL; + H245OpenLogicalChannel* olc; + ASN1OCTET msgbuf[MAXMSGLEN]; + ooLogicalChannel * pChannel = NULL; + H245H2250LogicalChannelParameters * h2250lcp = NULL; + int i=0, ret=0; + + + if(!q931Msg->userInfo) + { + OOTRACEERR3("ERROR:No User-User IE in received Alerting message." + " (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + alerting = q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.alerting; + if(alerting == NULL) + { + OOTRACEERR3("Error: Received Alerting message does not have " + "alerting UUIE (%s, %s)\n", call->callType, + call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + /*Handle fast-start */ + if(OO_TESTFLAG (call->flags, OO_M_FASTSTART) && + !OO_TESTFLAG(call->flags, OO_M_FASTSTARTANSWERED)) + { + if(alerting->m.fastStartPresent) + { + /* For printing the decoded message to log, initialize handler. */ + initializePrintHandler(&printHandler, "FastStart Elements"); + + /* Set print handler */ + setEventHandler (call->pctxt, &printHandler); + + for(i=0; i<(int)alerting->fastStart.n; i++) + { + olc = NULL; + + olc = (H245OpenLogicalChannel*)memAlloc(call->pctxt, + sizeof(H245OpenLogicalChannel)); + if(!olc) + { + OOTRACEERR3("ERROR:Memory - ooOnReceivedAlerting - olc" + "(%s, %s)\n", call->callType, call->callToken); + /*Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + memset(olc, 0, sizeof(H245OpenLogicalChannel)); + memcpy(msgbuf, alerting->fastStart.elem[i].data, + alerting->fastStart.elem[i].numocts); + setPERBuffer(call->pctxt, msgbuf, + alerting->fastStart.elem[i].numocts, 1); + ret = asn1PD_H245OpenLogicalChannel(call->pctxt, olc); + if(ret != ASN_OK) + { + OOTRACEERR3("ERROR:Failed to decode fast start olc element " + "(%s, %s)\n", call->callType, call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + + dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc); + + pChannel = ooFindLogicalChannelByOLC(call, olc); + if(!pChannel) + { + OOTRACEERR4("ERROR: Logical Channel %d not found, fast start. " + "(%s, %s)\n", + olc->forwardLogicalChannelNumber, call->callType, + call->callToken); + return OO_FAILED; + } + if(pChannel->channelNo != olc->forwardLogicalChannelNumber) + { + OOTRACEINFO5("Remote endpoint changed forwardLogicalChannel" + "Number from %d to %d (%s, %s)\n", + pChannel->channelNo, + olc->forwardLogicalChannelNumber, call->callType, + call->callToken); + pChannel->channelNo = olc->forwardLogicalChannelNumber; + } + if(!strcmp(pChannel->dir, "transmit")) + { + if(olc->forwardLogicalChannelParameters.multiplexParameters.t != + T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters) + { + OOTRACEERR4("ERROR:Unknown multiplex parameter type for " + "channel %d (%s, %s)\n", + olc->forwardLogicalChannelNumber, call->callType, + call->callToken); + continue; + } + + /* Extract the remote media endpoint address */ + h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters; + if(!h2250lcp) + { + OOTRACEERR3("ERROR:Invalid OLC received in fast start. No " + "forward Logical Channel Parameters found. " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + if(!h2250lcp->m.mediaChannelPresent) + { + OOTRACEERR3("ERROR:Invalid OLC received in fast start. No " + "reverse media channel information found." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ret = ooGetIpPortFromH245TransportAddress(call, + &h2250lcp->mediaChannel, pChannel->remoteIP, + &pChannel->remoteMediaPort); + + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Unsupported media channel address type " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + if(!pChannel->chanCap->startTransmitChannel) + { + OOTRACEERR3("ERROR:No callback registered to start transmit " + "channel (%s, %s)\n",call->callType, + call->callToken); + return OO_FAILED; + } + pChannel->chanCap->startTransmitChannel(call, pChannel); + } + /* Mark the current channel as established and close all other + logical channels with same session id and in same direction. + */ + ooOnLogicalChannelEstablished(call, pChannel); + } + finishPrint(); + removeEventHandler(call->pctxt); + OO_SETFLAG(call->flags, OO_M_FASTSTARTANSWERED); + } + + } + + /* Retrieve the H.245 control channel address from the connect msg */ + if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent && + q931Msg->userInfo->h323_uu_pdu.h245Tunneling && + alerting->m.h245AddressPresent) { + OOTRACEINFO3("Tunneling and h245address provided." + "Giving preference to Tunneling (%s, %s)\n", + call->callType, call->callToken); + } + else if(alerting->m.h245AddressPresent) + { + if (OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + OO_CLRFLAG (call->flags, OO_M_TUNNELING); + OOTRACEINFO3("Tunneling is disabled for call as H245 address is " + "provided in Alerting message (%s, %s)\n", + call->callType, call->callToken); + } + ret = ooH323GetIpPortFromH225TransportAddress(call, + &alerting->h245Address, call->remoteIP, + &call->remoteH245Port); + if(ret != OO_OK) + { + OOTRACEERR3("Error: Unknown H245 address type in received " + "Alerting message (%s, %s)", call->callType, + call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + } + return OO_OK; +} + + +int ooOnReceivedSignalConnect(OOH323CallData* call, Q931Message *q931Msg) +{ + int ret, i; + H225Connect_UUIE *connect; + H245OpenLogicalChannel* olc; + ASN1OCTET msgbuf[MAXMSGLEN]; + ooLogicalChannel * pChannel = NULL; + H245H2250LogicalChannelParameters * h2250lcp = NULL; + + if(!q931Msg->userInfo) + { + OOTRACEERR3("Error: UUIE not found in received H.225 Connect message" + " (%s, %s)\n", call->callType, call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + /* Retrieve the connect message from the user-user IE & Q.931 header */ + connect = q931Msg->userInfo->h323_uu_pdu.h323_message_body.u.connect; + if(connect == NULL) + { + OOTRACEERR3("Error: Received Connect message does not have Connect UUIE" + " (%s, %s)\n", call->callType, call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + + /*Handle fast-start */ + if(OO_TESTFLAG (call->flags, OO_M_FASTSTART) && + !OO_TESTFLAG (call->flags, OO_M_FASTSTARTANSWERED)) + { + if(!connect->m.fastStartPresent) + { + OOTRACEINFO3("Remote endpoint has rejected fastStart. (%s, %s)\n", + call->callType, call->callToken); + /* Clear all channels we might have created */ + ooClearAllLogicalChannels(call); + OO_CLRFLAG (call->flags, OO_M_FASTSTART); + } + } + + if (connect->m.fastStartPresent && + !OO_TESTFLAG(call->flags, OO_M_FASTSTARTANSWERED)) + { + /* For printing the decoded message to log, initialize handler. */ + initializePrintHandler(&printHandler, "FastStart Elements"); + + /* Set print handler */ + setEventHandler (call->pctxt, &printHandler); + + for(i=0; i<(int)connect->fastStart.n; i++) + { + olc = NULL; + /* memset(msgbuf, 0, sizeof(msgbuf));*/ + olc = (H245OpenLogicalChannel*)memAlloc(call->pctxt, + sizeof(H245OpenLogicalChannel)); + if(!olc) + { + OOTRACEERR3("ERROR:Memory - ooOnReceivedSignalConnect - olc" + "(%s, %s)\n", call->callType, call->callToken); + /*Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + finishPrint(); + removeEventHandler(call->pctxt); + return OO_FAILED; + } + memset(olc, 0, sizeof(H245OpenLogicalChannel)); + memcpy(msgbuf, connect->fastStart.elem[i].data, + connect->fastStart.elem[i].numocts); + setPERBuffer(call->pctxt, msgbuf, + connect->fastStart.elem[i].numocts, 1); + ret = asn1PD_H245OpenLogicalChannel(call->pctxt, olc); + if(ret != ASN_OK) + { + OOTRACEERR3("ERROR:Failed to decode fast start olc element " + "(%s, %s)\n", call->callType, call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + finishPrint(); + removeEventHandler(call->pctxt); + return OO_FAILED; + } + + dListAppend(call->pctxt, &call->remoteFastStartOLCs, olc); + + pChannel = ooFindLogicalChannelByOLC(call, olc); + if(!pChannel) + { + OOTRACEERR4("ERROR: Logical Channel %d not found, fasts start " + "answered. (%s, %s)\n", + olc->forwardLogicalChannelNumber, call->callType, + call->callToken); + finishPrint(); + removeEventHandler(call->pctxt); + return OO_FAILED; + } + if(pChannel->channelNo != olc->forwardLogicalChannelNumber) + { + OOTRACEINFO5("Remote endpoint changed forwardLogicalChannelNumber" + "from %d to %d (%s, %s)\n", pChannel->channelNo, + olc->forwardLogicalChannelNumber, call->callType, + call->callToken); + pChannel->channelNo = olc->forwardLogicalChannelNumber; + } + if(!strcmp(pChannel->dir, "transmit")) + { + if(olc->forwardLogicalChannelParameters.multiplexParameters.t != + T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters) + { + OOTRACEERR4("ERROR:Unknown multiplex parameter type for channel" + " %d (%s, %s)\n", olc->forwardLogicalChannelNumber, + call->callType, call->callToken); + continue; + } + + /* Extract the remote media endpoint address */ + h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters; + if(!h2250lcp) + { + OOTRACEERR3("ERROR:Invalid OLC received in fast start. No " + "forward Logical Channel Parameters found. (%s, %s)" + "\n", call->callType, call->callToken); + finishPrint(); + removeEventHandler(call->pctxt); + return OO_FAILED; + } + if(!h2250lcp->m.mediaChannelPresent) + { + OOTRACEERR3("ERROR:Invalid OLC received in fast start. No " + "reverse media channel information found. (%s, %s)" + "\n", call->callType, call->callToken); + finishPrint(); + removeEventHandler(call->pctxt); + return OO_FAILED; + } + + ret = ooGetIpPortFromH245TransportAddress(call, + &h2250lcp->mediaChannel, pChannel->remoteIP, + &pChannel->remoteMediaPort); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Unsupported media channel address type " + "(%s, %s)\n", call->callType, call->callToken); + finishPrint(); + removeEventHandler(call->pctxt); + return OO_FAILED; + } + if(!pChannel->chanCap->startTransmitChannel) + { + OOTRACEERR3("ERROR:No callback registered to start transmit " + "channel (%s, %s)\n",call->callType, call->callToken); + finishPrint(); + removeEventHandler(call->pctxt); + return OO_FAILED; + } + pChannel->chanCap->startTransmitChannel(call, pChannel); + } + /* Mark the current channel as established and close all other + logical channels with same session id and in same direction. + */ + ooOnLogicalChannelEstablished(call, pChannel); + } + finishPrint(); + removeEventHandler(call->pctxt); + OO_SETFLAG(call->flags, OO_M_FASTSTARTANSWERED); + } + + /* Retrieve the H.245 control channel address from the CONNECT msg */ + if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent && + q931Msg->userInfo->h323_uu_pdu.h245Tunneling && + connect->m.h245AddressPresent) { + OOTRACEINFO3("Tunneling and h245address provided." + "Giving preference to Tunneling (%s, %s)\n", + call->callType, call->callToken); + } + else if(connect->m.h245AddressPresent) + { + if (OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + OO_CLRFLAG (call->flags, OO_M_TUNNELING); + OOTRACEINFO3("Tunneling is disabled for call as H245 address is " + "provided in connect message (%s, %s)\n", + call->callType, call->callToken); + } + ret = ooH323GetIpPortFromH225TransportAddress(call, + &connect->h245Address, call->remoteIP, &call->remoteH245Port); + if(ret != OO_OK) + { + OOTRACEERR3("Error: Unknown H245 address type in received Connect " + "message (%s, %s)", call->callType, call->callToken); + /* Mark call for clearing */ + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_INVALIDMESSAGE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + } + + if(call->remoteH245Port != 0) + { + /* Create an H.245 connection. + */ + if(ooCreateH245Connection(call)== OO_FAILED) + { + OOTRACEERR3("Error: H.245 channel creation failed (%s, %s)\n", + call->callType, call->callToken); + + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_TRANSPORTFAILURE; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + } + + if(q931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent) + { + if (!q931Msg->userInfo->h323_uu_pdu.h245Tunneling) + { + if (OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + OO_CLRFLAG (call->flags, OO_M_TUNNELING); + OOTRACEINFO3("Tunneling is disabled by remote endpoint.(%s, %s)\n", + call->callType, call->callToken); + } + } + } + if (OO_TESTFLAG(call->flags, OO_M_TUNNELING)) + { + OOTRACEDBGB3("Handling tunneled messages in CONNECT. (%s, %s)\n", + call->callType, call->callToken); + ret = ooHandleTunneledH245Messages + (call, &q931Msg->userInfo->h323_uu_pdu); + OOTRACEDBGB3("Finished tunneled messages in Connect. (%s, %s)\n", + call->callType, call->callToken); + + /* + Send TCS as call established and no capability exchange has yet + started. This will be true only when separate h245 connection is not + established and tunneling is being used. + */ + if(call->localTermCapState == OO_LocalTermCapExchange_Idle) + { + /*Start terminal capability exchange and master slave determination */ + ret = ooSendTermCapMsg(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n", + call->callType, call->callToken); + return ret; + } + } + if(call->masterSlaveState == OO_MasterSlave_Idle) + { + ret = ooSendMasterSlaveDetermination(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Master-slave determination message " + "(%s, %s)\n", call->callType, call->callToken); + return ret; + } + } + + } + return OO_OK; +} + +int ooHandleH2250Message(OOH323CallData *call, Q931Message *q931Msg) +{ + int ret=OO_OK; + ASN1UINT i; + DListNode *pNode = NULL; + OOTimer *pTimer=NULL; + int type = q931Msg->messageType; + switch(type) + { + case Q931SetupMsg: /* SETUP message is received */ + OOTRACEINFO3("Received SETUP message (%s, %s)\n", call->callType, + call->callToken); + ooOnReceivedSetup(call, q931Msg); + + /* H225 message callback */ + if(gH323ep.h225Callbacks.onReceivedSetup) + gH323ep.h225Callbacks.onReceivedSetup(call, q931Msg); + + /* Free up the mem used by the received message, as it's processing + is done. + */ + ooFreeQ931Message(q931Msg); + + ooSendCallProceeding(call);/* Send call proceeding message*/ + + /* DISABLEGK is used to selectively disable gatekeeper use. For + incoming calls DISABLEGK can be set in onReceivedSetup callback by + application. Very useful in pbx applications where gk is used only + when call is to or from outside pbx domian + */ + if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK)) + { + if(gH323ep.gkClient->state == GkClientRegistered) + { + ret = ooGkClientSendAdmissionRequest(gH323ep.gkClient, call, + FALSE); + call->callState = OO_CALL_WAITING_ADMISSION; + } + else{ + /* TODO: Should send Release complete with reject reason */ + OOTRACEERR1("Error:Ignoring incoming call as not yet" + "registered with Gk\n"); + } + } + else { + ret = ooH323CallAdmitted (call); + } + break; + + + case Q931CallProceedingMsg: /* CALL PROCEEDING message is received */ + OOTRACEINFO3("H.225 Call Proceeding message received (%s, %s)\n", + call->callType, call->callToken); + ooOnReceivedCallProceeding(call, q931Msg); + + ooFreeQ931Message(q931Msg); + break; + + + case Q931AlertingMsg:/* ALERTING message received */ + OOTRACEINFO3("H.225 Alerting message received (%s, %s)\n", + call->callType, call->callToken); + + ooOnReceivedAlerting(call, q931Msg); + + if(gH323ep.h323Callbacks.onAlerting && call->callStatecallType, call->callToken); + + /* Disable call establishment timer */ + for(i = 0; itimerList.count; i++) + { + pNode = dListFindByIndex(&call->timerList, i); + pTimer = (OOTimer*)pNode->data; + if(((ooTimerCallback*)pTimer->cbData)->timerType & + OO_CALLESTB_TIMER) + { + memFreePtr(call->pctxt, pTimer->cbData); + ooTimerDelete(call->pctxt, &call->timerList, pTimer); + OOTRACEDBGC3("Deleted CallESTB timer. (%s, %s)\n", + call->callType, call->callToken); + break; + } + } + ret = ooOnReceivedSignalConnect(call, q931Msg); + if(ret != OO_OK) + OOTRACEERR3("Error:Invalid Connect message received. (%s, %s)\n", + call->callType, call->callToken); + else{ + /* H225 message callback */ + if(gH323ep.h225Callbacks.onReceivedConnect) + gH323ep.h225Callbacks.onReceivedConnect(call, q931Msg); + + if(gH323ep.h323Callbacks.onCallEstablished) + gH323ep.h323Callbacks.onCallEstablished(call); + } + ooFreeQ931Message(q931Msg); + break; + case Q931InformationMsg: + OOTRACEINFO3("H.225 Information msg received (%s, %s)\n", + call->callType, call->callToken); + ooFreeQ931Message(q931Msg); + break; + + + case Q931ReleaseCompleteMsg:/* RELEASE COMPLETE message received */ + OOTRACEINFO3("H.225 Release Complete message received (%s, %s)\n", + call->callType, call->callToken); + + ooOnReceivedReleaseComplete(call, q931Msg); + + ooFreeQ931Message(q931Msg); + break; + case Q931FacilityMsg: + OOTRACEINFO3("H.225 Facility message Received (%s, %s)\n", + call->callType, call->callToken); + + ooOnReceivedFacility(call, q931Msg); + ooFreeQ931Message(q931Msg); + break; + case Q931ProgressMsg: + OOTRACEINFO3("H.225 Progress message received (%s, %s)\n", + call->callType, call->callToken); + ooFreeQ931Message(q931Msg); + break; + case Q931StatusMsg: + OOTRACEINFO3("H.225 Status message received (%s, %s)\n", + call->callType, call->callToken); + ooFreeQ931Message(q931Msg); + break; + case Q931StatusEnquiryMsg: + OOTRACEINFO3("H.225 Status Inquiry message Received (%s, %s)\n", + call->callType, call->callToken); + ooFreeQ931Message(q931Msg); + break; + case Q931SetupAckMsg: + OOTRACEINFO3("H.225 Setup Ack message received (%s, %s)\n", + call->callType, call->callToken); + ooFreeQ931Message(q931Msg); + break; + case Q931NotifyMsg: + OOTRACEINFO3("H.225 Notify message Received (%s, %s)\n", + call->callType, call->callToken); + ooFreeQ931Message(q931Msg); + break; + default: + OOTRACEWARN3("Invalid H.225 message type received (%s, %s)\n", + call->callType, call->callToken); + ooFreeQ931Message(q931Msg); + } + return ret; +} + +int ooOnReceivedFacility(OOH323CallData *call, Q931Message * pQ931Msg) +{ + H225H323_UU_PDU * pH323UUPdu = NULL; + H225Facility_UUIE * facility = NULL; + int ret; + H225TransportAddress_ipAddress_ip *ip = NULL; + OOTRACEDBGC3("Received Facility Message.(%s, %s)\n", call->callType, + call->callToken); + /* Get Reference to H323_UU_PDU */ + if(!pQ931Msg->userInfo) + { + OOTRACEERR3("Error: UserInfo not found in received H.225 Facility " + "message (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + pH323UUPdu = &pQ931Msg->userInfo->h323_uu_pdu; + if(!pH323UUPdu) + { + OOTRACEERR1("ERROR: H225H323_UU_PDU absent in incoming facility " + "message\n"); + return OO_FAILED; + } + facility = pH323UUPdu->h323_message_body.u.facility; + if(facility) + { + /* Depending on the reason of facility message handle the message */ + if(facility->reason.t == T_H225FacilityReason_transportedInformation) + { + if(OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + OOTRACEDBGB3("Handling tunneled messages in Facility. (%s, %s)\n", + call->callType, call->callToken); + ooHandleTunneledH245Messages(call, pH323UUPdu); + OOTRACEDBGB3("Finished handling tunneled messages in Facility." + "(%s, %s)\n",call->callType, call->callToken); + } + else + { + OOTRACEERR3("ERROR:Tunneled H.245 message received in facility. " + "Tunneling is disabled at local for this call (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + } + else if(facility->reason.t == T_H225FacilityReason_startH245) + { + OOTRACEINFO3("Remote wants to start a separate H.245 Channel " + "(%s, %s)\n", call->callType, call->callToken); + /*start H.245 channel*/ + ret = ooHandleStartH245FacilityMessage(call, facility); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR: Handling startH245 facility message " + "(%s, %s)\n", call->callType, call->callToken); + return ret; + } + } + else if(facility->reason.t == T_H225FacilityReason_callForwarded) + { + OOTRACEINFO3("Call Forward Facility message received. (%s, %s)\n", + call->callType, call->callToken); + if(!facility->m.alternativeAddressPresent && + !facility->m.alternativeAliasAddressPresent) + { + OOTRACEERR3("Error:No alternative address provided in call forward" + "facility message.(%s, %s)\n", call->callType, + call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_INVALIDMESSAGE; + } + return OO_OK; + } + call->pCallFwdData = (OOCallFwdData *) memAlloc(call->pctxt, + sizeof(OOCallFwdData)); + if(!call->pCallFwdData) + { + OOTRACEERR3("Error:Memory - ooOnReceivedFacility - pCallFwdData " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + call->pCallFwdData->fwdedByRemote = TRUE; + call->pCallFwdData->ip[0]='\0'; + call->pCallFwdData->aliases = NULL; + if(facility->m.alternativeAddressPresent) + { + if(facility->alternativeAddress.t != + T_H225TransportAddress_ipAddress) + { + OOTRACEERR3("ERROR: Source call signalling address type not ip " + "(%s, %s)\n", call->callType, call->callToken); + + return OO_FAILED; + } + + ip = &facility->alternativeAddress.u.ipAddress->ip; + sprintf(call->pCallFwdData->ip, "%d.%d.%d.%d", ip->data[0], + ip->data[1], ip->data[2], ip->data[3]); + call->pCallFwdData->port = + facility->alternativeAddress.u.ipAddress->port; + } + + if(facility->m.alternativeAliasAddressPresent) + { + ooH323RetrieveAliases(call, &facility->alternativeAliasAddress, + &call->pCallFwdData->aliases); + } + /* Now we have to clear the current call and make a new call to + fwded location*/ + if(call->callState < OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_REMOTE_FWDED; + } + else{ + OOTRACEERR3("Error:Can't forward call as it is being cleared." + " (%s, %s)\n", call->callType, call->callToken); + return OO_OK; + } + } + else{ + OOTRACEINFO3("Unhandled Facility reason type received (%s, %s)\n", + call->callType, call->callToken); + } + } + else{ /* Empty facility message Check for tunneling */ + OOTRACEDBGB3("Handling tunneled messages in empty Facility message." + " (%s, %s)\n", call->callType, call->callToken); + ooHandleTunneledH245Messages(call, pH323UUPdu); + OOTRACEDBGB3("Finished handling tunneled messages in empty Facility " + "message. (%s, %s)\n", call->callType, call->callToken); + } + + return OO_OK; +} + +int ooHandleStartH245FacilityMessage + (OOH323CallData *call, H225Facility_UUIE *facility) +{ + H225TransportAddress_ipAddress *ipAddress = NULL; + int ret; + + /* Extract H245 address */ + if(!facility->m.h245AddressPresent) + { + OOTRACEERR3("ERROR: startH245 facility message received with no h245 " + "address (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + if(facility->h245Address.t != T_H225TransportAddress_ipAddress) + { + OOTRACEERR3("ERROR:Unknown H245 address type in received startH245 " + "facility message (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ipAddress = facility->h245Address.u.ipAddress; + if(!ipAddress) + { + OOTRACEERR3("ERROR:Invalid startH245 facility message. No H245 ip " + "address found. (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + sprintf(call->remoteIP, "%d.%d.%d.%d", ipAddress->ip.data[0], + ipAddress->ip.data[1], + ipAddress->ip.data[2], + ipAddress->ip.data[3]); + call->remoteH245Port = ipAddress->port; + + /* disable tunneling for this call */ + OO_CLRFLAG (call->flags, OO_M_TUNNELING); + + /*Establish an H.245 connection */ + ret = ooCreateH245Connection(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR: Failed to establish an H.245 connection with remote" + " endpoint (%s, %s)\n", call->callType, call->callToken); + return ret; + } + return OO_OK; +} + +int ooHandleTunneledH245Messages + (OOH323CallData *call, H225H323_UU_PDU * pH323UUPdu) +{ + H245Message *pmsg; + OOCTXT *pctxt = &gH323ep.msgctxt; + int ret=0,i=0; + + OOTRACEDBGC3("Checking for tunneled H.245 messages (%s, %s)\n", + call->callType, call->callToken); + + /* Check whether there are tunneled messages */ + if(pH323UUPdu->m.h245TunnelingPresent) + { + if(pH323UUPdu->h245Tunneling) + { + OOTRACEDBGB4("Total number of tunneled H245 messages are %d.(%s, %s)" + "\n", (int)pH323UUPdu->h245Control.n, call->callType, + call->callToken); + for(i=0; i< (int)pH323UUPdu->h245Control.n; i++) + { + OOTRACEDBGC5("Retrieving %d of %d tunneled H.245 messages." + "(%s, %s)\n",i+1, pH323UUPdu->h245Control.n, + call->callType, call->callToken); + pmsg = (H245Message*)memAlloc(pctxt, sizeof(H245Message)); + if(!pmsg) + { + OOTRACEERR3("Error:Memory - ooHandleH245TunneledMessages - pmsg" + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + setPERBuffer(pctxt, + (ASN1OCTET*)pH323UUPdu->h245Control.elem[i].data, + pH323UUPdu->h245Control.elem[i].numocts, 1); + + initializePrintHandler(&printHandler, "Tunneled H.245 Message"); + memset(pmsg, 0, sizeof(H245Message)); + /* Set event handler */ + setEventHandler (pctxt, &printHandler); + OOTRACEDBGC4("Decoding %d tunneled H245 message. (%s, %s)\n", + i+1, call->callType, call->callToken); + ret = asn1PD_H245MultimediaSystemControlMessage(pctxt, + &(pmsg->h245Msg)); + if(ret != ASN_OK) + { + OOTRACEERR3("Error decoding H245 message (%s, %s)\n", + call->callType, call->callToken); + ooFreeH245Message(call,pmsg); + return OO_FAILED; + } + finishPrint(); + removeEventHandler (pctxt); + ooHandleH245Message(call, pmsg); + memFreePtr(pctxt, pmsg); + pmsg = NULL; + }/* End of For loop */ + }/* End of if(h245Tunneling) */ + } + return OO_OK; +} + +int ooH323RetrieveAliases + (OOH323CallData *call, H225_SeqOfH225AliasAddress *pAddresses, + OOAliases **aliasList) +{ + int i=0,j=0,k=0; + DListNode* pNode=NULL; + H225AliasAddress *pAliasAddress=NULL; + OOAliases *newAlias=NULL; + H225TransportAddress *pTransportAddrss=NULL; + + if(!pAddresses) + { + OOTRACEWARN3("Warn:No Aliases present (%s, %s)\n", call->callType, + call->callToken); + return OO_OK; + } + /* check for aliases */ + if(pAddresses->count<=0) + return OO_OK; + + for(i=0; i<(int)pAddresses->count; i++) + { + pNode = dListFindByIndex (pAddresses, i); + + if(!pNode) + continue; + + pAliasAddress = (H225AliasAddress*)pNode->data; + + if(!pAliasAddress) + continue; + + newAlias = (OOAliases*)memAlloc(call->pctxt, sizeof(OOAliases)); + if(!newAlias) + { + OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - newAlias " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + memset(newAlias, 0, sizeof(OOAliases)); + switch(pAliasAddress->t) + { + case T_H225AliasAddress_dialedDigits: + newAlias->type = T_H225AliasAddress_dialedDigits; + newAlias->value = (char*) memAlloc(call->pctxt, + strlen(pAliasAddress->u.dialedDigits)*sizeof(char)+1); + if(!newAlias->value) + { + OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - " + "newAlias->value(dialedDigits) (%s, %s)\n", + call->callType, call->callToken); + memFreePtr(call->pctxt, newAlias); + return OO_FAILED; + } + + memcpy(newAlias->value, pAliasAddress->u.dialedDigits, + strlen(pAliasAddress->u.dialedDigits)*sizeof(char)); + newAlias->value[strlen(pAliasAddress->u.dialedDigits)*sizeof(char)]='\0'; + break; + case T_H225AliasAddress_h323_ID: + newAlias->type = T_H225AliasAddress_h323_ID; + newAlias->value = (char*)memAlloc(call->pctxt, + (pAliasAddress->u.h323_ID.nchars+1)*sizeof(char)+1); + if(!newAlias->value) + { + OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - " + "newAlias->value(h323id) (%s, %s)\n", call->callType, + call->callToken); + memFreePtr(call->pctxt, newAlias); + return OO_FAILED; + } + + for(j=0, k=0; j<(int)pAliasAddress->u.h323_ID.nchars; j++) + { + if(pAliasAddress->u.h323_ID.data[j] < 256) + { + newAlias->value[k++] = (char) pAliasAddress->u.h323_ID.data[j]; + } + } + newAlias->value[k] = '\0'; + break; + case T_H225AliasAddress_url_ID: + newAlias->type = T_H225AliasAddress_url_ID; + newAlias->value = (char*)memAlloc(call->pctxt, + strlen(pAliasAddress->u.url_ID)*sizeof(char)+1); + if(!newAlias->value) + { + OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - " + "newAlias->value(urlid) (%s, %s)\n", call->callType, + call->callToken); + memFreePtr(call->pctxt, newAlias); + return OO_FAILED; + } + + memcpy(newAlias->value, pAliasAddress->u.url_ID, + strlen(pAliasAddress->u.url_ID)*sizeof(char)); + newAlias->value[strlen(pAliasAddress->u.url_ID)*sizeof(char)]='\0'; + break; + case T_H225AliasAddress_transportID: + newAlias->type = T_H225AliasAddress_transportID; + pTransportAddrss = pAliasAddress->u.transportID; + if(pTransportAddrss->t != T_H225TransportAddress_ipAddress) + { + OOTRACEERR3("Error:Alias transportID not an IP address" + "(%s, %s)\n", call->callType, call->callToken); + memFreePtr(call->pctxt, newAlias); + break; + } + /* hopefully ip:port value can't exceed more than 30 + characters */ + newAlias->value = (char*)memAlloc(call->pctxt, + 30*sizeof(char)); + sprintf(newAlias->value, "%d.%d.%d.%d:%d", + pTransportAddrss->u.ipAddress->ip.data[0], + pTransportAddrss->u.ipAddress->ip.data[1], + pTransportAddrss->u.ipAddress->ip.data[2], + pTransportAddrss->u.ipAddress->ip.data[3], + pTransportAddrss->u.ipAddress->port); + break; + case T_H225AliasAddress_email_ID: + newAlias->type = T_H225AliasAddress_email_ID; + newAlias->value = (char*)memAlloc(call->pctxt, + strlen(pAliasAddress->u.email_ID)*sizeof(char)+1); + if(!newAlias->value) + { + OOTRACEERR3("ERROR:Memory - ooH323RetrieveAliases - " + "newAlias->value(emailid) (%s, %s)\n", call->callType, + call->callToken); + memFreePtr(call->pctxt, newAlias); + return OO_FAILED; + } + + memcpy(newAlias->value, pAliasAddress->u.email_ID, + strlen(pAliasAddress->u.email_ID)*sizeof(char)); + newAlias->value[strlen(pAliasAddress->u.email_ID)*sizeof(char)]='\0'; + break; + default: + OOTRACEERR3("Error:Unhandled Alias type (%s, %s)\n", + call->callType, call->callToken); + memFreePtr(call->pctxt, newAlias); + continue; + } + + newAlias->next = *aliasList; + *aliasList = newAlias; + + newAlias = NULL; + + pAliasAddress = NULL; + pNode = NULL; + }/* endof: for */ + return OO_OK; +} + + +int ooPopulateAliasList(OOCTXT *pctxt, OOAliases *pAliases, + H225_SeqOfH225AliasAddress *pAliasList ) +{ + H225AliasAddress *pAliasEntry=NULL; + OOAliases * pAlias=NULL; + ASN1BOOL bValid=FALSE; + int i = 0; + + dListInit(pAliasList); + if(pAliases) + { + pAlias = pAliases; + while(pAlias) + { + pAliasEntry = (H225AliasAddress*)memAlloc(pctxt, + sizeof(H225AliasAddress)); + if(!pAliasEntry) + { + OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - pAliasEntry\n"); + return OO_FAILED; + } + switch(pAlias->type) + { + case T_H225AliasAddress_dialedDigits: + pAliasEntry->t = T_H225AliasAddress_dialedDigits; + pAliasEntry->u.dialedDigits = (ASN1IA5String)memAlloc(pctxt, + strlen(pAlias->value)+1); + if(!pAliasEntry->u.dialedDigits) + { + OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - " + "dialedDigits\n"); + memFreePtr(pctxt, pAliasEntry); + return OO_FAILED; + } + strcpy((char*)pAliasEntry->u.dialedDigits, pAlias->value); + bValid = TRUE; + break; + case T_H225AliasAddress_h323_ID: + pAliasEntry->t = T_H225AliasAddress_h323_ID; + pAliasEntry->u.h323_ID.nchars = strlen(pAlias->value); + pAliasEntry->u.h323_ID.data = (ASN116BITCHAR*)memAllocZ + (pctxt, strlen(pAlias->value)*sizeof(ASN116BITCHAR)); + + if(!pAliasEntry->u.h323_ID.data) + { + OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - h323_id\n"); + memFreePtr(pctxt, pAliasEntry); + return OO_FAILED; + } + for(i=0; *(pAlias->value+i) != '\0'; i++) + pAliasEntry->u.h323_ID.data[i] =(ASN116BITCHAR)pAlias->value[i]; + bValid = TRUE; + break; + case T_H225AliasAddress_url_ID: + pAliasEntry->t = T_H225AliasAddress_url_ID; + pAliasEntry->u.url_ID = (ASN1IA5String)memAlloc(pctxt, + strlen(pAlias->value)+1); + if(!pAliasEntry->u.url_ID) + { + OOTRACEERR1("ERROR:Memory - ooPopulateAliasList - url_id\n"); + memFreePtr(pctxt, pAliasEntry); + return OO_FAILED; + } + strcpy((char*)pAliasEntry->u.url_ID, pAlias->value); + bValid = TRUE; + break; + case T_H225AliasAddress_email_ID: + pAliasEntry->t = T_H225AliasAddress_email_ID; + pAliasEntry->u.email_ID = (ASN1IA5String)memAlloc(pctxt, + strlen(pAlias->value)+1); + if(!pAliasEntry->u.email_ID) + { + OOTRACEERR1("ERROR: Failed to allocate memory for EmailID " + "alias entry \n"); + return OO_FAILED; + } + strcpy((char*)pAliasEntry->u.email_ID, pAlias->value); + bValid = TRUE; + break; + default: + OOTRACEERR1("ERROR: Unhandled alias type\n"); + bValid = FALSE; + } + + if(bValid) + dListAppend( pctxt, pAliasList, (void*)pAliasEntry ); + else + memFreePtr(pctxt, pAliasEntry); + + pAlias = pAlias->next; + } + } + return OO_OK; +} + + +OOAliases* ooH323GetAliasFromList(OOAliases *aliasList, int type, char *value) +{ + + OOAliases *pAlias = NULL; + + if(!aliasList) + { + OOTRACEDBGC1("No alias List to search\n"); + return NULL; + } + + pAlias = aliasList; + + while(pAlias) + { + if(type != 0 && value) { /* Search by type and value */ + if(pAlias->type == type && !strcmp(pAlias->value, value)) + { + return pAlias; + } + } + else if(type != 0 && !value) {/* search by type */ + if(pAlias->type == type) + return pAlias; + } + else if(type == 0 && value) {/* search by value */ + if(!strcmp(pAlias->value, value)) + return pAlias; + } + else { + OOTRACEDBGC1("No criteria to search the alias list\n"); + return NULL; + } + pAlias = pAlias->next; + } + + return NULL; +} + +OOAliases* ooH323AddAliasToList +(OOAliases **pAliasList, OOCTXT *pctxt, H225AliasAddress *pAliasAddress) +{ + int j=0,k=0; + OOAliases *newAlias=NULL; + H225TransportAddress *pTransportAddrss=NULL; + + newAlias = (OOAliases*) memAlloc(pctxt, sizeof(OOAliases)); + if(!newAlias) + { + OOTRACEERR1("Error: Failed to allocate memory for new alias to be added to the alias list\n"); + return NULL; + } + memset(newAlias, 0, sizeof(OOAliases)); + + switch(pAliasAddress->t) + { + case T_H225AliasAddress_dialedDigits: + newAlias->type = T_H225AliasAddress_dialedDigits; + newAlias->value = (char*) memAlloc(pctxt, strlen(pAliasAddress->u.dialedDigits)*sizeof(char)+1); + strcpy(newAlias->value, pAliasAddress->u.dialedDigits); + break; + case T_H225AliasAddress_h323_ID: + newAlias->type = T_H225AliasAddress_h323_ID; + newAlias->value = (char*)memAlloc(pctxt, + (pAliasAddress->u.h323_ID.nchars+1)*sizeof(char)+1); + + for(j=0, k=0; j<(int)pAliasAddress->u.h323_ID.nchars; j++) + { + if(pAliasAddress->u.h323_ID.data[j] < 256) + { + newAlias->value[k++] = (char) pAliasAddress->u.h323_ID.data[j]; + } + } + newAlias->value[k] = '\0'; + break; + case T_H225AliasAddress_url_ID: + newAlias->type = T_H225AliasAddress_url_ID; + newAlias->value = (char*)memAlloc(pctxt, + strlen(pAliasAddress->u.url_ID)*sizeof(char)+1); + + strcpy(newAlias->value, pAliasAddress->u.url_ID); + break; + case T_H225AliasAddress_transportID: + newAlias->type = T_H225AliasAddress_transportID; + pTransportAddrss = pAliasAddress->u.transportID; + if(pTransportAddrss->t != T_H225TransportAddress_ipAddress) + { + OOTRACEERR1("Error:Alias transportID not an IP address\n"); + memFreePtr(pctxt, newAlias); + return NULL; + } + /* hopefully ip:port value can't exceed more than 30 + characters */ + newAlias->value = (char*)memAlloc(pctxt, + 30*sizeof(char)); + sprintf(newAlias->value, "%d.%d.%d.%d:%d", + pTransportAddrss->u.ipAddress->ip.data[0], + pTransportAddrss->u.ipAddress->ip.data[1], + pTransportAddrss->u.ipAddress->ip.data[2], + pTransportAddrss->u.ipAddress->ip.data[3], + pTransportAddrss->u.ipAddress->port); + break; + case T_H225AliasAddress_email_ID: + newAlias->type = T_H225AliasAddress_email_ID; + newAlias->value = (char*)memAlloc(pctxt, + strlen(pAliasAddress->u.email_ID)*sizeof(char)+1); + + strcpy(newAlias->value, pAliasAddress->u.email_ID); + break; + default: + OOTRACEERR1("Error:Unhandled Alias type \n"); + memFreePtr(pctxt, newAlias); + return NULL; + + } + newAlias->next = *pAliasList; + *pAliasList= newAlias; + return newAlias; +} + +int ooH323GetIpPortFromH225TransportAddress(struct OOH323CallData *call, + H225TransportAddress *h225Address, char *ip, int *port) +{ + if(h225Address->t != T_H225TransportAddress_ipAddress) + { + OOTRACEERR3("Error: Unknown H225 address type. (%s, %s)", call->callType, + call->callToken); + return OO_FAILED; + } + sprintf(ip, "%d.%d.%d.%d", + h225Address->u.ipAddress->ip.data[0], + h225Address->u.ipAddress->ip.data[1], + h225Address->u.ipAddress->ip.data[2], + h225Address->u.ipAddress->ip.data[3]); + *port = h225Address->u.ipAddress->port; + return OO_OK; +} diff --git a/addons/ooh323c/src/ooh323.h b/addons/ooh323c/src/ooh323.h new file mode 100644 index 000000000..8c5a99434 --- /dev/null +++ b/addons/ooh323c/src/ooh323.h @@ -0,0 +1,182 @@ +/* + * 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. + * + *****************************************************************************/ + +/** + * @file ooh323.h + * This file contains functions to support H.225 messages. + */ +#ifndef _OOH323HDR_H_ +#define _OOH323HDR_H_ + +#include "ooasn1.h" +#include "ootypes.h" +#include "ootrace.h" +#include "ooq931.h" +#include "MULTIMEDIA-SYSTEM-CONTROL.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +struct OOH323CallData; + +/** + * @addtogroup q931 + * @{ + */ +/** + * This function is used to process a received SETUP message. + * @param call Pointer to call for which SETUP message is received. + * @param q931Msg Pointer to the received SETUP message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedSetup +(struct OOH323CallData *call, Q931Message *q931Msg); + +/** + * This function is used to process a received CONNECT message. + * It creates H.245 negotiation channel, and starts TCS and MSD + * procedures. + * @param call Pointer to call for which CONNECT message is received. + * @param q931Msg Pointer to the received q931Msg + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedSignalConnect +(struct OOH323CallData* call, Q931Message *q931Msg); + +/** + * This function is used to handle received H.2250 messages. It + * calls helper functions based on the type of message received. + * @param call Pointer to the call for which a H.2250 message is received + * @param q931Msg Pointer to the received q931Msg + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooHandleH2250Message +(struct OOH323CallData *call, Q931Message *q931Msg); + +/** + * This function is used to process a received Facility message. + * @param call Handle to the call for which message has been received. + * @param pQ931Msg Pointer the the received Facility message. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooOnReceivedFacility +(struct OOH323CallData *call, Q931Message * pQ931Msg); + +/** + * This function is used to process tunneled H245 messages + * @param call Handle to the call + * @param pH323UUPdu Pointer to the pdu containing tunneled messages. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooHandleTunneledH245Messages(struct OOH323CallData *call, + H225H323_UU_PDU * pH323UUPdu); + +/** + * This is a helper function used to handle an startH245 Facility message. + * @param call Handle to the call + * @param facility Pointer to the facility message. + */ +EXTERN int ooHandleStartH245FacilityMessage(struct OOH323CallData *call, + H225Facility_UUIE *facility); + +/** + * This function is used to retrieve the aliases from Sequence of alias + * addresses. + * @param call Handle to the call.Null when retrieving registered + * aliases. + * @param pAddresses Pointer to the sequence of alias addresses. + * @param aliasList Handle to alias list to be populated with retrieved + * aliases. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooH323RetrieveAliases + (struct OOH323CallData *call, H225_SeqOfH225AliasAddress *pAddresses, + OOAliases **aliasList); + +/** + * This is a helper function used to populate alias list using aliases. + * @param pctxt Pointer to OOCTXT structure which will be used for memory + * allocations. + * @param pAliases Pointer to aliases to be used for populating list. + * @param pAliasList Pointer to alias list to be populated. + * + * @return OO_OK, on success. OO_FAILED, otherwise. + */ +EXTERN int ooPopulateAliasList(OOCTXT *pctxt, OOAliases *pAliases, + H225_SeqOfH225AliasAddress *pAliasList); + +/** + * This function is used to search a particular alias in the alias list. The + * search can be on the basis of alias type or value or both. + * @param aliasList Handle to the alias list to be searched. + * @param type Type of the alias, if search has to consider type as + * criterion, otherwise 0. + * @param value Value of the alias, if the search has to consider value as + * criterion, NULL otherwise. + */ +EXTERN OOAliases* ooH323GetAliasFromList + (OOAliases *aliasList, int type, char *value); + +/** + * This function is used to add a new alias to alias list. + * @param pAliasList Pointer to Alias list. + * @param pctxt Pointer to OOCTXT structure to be used for memory + * allocation. + * @param pAliasAddress New alias address to be added. + * + * @return Handle to newly added alias or NULL in case of failure. + */ +EXTERN OOAliases* ooH323AddAliasToList +(OOAliases **pAliasList, OOCTXT *pctxt, H225AliasAddress *pAliasAddress); + +/** + * This function is used to retrieve ip address and port number from an + * H225TransportAddress structure. + * @param call Handle to the associated call. + * @param h225Address Pointer to H225TransportAddress structure + * @param ip Pointer to the buffer in which dotted ip address will + * be returned. + * @param port Pointer to the integer in which port value will be + * returned. + * + * @return OO_OK, on success; OO_FAILED, on failure. + */ +int ooH323GetIpPortFromH225TransportAddress(struct OOH323CallData *call, + H225TransportAddress *h225Address, char *ip, int *port); +/** + * @} + */ +#ifdef __cplusplus +} +#endif + +#endif + diff --git a/addons/ooh323c/src/ooh323ep.c b/addons/ooh323c/src/ooh323ep.c new file mode 100644 index 000000000..93e2ec3a3 --- /dev/null +++ b/addons/ooh323c/src/ooh323ep.c @@ -0,0 +1,789 @@ +/* + * 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 "ooh323ep.h" +#include "ootrace.h" +#include "ooCalls.h" +#include "ooCapability.h" +#include "ooGkClient.h" +#include "ooStackCmds.h" +#include "ooCmdChannel.h" +/** Global endpoint structure */ +ooEndPoint gH323ep; + + +extern DList g_TimerList; + +int ooH323EpInitialize + (enum OOCallMode callMode, const char* tracefile) +{ + + memset(&gH323ep, 0, sizeof(ooEndPoint)); + + initContext(&(gH323ep.ctxt)); + initContext(&(gH323ep.msgctxt)); + + if(tracefile) + { + if(strlen(tracefile)>= MAXFILENAME) + { + printf("Error:File name longer than allowed maximum %d\n", + MAXFILENAME-1); + return OO_FAILED; + } + strcpy(gH323ep.traceFile, tracefile); + } + else{ + strcpy(gH323ep.traceFile, DEFAULT_TRACEFILE); + } + + gH323ep.fptraceFile = fopen(gH323ep.traceFile, "w"); + if(gH323ep.fptraceFile == NULL) + { + printf("Error:Failed to open trace file %s for write.\n", + gH323ep.traceFile); + return OO_FAILED; + } + + /* Initialize default port ranges that will be used by stack. + Apps can override these by explicitely setting port ranges + */ + + gH323ep.tcpPorts.start = TCPPORTSSTART; + gH323ep.tcpPorts.max = TCPPORTSEND; + gH323ep.tcpPorts.current=TCPPORTSSTART; + + gH323ep.udpPorts.start = UDPPORTSSTART; + gH323ep.udpPorts.max = UDPPORTSEND; + gH323ep.udpPorts.current = UDPPORTSSTART; + + gH323ep.rtpPorts.start = RTPPORTSSTART; + gH323ep.rtpPorts.max = RTPPORTSEND; + gH323ep.rtpPorts.current = RTPPORTSSTART; + + OO_SETFLAG(gH323ep.flags, OO_M_FASTSTART); + OO_SETFLAG(gH323ep.flags, OO_M_TUNNELING); + OO_SETFLAG(gH323ep.flags, OO_M_AUTOANSWER); + OO_CLRFLAG(gH323ep.flags, OO_M_GKROUTED); + + gH323ep.aliases = NULL; + + gH323ep.termType = DEFAULT_TERMTYPE; + + gH323ep.t35CountryCode = DEFAULT_T35COUNTRYCODE; + + gH323ep.t35Extension = DEFAULT_T35EXTENSION; + + gH323ep.manufacturerCode = DEFAULT_MANUFACTURERCODE; + + gH323ep.productID = DEFAULT_PRODUCTID; + + gH323ep.versionID = OOH323C_VERSION; + + gH323ep.callType = T_H225CallType_pointToPoint; + ooGetLocalIPAddress(gH323ep.signallingIP); + gH323ep.listenPort = DEFAULT_H323PORT; + + gH323ep.listener = NULL; + + ooH323EpSetCallerID(DEFAULT_CALLERID); + + + gH323ep.myCaps = NULL; + gH323ep.noOfCaps = 0; + gH323ep.callList = NULL; + gH323ep.dtmfmode = 0; + gH323ep.callingPartyNumber[0]='\0'; + gH323ep.callMode = callMode; + gH323ep.isGateway = FALSE; + + dListInit(&g_TimerList);/* This is for test application chansetup only*/ + + gH323ep.callEstablishmentTimeout = DEFAULT_CALLESTB_TIMEOUT; + + gH323ep.msdTimeout = DEFAULT_MSD_TIMEOUT; + + gH323ep.tcsTimeout = DEFAULT_TCS_TIMEOUT; + + gH323ep.logicalChannelTimeout = DEFAULT_LOGICALCHAN_TIMEOUT; + + gH323ep.sessionTimeout = DEFAULT_ENDSESSION_TIMEOUT; + gH323ep.ifList = NULL; + + ooSetTraceThreshold(OOTRCLVLINFO); + OO_SETFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED); + + gH323ep.cmdSock = 0; + return OO_OK; +} + +EXTERN int ooH323EpSetAsGateway() +{ + gH323ep.isGateway = TRUE; + return OO_OK; +} + + +int ooH323EpSetLocalAddress(const char* localip, int listenport) +{ + if(localip) + { + strcpy(gH323ep.signallingIP, localip); + OOTRACEINFO2("Signalling IP address is set to %s\n", localip); + } + + if(listenport) + { + gH323ep.listenPort = listenport; + OOTRACEINFO2("Listen port number is set to %d\n", listenport); + } + return OO_OK; +} + +int ooH323EpAddAliasH323ID(const char *h323id) +{ + ooAliases * psNewAlias=NULL; + psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error: Failed to allocate memory for new H323-ID alias\n"); + return OO_FAILED; + } + psNewAlias->type = T_H225AliasAddress_h323_ID; + psNewAlias->registered = FALSE; + psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(h323id)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error: Failed to allocate memory for the new H323-ID alias " + "value\n"); + memFreePtr(&gH323ep.ctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, h323id); + psNewAlias->next = gH323ep.aliases; + gH323ep.aliases = psNewAlias; + OOTRACEDBGA2("Added alias: H323ID - %s\n", h323id); + return OO_OK; +} + +int ooH323EpAddAliasDialedDigits(const char* dialedDigits) +{ + ooAliases * psNewAlias=NULL; + psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error: Failed to allocate memory for new DialedDigits " + "alias\n"); + return OO_FAILED; + } + psNewAlias->type = T_H225AliasAddress_dialedDigits; + psNewAlias->registered = FALSE; + psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(dialedDigits)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error: Failed to allocate memory for the new DialedDigits" + " alias value\n"); + memFreePtr(&gH323ep.ctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, dialedDigits); + psNewAlias->next = gH323ep.aliases; + gH323ep.aliases = psNewAlias; + OOTRACEDBGA2("Added alias: DialedDigits - %s\n", dialedDigits); + return OO_OK; +} + +int ooH323EpAddAliasURLID(const char * url) +{ + ooAliases * psNewAlias=NULL; + psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error: Failed to allocate memory for new URL-ID alias\n"); + return OO_FAILED; + } + psNewAlias->type = T_H225AliasAddress_url_ID; + psNewAlias->registered = FALSE; + psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(url)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error: Failed to allocate memory for the new URL-ID alias" + " value\n"); + memFreePtr(&gH323ep.ctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, url); + psNewAlias->next = gH323ep.aliases; + gH323ep.aliases = psNewAlias; + OOTRACEDBGA2("Added alias: URL-ID - %s\n", url); + return OO_OK; +} + +int ooH323EpAddAliasEmailID(const char * email) +{ + ooAliases * psNewAlias=NULL; + psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error: Failed to allocate memory for new Email-ID alias\n"); + return OO_FAILED; + } + psNewAlias->type = T_H225AliasAddress_email_ID; + psNewAlias->registered = FALSE; + psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(email)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error: Failed to allocate memory for the new Email-ID alias" + " value\n"); + memFreePtr(&gH323ep.ctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, email); + psNewAlias->next = gH323ep.aliases; + gH323ep.aliases = psNewAlias; + OOTRACEDBGA2("Added alias: Email-ID - %s\n", email); + return OO_OK; +} + +int ooH323EpAddAliasTransportID(const char * ipaddress) +{ + ooAliases * psNewAlias=NULL; + psNewAlias = (ooAliases*)memAlloc(&gH323ep.ctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error: Failed to allocate memory for new Transport-ID " + "alias\n"); + return OO_FAILED; + } + psNewAlias->type = T_H225AliasAddress_transportID; + psNewAlias->registered = FALSE; + psNewAlias->value = (char*) memAlloc(&gH323ep.ctxt, strlen(ipaddress)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error: Failed to allocate memory for the new Transport-ID " + "alias value\n"); + memFreePtr(&gH323ep.ctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, ipaddress); + psNewAlias->next = gH323ep.aliases; + gH323ep.aliases = psNewAlias; + OOTRACEDBGA2("Added alias: Transport-ID - %s\n", ipaddress); + return OO_OK; +} + +int ooH323EpClearAllAliases(void) +{ + ooAliases *pAlias = NULL, *pTemp; + if(gH323ep.aliases) + { + pAlias = gH323ep.aliases; + while(pAlias) + { + pTemp = pAlias; + pAlias = pAlias->next; + memFreePtr(&gH323ep.ctxt, pTemp); + } + gH323ep.aliases = NULL; + } + return OO_OK; +} + + +int ooH323EpSetH225MsgCallbacks(OOH225MsgCallbacks h225Callbacks) +{ + gH323ep.h225Callbacks.onReceivedSetup = h225Callbacks.onReceivedSetup; + gH323ep.h225Callbacks.onReceivedConnect = h225Callbacks.onReceivedConnect; + gH323ep.h225Callbacks.onBuiltSetup = h225Callbacks.onBuiltSetup; + gH323ep.h225Callbacks.onBuiltConnect = h225Callbacks.onBuiltConnect; + + return OO_OK; +} + +int ooH323EpSetH323Callbacks(OOH323CALLBACKS h323Callbacks) +{ + gH323ep.h323Callbacks.onNewCallCreated = h323Callbacks.onNewCallCreated; + gH323ep.h323Callbacks.onAlerting = h323Callbacks.onAlerting; + gH323ep.h323Callbacks.onIncomingCall = h323Callbacks.onIncomingCall; + gH323ep.h323Callbacks.onOutgoingCall = h323Callbacks.onOutgoingCall; + gH323ep.h323Callbacks.onCallEstablished = h323Callbacks.onCallEstablished; + gH323ep.h323Callbacks.onCallForwarded = h323Callbacks.onCallForwarded; + gH323ep.h323Callbacks.onCallCleared = h323Callbacks.onCallCleared; + gH323ep.h323Callbacks.openLogicalChannels = h323Callbacks.openLogicalChannels; + gH323ep.h323Callbacks.onReceivedDTMF = h323Callbacks.onReceivedDTMF; + return OO_OK; +} + +int ooH323EpDestroy(void) +{ + /* free any internal memory allocated + close trace file free context structure + */ + OOH323CallData * cur, *temp; + if(OO_TESTFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED)) + { + OOTRACEINFO1("Destroying H323 Endpoint\n"); + if(gH323ep.callList) + { + cur = gH323ep.callList; + while(cur) + { + temp = cur; + cur = cur->next; + temp->callEndReason = OO_REASON_LOCAL_CLEARED; + ooCleanCall(temp); + } + gH323ep.callList = NULL; + } + + + if(gH323ep.listener) + { + ooSocketClose(*(gH323ep.listener)); + gH323ep.listener = NULL; + } + + ooGkClientDestroy(); + + if(gH323ep.fptraceFile) + { + fclose(gH323ep.fptraceFile); + gH323ep.fptraceFile = NULL; + } + + freeContext(&(gH323ep.ctxt)); + + OO_CLRFLAG(gH323ep.flags, OO_M_ENDPOINTCREATED); + } + return OO_OK; +} + +int ooH323EpEnableGkRouted(void) +{ + OO_SETFLAG(gH323ep.flags, OO_M_GKROUTED); + return OO_OK; +} + +int ooH323EpDisableGkRouted(void) +{ + OO_CLRFLAG(gH323ep.flags, OO_M_GKROUTED); + return OO_OK; +} + +int ooH323EpEnableAutoAnswer(void) +{ + OO_SETFLAG(gH323ep.flags, OO_M_AUTOANSWER); + return OO_OK; +} + +int ooH323EpDisableAutoAnswer(void) +{ + OO_CLRFLAG(gH323ep.flags, OO_M_AUTOANSWER); + return OO_OK; +} + +int ooH323EpEnableManualRingback(void) +{ + OO_SETFLAG(gH323ep.flags, OO_M_MANUALRINGBACK); + return OO_OK; +} + + +int ooH323EpDisableManualRingback(void) +{ + OO_CLRFLAG(gH323ep.flags, OO_M_MANUALRINGBACK); + return OO_OK; +} + +int ooH323EpEnableMediaWaitForConnect(void) +{ + OO_SETFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN); + return OO_OK; +} + +int ooH323EpDisableMediaWaitForConnect(void) +{ + OO_CLRFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN); + return OO_OK; +} + +int ooH323EpEnableFastStart(void) +{ + OO_SETFLAG(gH323ep.flags, OO_M_FASTSTART); + return OO_OK; +} + +int ooH323EpDisableFastStart(void) +{ + OO_CLRFLAG(gH323ep.flags, OO_M_FASTSTART); + return OO_OK; +} + +int ooH323EpEnableH245Tunneling(void) +{ + OO_SETFLAG(gH323ep.flags, OO_M_TUNNELING); + return OO_OK; +} + +int ooH323EpDisableH245Tunneling(void) +{ + OO_CLRFLAG(gH323ep.flags, OO_M_TUNNELING); + return OO_OK; +} + +int ooH323EpSetTermType(int value) +{ + gH323ep.termType = value; + return OO_OK; +} + +int ooH323EpSetProductID (const char* productID) +{ + if (0 != productID) { + char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(productID)+1); + strcpy (pstr, productID); + if(gH323ep.productID) + memFreePtr(&gH323ep.ctxt, gH323ep.productID); + gH323ep.productID = pstr; + return OO_OK; + } + else return OO_FAILED; +} + +int ooH323EpSetVersionID (const char* versionID) +{ + if (0 != versionID) { + char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(versionID)+1); + strcpy (pstr, versionID); + if(gH323ep.versionID) + memFreePtr(&gH323ep.ctxt, gH323ep.versionID); + gH323ep.versionID = pstr; + return OO_OK; + } + else return OO_FAILED; +} + +int ooH323EpSetCallerID (const char* callerID) +{ + if (0 != callerID) { + char* pstr = (char*) memAlloc (&gH323ep.ctxt, strlen(callerID)+1); + strcpy (pstr, callerID); + if(gH323ep.callerid) + memFreePtr(&gH323ep.ctxt, gH323ep.callerid); + gH323ep.callerid = pstr; + return OO_OK; + } + else return OO_FAILED; +} + +int ooH323EpSetCallingPartyNumber(const char* number) +{ + int ret=OO_OK; + if(number) + { + strncpy(gH323ep.callingPartyNumber, number, + sizeof(gH323ep.callingPartyNumber)-1); + ret = ooH323EpAddAliasDialedDigits((char*)number); + return ret; + } + else return OO_FAILED; +} + +int ooH323EpSetTraceLevel(int traceLevel) +{ + ooSetTraceThreshold(traceLevel); + return OO_OK; +} + +void ooH323EpPrintConfig(void) +{ + OOTRACEINFO1("H.323 Endpoint Configuration is as follows:\n"); + + OOTRACEINFO2("\tTrace File: %s\n", gH323ep.traceFile); + + if(!OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART)) + { + OOTRACEINFO1("\tFastStart - disabled\n"); + } + else{ + OOTRACEINFO1("\tFastStart - enabled\n"); + } + + if(!OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING)) + { + OOTRACEINFO1("\tH245 Tunneling - disabled\n"); + } + else{ + OOTRACEINFO1("\tH245 Tunneling - enabled\n"); + } + + if(!OO_TESTFLAG(gH323ep.flags, OO_M_MEDIAWAITFORCONN)) + { + OOTRACEINFO1("\tMediaWaitForConnect - disabled\n"); + } + else{ + OOTRACEINFO1("\tMediaWaitForConnect - enabled\n"); + } + + if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER)) + OOTRACEINFO1("\tAutoAnswer - enabled\n"); + else + OOTRACEINFO1("\tAutoAnswer - disabled\n"); + + OOTRACEINFO2("\tTerminal Type - %d\n", gH323ep.termType); + + OOTRACEINFO2("\tT35 CountryCode - %d\n", gH323ep.t35CountryCode); + + OOTRACEINFO2("\tT35 Extension - %d\n", gH323ep.t35Extension); + + OOTRACEINFO2("\tManufacturer Code - %d\n", gH323ep.manufacturerCode); + + OOTRACEINFO2("\tProductID - %s\n", gH323ep.productID); + + OOTRACEINFO2("\tVersionID - %s\n", gH323ep.versionID); + + OOTRACEINFO2("\tLocal signalling IP address - %s\n", gH323ep.signallingIP); + + OOTRACEINFO2("\tH225 ListenPort - %d\n", gH323ep.listenPort); + + OOTRACEINFO2("\tCallerID - %s\n", gH323ep.callerid); + + + OOTRACEINFO2("\tCall Establishment Timeout - %d seconds\n", + gH323ep.callEstablishmentTimeout); + + OOTRACEINFO2("\tMasterSlaveDetermination Timeout - %d seconds\n", + gH323ep.msdTimeout); + + OOTRACEINFO2("\tTerminalCapabilityExchange Timeout - %d seconds\n", + gH323ep.tcsTimeout); + + OOTRACEINFO2("\tLogicalChannel Timeout - %d seconds\n", + gH323ep.logicalChannelTimeout); + + OOTRACEINFO2("\tSession Timeout - %d seconds\n", gH323ep.sessionTimeout); + + return; +} + + +int ooH323EpAddG711Capability(int cap, int txframes, int rxframes, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(NULL, cap, txframes, rxframes, FALSE, + dir, startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, FALSE); +} + +int ooH323EpAddG728Capability(int cap, int txframes, int rxframes, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(NULL, cap, txframes, rxframes, FALSE, + dir, startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, FALSE); +} + +int ooH323EpAddG729Capability(int cap, int txframes, int rxframes, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(NULL, cap, txframes, rxframes, FALSE, + dir, startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, FALSE); +} + + +int ooH323EpAddG7231Capability(int cap, int txframes, int rxframes, + OOBOOL silenceSuppression, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddSimpleCapability(NULL, cap, txframes, rxframes, + silenceSuppression, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, FALSE); +} + +int ooH323EpAddGSMCapability(int cap, ASN1USINT framesPerPkt, + OOBOOL comfortNoise, OOBOOL scrambled, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + return ooCapabilityAddGSMCapability(NULL, cap, framesPerPkt, comfortNoise, + scrambled, dir, startReceiveChannel, + startTransmitChannel, stopReceiveChannel, + stopTransmitChannel, FALSE); +} + + +int ooH323EpAddH263VideoCapability(int cap, unsigned sqcifMPI, + unsigned qcifMPI, unsigned cifMPI, + unsigned cif4MPI, unsigned cif16MPI, + unsigned maxBitRate, int dir, + cb_StartReceiveChannel startReceiveChannel, + cb_StartTransmitChannel startTransmitChannel, + cb_StopReceiveChannel stopReceiveChannel, + cb_StopTransmitChannel stopTransmitChannel) +{ + + return ooCapabilityAddH263VideoCapability(NULL, sqcifMPI, qcifMPI, cifMPI, + cif4MPI, cif16MPI, maxBitRate,dir, + startReceiveChannel, startTransmitChannel, + stopReceiveChannel, stopTransmitChannel, + FALSE); + +} + + +int ooH323EpEnableDTMFRFC2833(int dynamicRTPPayloadType) +{ + return ooCapabilityEnableDTMFRFC2833(NULL, dynamicRTPPayloadType); +} + +int ooH323EpDisableDTMFRFC2833(void) +{ + return ooCapabilityDisableDTMFRFC2833(NULL); +} + +int ooH323EpEnableDTMFH245Alphanumeric() +{ + return ooCapabilityEnableDTMFH245Alphanumeric(NULL); +} + +int ooH323EpDisableDTMFH245Alphanumeric() +{ + return ooCapabilityDisableDTMFH245Alphanumeric(NULL); +} + +int ooH323EpEnableDTMFH245Signal() +{ + return ooCapabilityEnableDTMFH245Signal(NULL); +} + +int ooH323EpDisableDTMFH245Signal() +{ + return ooCapabilityDisableDTMFH245Signal(NULL); +} + +int ooH323EpEnableDTMFQ931Keypad() +{ + return ooCapabilityEnableDTMFQ931Keypad(NULL); +} + +int ooH323EpDisableDTMFQ931Keypad() +{ + return ooCapabilityDisableDTMFQ931Keypad(NULL); +} + +int ooH323EpSetGkClientCallbacks(OOGKCLIENTCALLBACKS gkClientCallbacks) +{ + + if(gH323ep.gkClient) + { + return ooGkClientSetCallbacks(gH323ep.gkClient, gkClientCallbacks); + } + else{ + OOTRACEERR1("Error:Gk Client hasn't been initialized yet\n"); + return OO_FAILED; + } + +} + + + +/* 0-1024 are reserved for well known services */ +int ooH323EpSetTCPPortRange(int base, int max) +{ + if(base <= 1024) + gH323ep.tcpPorts.start = 1025; + else + gH323ep.tcpPorts.start = base; + if(max > 65500) + gH323ep.tcpPorts.max = 65500; + else + gH323ep.tcpPorts.max = max; + + if(gH323ep.tcpPorts.max 65500) + gH323ep.udpPorts.max = 65500; + else + gH323ep.udpPorts.max = max; + + if(gH323ep.udpPorts.max 65500) + gH323ep.rtpPorts.max = 65500; + else + gH323ep.rtpPorts.max = max; + + if(gH323ep.rtpPorts.max +#include + +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + + +static ASN1OBJID gProtocolID = { + 6, { 0, 0, 8, 2250, 0, 4 } +}; + +EXTERN int ooQ931Decode + (OOH323CallData *call, Q931Message* msg, int length, ASN1OCTET *data) +{ + int offset, x; + int rv = ASN_OK; + char number[128]; + OOCTXT *pctxt = &gH323ep.msgctxt; + + dListInit (&msg->ies); /* clear information elements list */ + + if (length < 5) /* Packet too short */ + return Q931_E_TOOSHORT; + + msg->protocolDiscriminator = data[0]; + OOTRACEDBGB2(" protocolDiscriminator = %d\n", msg->protocolDiscriminator); + if (data[1] != 2) /* Call reference must be 2 bytes long */ + return Q931_E_INVCALLREF; + + msg->callReference = ((data[2] & 0x7f) << 8) | data[3]; + + OOTRACEDBGB2(" callReference = %d\n", msg->callReference); + + msg->fromDestination = (data[2] & 0x80) != 0; + if(msg->fromDestination) + OOTRACEDBGB1(" from = destination\n"); + else + OOTRACEDBGB1(" from = originator\n"); + + + msg->messageType = data[4]; + OOTRACEDBGB2(" messageType = %x\n", msg->messageType); + + + /* Have preamble, start getting the informationElements into buffers */ + offset = 5; + while (offset < length) { + Q931InformationElement *ie; + int ieOff = offset; + /* Get field discriminator */ + int discriminator = data[offset++]; + + /* For discriminator with high bit set there is no data */ + if ((discriminator & 0x80) == 0) { + int len = data[offset++], alen; + + if (discriminator == Q931UserUserIE) { + /* Special case of User-user field, there is some confusion here as + the Q931 documentation claims the length is a single byte, + unfortunately all H.323 based apps have a 16 bit length here, so + we allow for said longer length. There is presumably an addendum + to Q931 which describes this, and provides a means to + discriminate between the old 1 byte and the new 2 byte systems. + However, at present we assume it is always 2 bytes until we find + something that breaks it. + */ + len <<= 8; + len |= data[offset++]; + + /* we also have a protocol discriminator, which we ignore */ + offset++; + len--; + } + + /* watch out for negative lengths! (ED, 11/5/03) */ + if (len < 0) { + return Q931_E_INVLENGTH; + } + else if (offset + len > length) { + alen = 0; + len = -len; + rv = Q931_E_INVLENGTH; + } + else alen = len; + + ie = (Q931InformationElement*) + memAlloc (pctxt, sizeof(*ie) - sizeof(ie->data) + alen); + if(!ie) + { + OOTRACEERR3("Error:Memory - ooQ931Decode - ie(%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + ie->discriminator = discriminator; + ie->offset = ieOff; + ie->length = len; + if (alen != 0) + memcpy(ie->data, data + offset, alen); + offset += len; + } + else { + ie = (Q931InformationElement*) memAlloc (pctxt, + sizeof(*ie) - sizeof(ie->data)); + if(!ie) + { + OOTRACEERR3("Error:Memory - ooQ931Decode - ie(%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + ie->discriminator = discriminator; + ie->offset = offset; + ie->length = 0; + } + if(ie->discriminator == Q931BearerCapabilityIE) + { + OOTRACEDBGB1(" Bearer-Capability IE = {\n"); + for(x=0; xlength; x++) + { + if(x==0) + OOTRACEDBGB2(" %x", ie->data[x]); + else + OOTRACEDBGB2(", %x", ie->data[x]); + } + OOTRACEDBGB1(" }\n"); + } + if(ie->discriminator == Q931DisplayIE) + { + OOTRACEDBGB1(" Display IE = {\n"); + OOTRACEDBGB2(" %s\n", ie->data); + OOTRACEDBGB1(" }\n"); + } + + if(ie->discriminator == Q931KeypadIE) + { + OOTRACEDBGB1(" Keypad IE = {\n"); + OOTRACEDBGB2(" %s\n", ie->data); + OOTRACEDBGB1(" }\n"); + if(gH323ep.h323Callbacks.onReceivedDTMF) + { + gH323ep.h323Callbacks.onReceivedDTMF(call, ie->data); + } + } + /* Extract calling party number TODO:Give respect to presentation and + screening indicators ;-) */ + if(ie->discriminator == Q931CallingPartyNumberIE) + { + OOTRACEDBGB1(" CallingPartyNumber IE = {\n"); + if(ie->length < OO_MAX_NUMBER_LENGTH) + { + int numoffset=1; + if(!(0x80 & ie->data[0])) numoffset = 2; + memcpy(number, ie->data+numoffset,ie->length-numoffset); + number[ie->length-numoffset]='\0'; + OOTRACEDBGB2(" %s\n", number); + if(!call->callingPartyNumber) + ooCallSetCallingPartyNumber(call, number); + } + else{ + OOTRACEERR3("Error:Calling party number too long. (%s, %s)\n", + call->callType, call->callToken); + } + OOTRACEDBGB1(" }\n"); + } + + /* Extract called party number */ + if(ie->discriminator == Q931CalledPartyNumberIE) + { + OOTRACEDBGB1(" CalledPartyNumber IE = {\n"); + if(ie->length < OO_MAX_NUMBER_LENGTH) + { + memcpy(number, ie->data+1,ie->length-1); + number[ie->length-1]='\0'; + OOTRACEDBGB2(" %s\n", number); + if(!call->calledPartyNumber) + ooCallSetCalledPartyNumber(call, number); + } + else{ + OOTRACEERR3("Error:Calling party number too long. (%s, %s)\n", + call->callType, call->callToken); + } + OOTRACEDBGB1(" }\n"); + } + + /* Handle Cause ie */ + if(ie->discriminator == Q931CauseIE) + { + msg->causeIE = ie; + OOTRACEDBGB1(" Cause IE = {\n"); + OOTRACEDBGB2(" %s\n", ooGetQ931CauseValueText(ie->data[1]&0x7f)); + OOTRACEDBGB1(" }\n"); + } + + /* TODO: Get rid of ie list.*/ + dListAppend (pctxt, &msg->ies, ie); + if (rv != ASN_OK) + return rv; + } + + /*cisco router sends Q931Notify without UU ie, + we just ignore notify message as of now as handling is optional for + end point*/ + if(msg->messageType != Q931NotifyMsg) + rv = ooDecodeUUIE(msg); + return rv; +} + +EXTERN Q931InformationElement* ooQ931GetIE (const Q931Message* q931msg, + int ieCode) +{ + DListNode* curNode; + unsigned int i; + + for(i = 0, curNode = q931msg->ies.head; i < q931msg->ies.count; i++) { + Q931InformationElement *ie = (Q931InformationElement*) curNode->data; + if (ie->discriminator == ieCode) { + return ie; + } + curNode = curNode->next; + } + return NULL; +} + +char* ooQ931GetMessageTypeName(int messageType, char* buf) { + switch (messageType) { + case Q931AlertingMsg : + strcpy(buf, "Alerting"); + break; + case Q931CallProceedingMsg : + strcpy(buf, "CallProceeding"); + break; + case Q931ConnectMsg : + strcpy(buf, "Connect"); + break; + case Q931ConnectAckMsg : + strcpy(buf, "ConnectAck"); + break; + case Q931ProgressMsg : + strcpy(buf, "Progress"); + break; + case Q931SetupMsg : + strcpy(buf, "Setup"); + break; + case Q931SetupAckMsg : + strcpy(buf, "SetupAck"); + break; + case Q931FacilityMsg : + strcpy(buf, "Facility"); + break; + case Q931ReleaseCompleteMsg : + strcpy(buf, "ReleaseComplete"); + break; + case Q931StatusEnquiryMsg : + strcpy(buf, "StatusEnquiry"); + break; + case Q931StatusMsg : + strcpy(buf, "Status"); + break; + case Q931InformationMsg : + strcpy(buf, "Information"); + break; + case Q931NationalEscapeMsg : + strcpy(buf, "Escape"); + break; + default: + sprintf(buf, "<%u>", messageType); + } + return buf; +} + +char* ooQ931GetIEName(int number, char* buf) { + switch (number) { + case Q931BearerCapabilityIE : + strcpy(buf, "Bearer-Capability"); + break; + case Q931CauseIE : + strcpy(buf, "Cause"); + break; + case Q931FacilityIE : + strcpy(buf, "Facility"); + break; + case Q931ProgressIndicatorIE : + strcpy(buf, "Progress-Indicator"); + break; + case Q931CallStateIE : + strcpy(buf, "Call-State"); + break; + case Q931DisplayIE : + strcpy(buf, "Display"); + break; + case Q931SignalIE : + strcpy(buf, "Signal"); + break; + case Q931CallingPartyNumberIE : + strcpy(buf, "Calling-Party-Number"); + break; + case Q931CalledPartyNumberIE : + strcpy(buf, "Called-Party-Number"); + break; + case Q931RedirectingNumberIE : + strcpy(buf, "Redirecting-Number"); + break; + case Q931UserUserIE : + strcpy(buf, "User-User"); + break; + default: + sprintf(buf, "0x%02x", number); + } + return buf; +} + +EXTERN void ooQ931Print (const Q931Message* q931msg) { + char buf[1000]; + DListNode* curNode; + unsigned int i; + + printf("Q.931 Message:\n"); + printf(" protocolDiscriminator: %i\n", q931msg->protocolDiscriminator); + printf(" callReference: %i\n", q931msg->callReference); + printf(" from: %s\n", (q931msg->fromDestination ? + "destination" : "originator")); + printf(" messageType: %s (0x%X)\n\n", + ooQ931GetMessageTypeName(q931msg->messageType, buf), + q931msg->messageType); + + for(i = 0, curNode = q931msg->ies.head; i < q931msg->ies.count; i++) { + Q931InformationElement *ie = (Q931InformationElement*) curNode->data; + int length = (ie->length >= 0) ? ie->length : -ie->length; + printf(" IE[%i] (offset 0x%X):\n", i, ie->offset); + printf(" discriminator: %s (0x%X)\n", + ooQ931GetIEName(ie->discriminator, buf), ie->discriminator); + printf(" data length: %i\n", length); + + curNode = curNode->next; + printf("\n"); + } +} + +int ooCreateQ931Message(Q931Message **q931msg, int msgType) +{ + OOCTXT *pctxt = &gH323ep.msgctxt; + + *q931msg = (Q931Message*)memAllocZ(pctxt, sizeof(Q931Message)); + + if(!*q931msg) + { + OOTRACEERR1("Error:Memory - ooCreateQ931Message - q931msg\n"); + return OO_FAILED; + } + else + { + (*q931msg)->protocolDiscriminator = 8; + (*q931msg)->fromDestination = FALSE; + (*q931msg)->messageType = msgType; + (*q931msg)->tunneledMsgType = msgType; + (*q931msg)->logicalChannelNo = 0; + (*q931msg)->bearerCapabilityIE = NULL; + (*q931msg)->callingPartyNumberIE = NULL; + (*q931msg)->calledPartyNumberIE = NULL; + (*q931msg)->causeIE = NULL; + return OO_OK; + } +} + + +int ooGenerateCallToken (char *callToken, size_t size) +{ + static int counter = 1; + char aCallToken[200]; + int ret = 0; + + sprintf (aCallToken, "ooh323c_%d", counter++); + + if (counter > OO_MAX_CALL_TOKEN) + counter = 1; + + if ((strlen(aCallToken)+1) < size) + strcpy (callToken, aCallToken); + else { + OOTRACEERR1 ("Error: Insufficient buffer size to generate call token"); + ret = OO_FAILED; + } + + + return ret; +} + +/* CallReference is a two octet field, thus max value can be 0xffff + or 65535 decimal. We restrict max value to 32760, however, this should + not cause any problems as there won't be those many simultaneous calls + CallRef has to be locally unique and generated by caller. +*/ +ASN1USINT ooGenerateCallReference() +{ + static ASN1USINT lastCallRef=0; + ASN1USINT newCallRef=0; + + + if(lastCallRef == 0) + { + /* Generate a new random callRef */ + srand((unsigned)time(0)); + lastCallRef = (ASN1USINT)(rand()%100); + } + else + lastCallRef++; + + /* Note callReference can be at the most 15 bits that is from 0 to 32767. + if we generate number bigger than that, bring it in range. + */ + if(lastCallRef>=32766) + lastCallRef=1; + + newCallRef = lastCallRef; + + + OOTRACEDBGC2("Generated callRef %d\n", newCallRef); + return newCallRef; +} + + +int ooGenerateCallIdentifier(H225CallIdentifier *callid) +{ + ASN1INT64 timestamp; + int i=0; +#ifdef _WIN32 + + SYSTEMTIME systemTime; + GetLocalTime(&systemTime); + SystemTimeToFileTime(&systemTime, (LPFILETIME)×tamp); +#else + struct timeval systemTime; + gettimeofday(&systemTime, NULL); + timestamp = systemTime.tv_sec * 10000000 + systemTime.tv_usec*10; +#endif + + callid->guid.numocts = 16; + callid->guid.data[0] = 'o'; + callid->guid.data[1] = 'o'; + callid->guid.data[2] = 'h'; + callid->guid.data[3] = '3'; + callid->guid.data[4] = '2'; + callid->guid.data[5] = '3'; + callid->guid.data[6] = 'c'; + callid->guid.data[7] = '-'; + + for (i = 8; i < 16; i++) + callid->guid.data[i] = (ASN1OCTET)((timestamp>>((i-8+1)*8))&0xff); + + return OO_OK; + +} + +int ooFreeQ931Message(Q931Message *q931Msg) +{ + if(!q931Msg) + { + memReset(&gH323ep.msgctxt); + } + return OO_OK; +} + +int ooEncodeUUIE(Q931Message *q931msg) +{ + ASN1OCTET msgbuf[1024]; + ASN1OCTET * msgptr=NULL; + int len; + ASN1BOOL aligned = TRUE; + Q931InformationElement* ie=NULL; + OOCTXT *pctxt = &gH323ep.msgctxt; + /* memset(msgbuf, 0, sizeof(msgbuf));*/ + if(!q931msg) + { + OOTRACEERR1("ERROR: Invalid Q931 message in add user-user IE\n"); + return OO_FAILED; + } + + if(!q931msg->userInfo) + { + OOTRACEERR1("ERROR: No User-User IE to encode\n"); + return OO_FAILED; + } + + setPERBuffer(pctxt, msgbuf, sizeof(msgbuf), aligned); + + if(asn1PE_H225H323_UserInformation (pctxt, + q931msg->userInfo)==ASN_OK) + { + OOTRACEDBGC1("UserInfo encoding - successful\n"); + } + else{ + OOTRACEERR1("ERROR: UserInfo encoding failed\n"); + return OO_FAILED; + } + msgptr = encodeGetMsgPtr(pctxt, &len); + + /* Allocate memory to hold complete UserUser Information */ + ie = (Q931InformationElement*)memAlloc (pctxt, + sizeof(*ie) - sizeof(ie->data) + len); + if(ie == NULL) + { + OOTRACEERR1("Error: Memory - ooEncodeUUIE - ie\n"); + return OO_FAILED; + } + ie->discriminator = Q931UserUserIE; + ie->length = len; + memcpy(ie->data, msgptr, len); + /* Add the user to user IE NOTE: ALL IEs SHOULD BE IN ASCENDING ORDER OF + THEIR DISCRIMINATOR AS PER SPEC. + */ + dListInit (&(q931msg->ies)); + if((dListAppend (pctxt, + &(q931msg->ies), ie)) == NULL) + { + OOTRACEERR1("Error: Failed to add UUIE in outgoing message\n"); + return OO_FAILED; + } + + return OO_OK; +} + +int ooDecodeUUIE(Q931Message *q931Msg) +{ + DListNode* curNode; + unsigned int i; + ASN1BOOL aligned=TRUE; + int stat; + Q931InformationElement *ie; + OOCTXT *pctxt = &gH323ep.msgctxt; + if(q931Msg ==NULL) + { + OOTRACEERR1("Error: ooDecodeUUIE failed - NULL q931 message\n"); + return OO_FAILED; + } + + /* Search for UserUser IE */ + for(i = 0, curNode = q931Msg->ies.head; i < q931Msg->ies.count; + i++, curNode = curNode->next) + { + ie = (Q931InformationElement*) curNode->data; + if(ie->discriminator == Q931UserUserIE) + break; + } + if(i == q931Msg->ies.count) + { + OOTRACEERR1("No UserUser IE found in ooDecodeUUIE\n"); + return OO_FAILED; + } + + /* Decode user-user ie */ + q931Msg->userInfo = (H225H323_UserInformation *) memAlloc(pctxt, + sizeof(H225H323_UserInformation)); + if(!q931Msg->userInfo) + { + OOTRACEERR1("ERROR:Memory - ooDecodeUUIE - userInfo\n"); + return OO_FAILED; + } + memset(q931Msg->userInfo, 0, sizeof(H225H323_UserInformation)); + + setPERBuffer (pctxt, ie->data, ie->length, aligned); + + stat = asn1PD_H225H323_UserInformation (pctxt, q931Msg->userInfo); + if(stat != ASN_OK) + { + OOTRACEERR1("Error: UserUser IE decode failed\n"); + return OO_FAILED; + } + OOTRACEDBGC1("UUIE decode successful\n"); + return OO_OK; +} + +#ifndef _COMPACT +static void ooQ931PrintMessage + (OOH323CallData* call, ASN1OCTET *msgbuf, ASN1UINT msglen) +{ + + OOCTXT *pctxt = &gH323ep.msgctxt; + Q931Message q931Msg; + int ret; + + initializePrintHandler(&printHandler, "Q931 Message"); + + /* Set event handler */ + setEventHandler (pctxt, &printHandler); + + setPERBuffer (pctxt, msgbuf, msglen, TRUE); + + ret = ooQ931Decode (call, &q931Msg, msglen, msgbuf); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed decoding Q931 message. (%s, %s)\n", + call->callType, call->callToken); + } + finishPrint(); + removeEventHandler(pctxt); + +} +#endif + + + +int ooEncodeH225Message(OOH323CallData *call, Q931Message *pq931Msg, + char *msgbuf, int size) +{ + int len=0, i=0, j=0, ieLen=0; + int stat=0; + DListNode* curNode=NULL; + + if(!msgbuf || size<200) + { + OOTRACEERR3("Error: Invalid message buffer/size for ooEncodeH245Message." + " (%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + if(pq931Msg->messageType == Q931SetupMsg){ + msgbuf[i++] = OOSetup; + } + else if(pq931Msg->messageType == Q931ConnectMsg){ + msgbuf[i++] = OOConnect; + } + else if(pq931Msg->messageType == Q931CallProceedingMsg){ + msgbuf[i++] = OOCallProceeding; + } + else if(pq931Msg->messageType == Q931AlertingMsg){ + msgbuf[i++] = OOAlert; + } + else if(pq931Msg->messageType == Q931ReleaseCompleteMsg){ + msgbuf[i++] = OOReleaseComplete; + } + else if(pq931Msg->messageType == Q931InformationMsg){ + msgbuf[i++] = OOInformationMessage; + } + else if(pq931Msg->messageType == Q931FacilityMsg){ + msgbuf[i++] = OOFacility; + msgbuf[i++] = pq931Msg->tunneledMsgType; + msgbuf[i++] = pq931Msg->logicalChannelNo>>8; + msgbuf[i++] = pq931Msg->logicalChannelNo; + } + else{ + OOTRACEERR3("Error:Unknow Q931 message type. (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + + stat = ooEncodeUUIE(pq931Msg); + if(stat != OO_OK) + { + OOTRACEERR3("Error:Failed to encode uuie. (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + + msgbuf[i++] = 3; /* TPKT version */ + msgbuf[i++] = 0; /* TPKT resevred */ + /* 1st octet of length, will be populated once len is determined */ + msgbuf[i++] = 0; + /* 2nd octet of length, will be populated once len is determined */ + msgbuf[i++] = 0; + /* Q931 protocol discriminator */ + msgbuf[i++] = pq931Msg->protocolDiscriminator; + msgbuf[i++] = 2; /* length of call ref is two octets */ + msgbuf[i] = (pq931Msg->callReference >> 8); /* populate 1st octet */ + if(!strcmp(call->callType, "incoming")) + msgbuf[i++] |= 0x80; /* fromDestination*/ + else + i++; /* fromOriginator*/ + + + msgbuf[i++] = pq931Msg->callReference; /* populate 2nd octet */ + msgbuf[i++] = pq931Msg->messageType; /* type of q931 message */ + + /* Note: the order in which ies are added is important. It is in the + ascending order of ie codes. + */ + /* Add bearer IE */ + if(pq931Msg->bearerCapabilityIE) + { + msgbuf[i++] = Q931BearerCapabilityIE; /* ie discriminator */ + msgbuf[i++] = pq931Msg->bearerCapabilityIE->length; + memcpy(msgbuf+i, pq931Msg->bearerCapabilityIE->data, + pq931Msg->bearerCapabilityIE->length); + i += pq931Msg->bearerCapabilityIE->length; + } + + /* Add cause IE */ + if(pq931Msg->causeIE) + { + msgbuf[i++] = Q931CauseIE; + msgbuf[i++] = pq931Msg->causeIE->length; + memcpy(msgbuf+i, pq931Msg->causeIE->data, pq931Msg->causeIE->length); + i += pq931Msg->causeIE->length; + } + + /*Add progress indicator IE + if(pq931Msg->messageType == Q931AlertingMsg || pq931Msg->messageType == Q931CallProceedingMsg) + { + msgbuf[i++] = Q931ProgressIndicatorIE; + msgbuf[i++] = 2; //Length is 2 octet + msgbuf[i++] = 0x80; //PI=8 + msgbuf[i++] = 0x88; + }*/ + + /*Add display ie. */ + if(!ooUtilsIsStrEmpty(call->ourCallerId)) + { + msgbuf[i++] = Q931DisplayIE; + ieLen = strlen(call->ourCallerId)+1; + msgbuf[i++] = ieLen; + memcpy(msgbuf+i, call->ourCallerId, ieLen-1); + i += ieLen-1; + msgbuf[i++] = '\0'; + } + + /* Add calling Party ie */ + if(pq931Msg->callingPartyNumberIE) + { + msgbuf[i++] = Q931CallingPartyNumberIE; + msgbuf[i++] = pq931Msg->callingPartyNumberIE->length; + memcpy(msgbuf+i, pq931Msg->callingPartyNumberIE->data, + pq931Msg->callingPartyNumberIE->length); + i += pq931Msg->callingPartyNumberIE->length; + } + + /* Add called Party ie */ + if(pq931Msg->calledPartyNumberIE) + { + msgbuf[i++] = Q931CalledPartyNumberIE; + msgbuf[i++] = pq931Msg->calledPartyNumberIE->length; + memcpy(msgbuf+i, pq931Msg->calledPartyNumberIE->data, + pq931Msg->calledPartyNumberIE->length); + i += pq931Msg->calledPartyNumberIE->length; + } + + /* Add keypad ie */ + if(pq931Msg->keypadIE) + { + msgbuf[i++] = Q931KeypadIE; + msgbuf[i++] = pq931Msg->keypadIE->length; + memcpy(msgbuf+i, pq931Msg->keypadIE->data, pq931Msg->keypadIE->length); + i += pq931Msg->keypadIE->length; + } + + /* Note: Have to fix this, though it works. Need to get rid of ie list. + Right now we only put UUIE in ie list. Can be easily removed. + */ + + for(j = 0, curNode = pq931Msg->ies.head; j < (int)pq931Msg->ies.count; j++) + { + Q931InformationElement *ie = (Q931InformationElement*) curNode->data; + + ieLen = ie->length; + + /* Add the ie discriminator in message buffer */ + msgbuf[i++] = ie->discriminator; + + /* For user-user IE, we have to add protocol discriminator */ + if (ie->discriminator == Q931UserUserIE) + { + ieLen++; /* length includes protocol discriminator octet. */ + msgbuf[i++] = (ieLen>>8); /* 1st octet for length */ + msgbuf[i++] = ieLen; /* 2nd octet for length */ + ieLen--; + msgbuf[i++] = 5; /* protocol discriminator */ + memcpy((msgbuf + i), ie->data, ieLen); + + i += ieLen; + + } + else + { + OOTRACEWARN1("Warning: Only UUIE is supported currently\n"); + return OO_FAILED; + } + } + // len = i+1-4; /* complete message length */ + + + /* Tpkt length octets populated with total length of the message */ + if(msgbuf[0] != OOFacility) + { + len = i-1; + msgbuf[3] = (len >> 8); + msgbuf[4] = len; /* including tpkt header */ + } + else{ + len = i-4; + msgbuf[6] = (len >> 8); + msgbuf[7] = len; + } + +#ifndef _COMPACT + if(msgbuf[0] != OOFacility) + ooQ931PrintMessage (call, msgbuf+5, len-4); + else + ooQ931PrintMessage (call, msgbuf+8, len-4); +#endif + return OO_OK; +} + +int ooSetFastStartResponse(OOH323CallData *pCall, Q931Message *pQ931msg, + ASN1UINT *fsCount, ASN1DynOctStr **fsElem) +{ + OOCTXT *pctxt = &gH323ep.msgctxt; + int ret = 0, i=0, j=0, remoteMediaPort=0, remoteMediaControlPort = 0, dir=0; + char remoteMediaIP[20], remoteMediaControlIP[20]; + DListNode *pNode = NULL; + H245OpenLogicalChannel *olc = NULL, printOlc; + ooH323EpCapability *epCap = NULL; + ASN1DynOctStr *pFS=NULL; + H245H2250LogicalChannelParameters *h2250lcp = NULL; + ooLogicalChannel* pChannel; + + + if(pCall->pFastStartRes) { + ASN1UINT k = 0; + ASN1OCTET* pData; + + /* copy the stored fast start response to structure */ + *fsCount = pCall->pFastStartRes->n; + *fsElem = (ASN1DynOctStr*) + memAlloc(pctxt, pCall->pFastStartRes->n * sizeof(ASN1DynOctStr)); + + for(k = 0; k < pCall->pFastStartRes->n; k ++) { + (*fsElem)[k].numocts = pCall->pFastStartRes->elem[k].numocts; + pData = (ASN1OCTET*) memAlloc( + pctxt, (*fsElem)[k].numocts * sizeof(ASN1OCTET)); + memcpy(pData, + pCall->pFastStartRes->elem[k].data, + pCall->pFastStartRes->elem[k].numocts); + (*fsElem)[k].data = pData; + } + + /* free the stored fast start response */ + if(pQ931msg->messageType == Q931ConnectMsg) { + for(k = 0; k < pCall->pFastStartRes->n; k ++) { + memFreePtr(pCall->pctxt, pCall->pFastStartRes->elem[k].data); + } + memFreePtr(pCall->pctxt, pCall->pFastStartRes->elem); + memFreePtr(pCall->pctxt, pCall->pFastStartRes); + pCall->pFastStartRes = NULL; + } + + return ASN_OK; + } + + + /* If fast start supported and remote endpoint has sent faststart element */ + if(OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART) && + pCall->remoteFastStartOLCs.count>0) + { + pFS = (ASN1DynOctStr*)memAlloc(pctxt, + pCall->remoteFastStartOLCs.count*sizeof(ASN1DynOctStr)); + if(!pFS) + { + OOTRACEERR3("Error:Memory - ooSetFastStartResponse - pFS (%s, %s)\n", + pCall->callType, pCall->callToken); + return OO_FAILED; + } + memset(pFS, 0, pCall->remoteFastStartOLCs.count*sizeof(ASN1DynOctStr)); + + /* Go though all the proposed channels */ + for(i=0, j=0; i<(int)pCall->remoteFastStartOLCs.count; i++) + { + + pNode = dListFindByIndex(&pCall->remoteFastStartOLCs, i); + olc = (H245OpenLogicalChannel*)pNode->data; + + /* Don't support both direction channel */ + if(olc->forwardLogicalChannelParameters.dataType.t != + T_H245DataType_nullData && + olc->m.reverseLogicalChannelParametersPresent) + { + OOTRACEINFO3("Ignoring bidirectional OLC as it is not supported." + "(%s, %s)\n", pCall->callType, pCall->callToken); + continue; + } + + /* Check forward logic channel */ + if(olc->forwardLogicalChannelParameters.dataType.t != + T_H245DataType_nullData) + { + /* Forward Channel - remote transmits - local receives */ + OOTRACEDBGC4("Processing received forward olc %d (%s, %s)\n", + olc->forwardLogicalChannelNumber, pCall->callType, + pCall->callToken); + dir = OORX; + epCap = ooIsDataTypeSupported(pCall, + &olc->forwardLogicalChannelParameters.dataType, + OORX); + + if(!epCap) { continue; } /* Not Supported Channel */ + + OOTRACEINFO1("Receive Channel data type supported\n"); + if(olc->forwardLogicalChannelParameters.multiplexParameters.t != + T_H245OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters) + { + OOTRACEERR4("ERROR:Unknown multiplex parameter type for " + "channel %d (%s, %s)\n", + olc->forwardLogicalChannelNumber, + pCall->callType, pCall->callToken); + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + continue; + } + h2250lcp = olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters; + + /* Check session is Not already established */ + if(ooIsSessionEstablished(pCall, olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, "receive")) + { + + OOTRACEINFO4("Receive channel with sessionID %d already " + "established.(%s, %s)\n", olc->forwardLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, + pCall->callType, pCall->callToken); + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + continue; + } + + /* Extract mediaControlChannel info, if supplied */ + if(h2250lcp->m.mediaControlChannelPresent) + { + if(OO_OK != ooGetIpPortFromH245TransportAddress(pCall, + &h2250lcp->mediaControlChannel, + remoteMediaControlIP, &remoteMediaControlPort)) + { + OOTRACEERR3("Error: Invalid media control channel address " + "(%s, %s)\n", pCall->callType, pCall->callToken); + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + continue; + } + } + } + /* Check reverse logical channel */ + else if(olc->m.reverseLogicalChannelParametersPresent) + { + /* Reverse channel - remote receives - local transmits */ + OOTRACEDBGC4("Processing received reverse olc %d (%s, %s)\n", + olc->forwardLogicalChannelNumber, pCall->callType, + pCall->callToken); + dir = OOTX; + epCap = ooIsDataTypeSupported(pCall, + &olc->reverseLogicalChannelParameters.dataType, + OOTX); + + if(!epCap) { continue; } /* Capability not supported */ + + OOTRACEINFO1("Transmit Channel data type supported\n"); + + if(olc->reverseLogicalChannelParameters.multiplexParameters.t != + T_H245OpenLogicalChannel_reverseLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters) + { + OOTRACEERR4("ERROR:Unknown multiplex parameter type for " + "channel %d (%s, %s)\n", + olc->forwardLogicalChannelNumber, + pCall->callType, pCall->callToken); + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + continue; + } + + /* Check session is not established */ + if(ooIsSessionEstablished(pCall, olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, "transmit")) + { + + OOTRACEINFO4("Transmit session with sessionID %d already " + "established.(%s, %s)\n", olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters->sessionID, pCall->callType, pCall->callToken); + + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + continue; + } + + /* Extract the remote media endpoint address */ + h2250lcp = olc->reverseLogicalChannelParameters.multiplexParameters.u.h2250LogicalChannelParameters; + if(!h2250lcp) + { + OOTRACEERR3("ERROR:Invalid OLC received in fast start. No " + "reverse Logical Channel Parameters found. " + "(%s, %s)\n", pCall->callType, pCall->callToken); + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + return OO_FAILED; + } + + /* Reverse Channel info will be always present, crash proof */ + if(!h2250lcp->m.mediaChannelPresent) + { + OOTRACEERR3("ERROR:Invalid OLC received in fast start. No " + "reverse media channel information found. " + "(%s, %s)\n", pCall->callType, pCall->callToken); + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + return OO_FAILED; + } + + /* Get IP, PORT of reverse channel */ + if(OO_OK != ooGetIpPortFromH245TransportAddress(pCall, + &h2250lcp->mediaChannel, + remoteMediaIP, &remoteMediaPort)) + { + OOTRACEERR3("Error: Invalid media channel address " + "(%s, %s)\n", pCall->callType, pCall->callToken); + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + continue; + } + + /* Extract mediaControlChannel info, if supplied */ + if(h2250lcp->m.mediaControlChannelPresent) + { + if(OO_OK != ooGetIpPortFromH245TransportAddress(pCall, + &h2250lcp->mediaControlChannel, + remoteMediaControlIP, &remoteMediaControlPort)) + { + OOTRACEERR3("Error: Invalid media control channel address " + "(%s, %s)\n", pCall->callType, pCall->callToken); + memFreePtr(pCall->pctxt, epCap); + epCap = NULL; + continue; + } + } + } + + if(dir & OOTX) + { + /* According to the spec if we are accepting olc for transmission + from called endpoint to calling endpoint, called endpoint should + insert a unqiue forwardLogicalChannelNumber into olc + */ + olc->forwardLogicalChannelNumber = pCall->logicalChanNoCur++; + if(pCall->logicalChanNoCur > pCall->logicalChanNoMax) + pCall->logicalChanNoCur = pCall->logicalChanNoBase; + } + + + ooPrepareFastStartResponseOLC(pCall, olc, epCap, pctxt, dir); + + pChannel = ooFindLogicalChannelByLogicalChannelNo + (pCall, olc->forwardLogicalChannelNumber); + + /* start receive and tramsmit channel listening */ + if(dir & OORX) + { + strcpy(pChannel->remoteIP, remoteMediaControlIP); + pChannel->remoteMediaControlPort = remoteMediaControlPort; + if(epCap->startReceiveChannel) + { + epCap->startReceiveChannel(pCall, pChannel); + OOTRACEINFO4("Receive channel of type %s started (%s, %s)\n", + (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", + pCall->callType, pCall->callToken); + } + else{ + OOTRACEERR4("ERROR:No callback registered to start receive %s" + " channel (%s, %s)\n", + (epCap->capType == OO_CAP_TYPE_AUDIO)?"audio":"video", + pCall->callType, pCall->callToken); + return OO_FAILED; + } + } + if(dir & OOTX) + { + pChannel->remoteMediaPort = remoteMediaPort; + strcpy(pChannel->remoteIP, remoteMediaIP); + pChannel->remoteMediaControlPort = remoteMediaControlPort; + + if(epCap->startTransmitChannel) + { + epCap->startTransmitChannel(pCall, pChannel); + OOTRACEINFO3("Transmit channel of type audio started " + "(%s, %s)\n", pCall->callType, pCall->callToken); + /*OO_SETFLAG (pCall->flags, OO_M_AUDIO);*/ + } + else{ + OOTRACEERR3("ERROR:No callback registered to start transmit" + " audio channel (%s, %s)\n", pCall->callType, + pCall->callToken); + return OO_FAILED; + } + } + + /* Encode fast start element */ + setPERBuffer(pctxt, NULL, 0, 1); + if(asn1PE_H245OpenLogicalChannel(pctxt, olc) != ASN_OK) + { + OOTRACEERR3("ERROR:Encoding of olc failed for faststart " + "(%s, %s)\n", pCall->callType, pCall->callToken); + ooFreeQ931Message(pQ931msg); + if(pCall->callState < OO_CALL_CLEAR) + { + pCall->callEndReason = OO_REASON_LOCAL_CLEARED; + pCall->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + pFS[j].data = encodeGetMsgPtr(pctxt, &(pFS[j].numocts)); + + + /* start print call */ + setPERBuffer(pctxt, (char*)pFS[j].data, pFS[j].numocts, 1); + initializePrintHandler(&printHandler, "FastStart Element"); + setEventHandler (pctxt, &printHandler); + memset(&printOlc, 0, sizeof(printOlc)); + ret = asn1PD_H245OpenLogicalChannel(pctxt, &(printOlc)); + if(ret != ASN_OK) + { + OOTRACEERR3("Error: Failed decoding FastStart Element (%s, %s)\n", + pCall->callType, pCall->callToken); + ooFreeQ931Message(pQ931msg); + if(pCall->callState < OO_CALL_CLEAR) + { + pCall->callEndReason = OO_REASON_LOCAL_CLEARED; + pCall->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + finishPrint(); + removeEventHandler(pctxt); + /* end print call */ + + olc = NULL; + j++; + epCap = NULL; + } + OOTRACEDBGA4("Added %d fast start elements to message " + "(%s, %s)\n", j, pCall->callType, pCall->callToken); + if(j != 0) + { + ASN1UINT k = 0; + ASN1OCTET* pData; + //*fsPresent = TRUE; + *fsCount = j; + *fsElem = pFS; + + /* save the fast start response for later use in ALERTING, CONNECT */ + pCall->pFastStartRes = (FastStartResponse*) + memAlloc(pCall->pctxt, sizeof(FastStartResponse)); + pCall->pFastStartRes->n = j; + pCall->pFastStartRes->elem = (ASN1DynOctStr*) memAlloc(pCall->pctxt, + pCall->pFastStartRes->n * sizeof(ASN1DynOctStr)); + + for(k = 0; k < pCall->pFastStartRes->n; k ++) { + pCall->pFastStartRes->elem[k].numocts = (*fsElem)[k].numocts; + pData = (ASN1OCTET*) memAlloc(pCall->pctxt, + pCall->pFastStartRes->elem[k].numocts * sizeof(ASN1OCTET)); + memcpy(pData, (*fsElem)[k].data, (*fsElem)[k].numocts); + pCall->pFastStartRes->elem[k].data = pData; + } + } + else{ + OOTRACEINFO3("None of the faststart elements received in setup can be" + " supported, rejecting faststart.(%s, %s)\n", + pCall->callType, pCall->callToken); + //*fsPresent = FALSE; + OO_CLRFLAG(pCall->flags, OO_M_FASTSTART); + OOTRACEDBGC3("Faststart for pCall is disabled by local endpoint." + "(%s, %s)\n", pCall->callType, pCall->callToken); + } + } + return ASN_OK; +} + + +/* + +*/ + +int ooSendCallProceeding(OOH323CallData *call) +{ + int ret; + H225VendorIdentifier *vendor; + H225CallProceeding_UUIE *callProceeding; + Q931Message *q931msg=NULL; + OOCTXT *pctxt = &gH323ep.msgctxt; + + OOTRACEDBGC3("Building CallProceeding (%s, %s)\n", call->callType, + call->callToken); + ret = ooCreateQ931Message(&q931msg, Q931CallProceedingMsg); + if(ret != OO_OK) + { + OOTRACEERR1("Error: In allocating memory for - H225 Call " + "Proceeding message\n"); + return OO_FAILED; + } + + q931msg->callReference = call->callReference; + + q931msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt, + sizeof(H225H323_UserInformation)); + if(!q931msg->userInfo) + { + OOTRACEERR1("ERROR:Memory - ooSendCallProceeding - userInfo\n"); + return OO_FAILED; + } + memset (q931msg->userInfo, 0, sizeof(H225H323_UserInformation)); + q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; + q931msg->userInfo->h323_uu_pdu.h245Tunneling = + OO_TESTFLAG(gH323ep.flags, OO_M_TUNNELING); + q931msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_callProceeding; + + callProceeding = (H225CallProceeding_UUIE*)memAlloc(pctxt, + sizeof(H225CallProceeding_UUIE)); + if(!callProceeding) + { + OOTRACEERR1("ERROR:Memory - ooSendCallProceeding - callProceeding\n"); + return OO_FAILED; + } + memset(callProceeding, 0, sizeof(H225CallProceeding_UUIE)); + q931msg->userInfo->h323_uu_pdu.h323_message_body.u.callProceeding = callProceeding; + callProceeding->m.multipleCallsPresent = 1; + callProceeding->m.maintainConnectionPresent = 1; + callProceeding->multipleCalls = FALSE; + callProceeding->maintainConnection = FALSE; + + callProceeding->m.callIdentifierPresent = 1; + callProceeding->callIdentifier.guid.numocts = + call->callIdentifier.guid.numocts; + memcpy(callProceeding->callIdentifier.guid.data, + call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + callProceeding->protocolIdentifier = gProtocolID; + + /* Pose as Terminal or Gateway */ + if(gH323ep.isGateway) + callProceeding->destinationInfo.m.gatewayPresent = TRUE; + else + callProceeding->destinationInfo.m.terminalPresent = TRUE; + + callProceeding->destinationInfo.m.vendorPresent = 1; + vendor = &callProceeding->destinationInfo.vendor; + if(gH323ep.productID) + { + vendor->m.productIdPresent = 1; + vendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), + sizeof(vendor->productId.data)); + strncpy(vendor->productId.data, gH323ep.productID, + vendor->productId.numocts); + } + if(gH323ep.versionID) + { + vendor->m.versionIdPresent = 1; + vendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), + sizeof(vendor->versionId.data)); + strncpy(vendor->versionId.data, gH323ep.versionID, + vendor->versionId.numocts); + } + + vendor->vendor.t35CountryCode = gH323ep.t35CountryCode; + vendor->vendor.t35Extension = gH323ep.t35Extension; + vendor->vendor.manufacturerCode = gH323ep.manufacturerCode; + + OOTRACEDBGA3("Built Call Proceeding(%s, %s)\n", call->callType, + call->callToken); + ret = ooSendH225Msg(call, q931msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue CallProceeding message to outbound queue.(%s, %s)\n", call->callType, call->callToken); + } + + memReset(&gH323ep.msgctxt); + + return ret; +} + +int ooSendAlerting(OOH323CallData *call) +{ + int ret; + H225Alerting_UUIE *alerting; + H225VendorIdentifier *vendor; + Q931Message *q931msg=NULL; + OOCTXT *pctxt = &gH323ep.msgctxt; + + ret = ooCreateQ931Message(&q931msg, Q931AlertingMsg); + if(ret != OO_OK) + { + OOTRACEERR1("Error: In allocating memory for - H225 " + "Alerting message\n"); + return OO_FAILED; + } + + q931msg->callReference = call->callReference; + + q931msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt, + sizeof(H225H323_UserInformation)); + if(!q931msg->userInfo) + { + OOTRACEERR1("ERROR:Memory - ooSendAlerting - userInfo\n"); + return OO_FAILED; + } + memset (q931msg->userInfo, 0, sizeof(H225H323_UserInformation)); + q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; + q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG(gH323ep.flags, + OO_M_TUNNELING); + q931msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_alerting; + + alerting = (H225Alerting_UUIE*)memAlloc(pctxt, + sizeof(H225Alerting_UUIE)); + if(!alerting) + { + OOTRACEERR1("ERROR:Memory - ooSendAlerting - alerting\n"); + return OO_FAILED; + } + memset(alerting, 0, sizeof(H225Alerting_UUIE)); + q931msg->userInfo->h323_uu_pdu.h323_message_body.u.alerting = alerting; + alerting->m.multipleCallsPresent = 1; + alerting->m.maintainConnectionPresent = 1; + alerting->multipleCalls = FALSE; + alerting->maintainConnection = FALSE; + + /*Populate aliases */ + alerting->m.alertingAddressPresent = TRUE; + if(call->ourAliases) + ret = ooPopulateAliasList(pctxt, call->ourAliases, + &alerting->alertingAddress); + else + ret = ooPopulateAliasList(pctxt, gH323ep.aliases, + &alerting->alertingAddress); + if(OO_OK != ret) + { + OOTRACEERR1("Error:Failed to populate alias list in Alert message\n"); + memReset(pctxt); + return OO_FAILED; + } + alerting->m.presentationIndicatorPresent = TRUE; + alerting->presentationIndicator.t = + T_H225PresentationIndicator_presentationAllowed; + alerting->m.screeningIndicatorPresent = TRUE; + alerting->screeningIndicator = userProvidedNotScreened; + + + + alerting->m.callIdentifierPresent = 1; + alerting->callIdentifier.guid.numocts = + call->callIdentifier.guid.numocts; + memcpy(alerting->callIdentifier.guid.data, + call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + alerting->protocolIdentifier = gProtocolID; + + /* Pose as Terminal or Gateway */ + if(gH323ep.isGateway) + alerting->destinationInfo.m.gatewayPresent = TRUE; + else + alerting->destinationInfo.m.terminalPresent = TRUE; + + alerting->destinationInfo.m.vendorPresent = 1; + vendor = &alerting->destinationInfo.vendor; + if(gH323ep.productID) + { + vendor->m.productIdPresent = 1; + vendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), + sizeof(vendor->productId.data)); + strncpy(vendor->productId.data, gH323ep.productID, + vendor->productId.numocts); + } + if(gH323ep.versionID) + { + vendor->m.versionIdPresent = 1; + vendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), + sizeof(vendor->versionId.data)); + strncpy(vendor->versionId.data, gH323ep.versionID, + vendor->versionId.numocts); + } + + vendor->vendor.t35CountryCode = gH323ep.t35CountryCode; + vendor->vendor.t35Extension = gH323ep.t35Extension; + vendor->vendor.manufacturerCode = gH323ep.manufacturerCode; + + ret = ooSetFastStartResponse(call, q931msg, + &alerting->fastStart.n, &alerting->fastStart.elem); + if(ret != ASN_OK) { return ret; } + if(alerting->fastStart.n > 0) { + alerting->m.fastStartPresent = TRUE; + } + else { + alerting->m.fastStartPresent = FALSE; + } + + OOTRACEDBGA3("Built Alerting (%s, %s)\n", call->callType, call->callToken); + + ret = ooSendH225Msg(call, q931msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error: Failed to enqueue Alerting message to outbound queue. (%s, %s)\n", call->callType, call->callToken); + } + + memReset(&gH323ep.msgctxt); + + return ret; +} + + +int ooSendFacility(OOH323CallData *call) +{ + int ret=0; + Q931Message *pQ931Msg = NULL; + H225Facility_UUIE *facility=NULL; + OOCTXT *pctxt = &gH323ep.msgctxt; + + OOTRACEDBGA3("Building Facility message (%s, %s)\n", call->callType, + call->callToken); + ret = ooCreateQ931Message(&pQ931Msg, Q931FacilityMsg); + if(ret != OO_OK) + { + OOTRACEERR3 + ("ERROR: In allocating memory for facility message (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + pQ931Msg->callReference = call->callReference; + + pQ931Msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt, + sizeof(H225H323_UserInformation)); + if(!pQ931Msg->userInfo) + { + OOTRACEERR3("ERROR:Memory - ooSendFacility - userInfo(%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + memset (pQ931Msg->userInfo, 0, sizeof(H225H323_UserInformation)); + pQ931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; + + pQ931Msg->userInfo->h323_uu_pdu.h245Tunneling = + OO_TESTFLAG (call->flags, OO_M_TUNNELING); + + pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_facility; + + facility = (H225Facility_UUIE*) + memAllocZ (pctxt, sizeof(H225Facility_UUIE)); + + if(!facility) + { + OOTRACEERR3("ERROR:Memory - ooSendFacility - facility (%s, %s)" + "\n", call->callType, call->callToken); + return OO_FAILED; + } + + pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.u.facility = facility; + + /* Populate Facility UUIE */ + facility->protocolIdentifier = gProtocolID; + facility->m.callIdentifierPresent = 1; + facility->callIdentifier.guid.numocts = + call->callIdentifier.guid.numocts; + memcpy(facility->callIdentifier.guid.data, + call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + facility->reason.t = T_H225FacilityReason_transportedInformation; + OOTRACEDBGA3("Built Facility message to send (%s, %s)\n", call->callType, + call->callToken); + + ret = ooSendH225Msg(call, pQ931Msg); + if(ret != OO_OK) + { + OOTRACEERR3 + ("Error:Failed to enqueue Facility message to outbound " + "queue.(%s, %s)\n", call->callType, call->callToken); + } + memReset (&gH323ep.msgctxt); + return ret; +} + +int ooSendReleaseComplete(OOH323CallData *call) +{ + int ret; + Q931Message *q931msg=NULL; + H225ReleaseComplete_UUIE *releaseComplete; + enum Q931CauseValues cause = Q931ErrorInCauseIE; + unsigned h225ReasonCode = T_H225ReleaseCompleteReason_undefinedReason; + + OOCTXT *pctxt = &gH323ep.msgctxt; + OOTRACEDBGA3("Building Release Complete message to send(%s, %s)\n", + call->callType, call->callToken); + ret = ooCreateQ931Message(&q931msg, Q931ReleaseCompleteMsg); + if(ret != OO_OK) + { + OOTRACEERR3("Error: In ooCreateQ931Message - H225 Release Complete " + "message(%s, %s)\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + + q931msg->callReference = call->callReference; + + q931msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt, + sizeof(H225H323_UserInformation)); + if(!q931msg->userInfo) + { + OOTRACEERR1("ERROR:Memory - ooSendReleaseComplete - userInfo\n"); + return OO_FAILED; + } + memset (q931msg->userInfo, 0, sizeof(H225H323_UserInformation)); + + releaseComplete = (H225ReleaseComplete_UUIE*)memAlloc(pctxt, + sizeof(H225ReleaseComplete_UUIE)); + if(!releaseComplete) + { + OOTRACEERR3("Error:Memory - ooSendReleaseComplete - releaseComplete" + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + memset(releaseComplete, 0, sizeof(H225ReleaseComplete_UUIE)); + q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; + q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG(gH323ep.flags, + OO_M_TUNNELING); + q931msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_releaseComplete; + + /* Get cause value and h225 reason code corresponding to OOCallClearReason*/ + ooQ931GetCauseAndReasonCodeFromCallClearReason(call->callEndReason, + &cause, &h225ReasonCode); + /* Set Cause IE */ + ooQ931SetCauseIE(q931msg, cause, 0, 0); + + /* Set H225 releaseComplete reasonCode */ + releaseComplete->m.reasonPresent = TRUE; + releaseComplete->reason.t = h225ReasonCode; + + /* Add user-user ie */ + q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=TRUE; + q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG (call->flags, OO_M_TUNNELING); + q931msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_releaseComplete; + + q931msg->userInfo->h323_uu_pdu.h323_message_body.u.releaseComplete = + releaseComplete; + releaseComplete->m.callIdentifierPresent = 1; + releaseComplete->protocolIdentifier = gProtocolID; + releaseComplete->callIdentifier.guid.numocts = + call->callIdentifier.guid.numocts; + memcpy(releaseComplete->callIdentifier.guid.data, + call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + + OOTRACEDBGA3("Built Release Complete message (%s, %s)\n", + call->callType, call->callToken); + /* Send H225 message */ + ret = ooSendH225Msg(call, q931msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue ReleaseComplete message to outbound" + " queue.(%s, %s)\n", call->callType, call->callToken); + } + memReset(&gH323ep.msgctxt); + + return ret; +} + +int ooSendConnect(OOH323CallData *call) +{ + ooAcceptCall(call); + return OO_OK; +} + +/*TODO: Need to clean logical channel in case of failure after creating one */ +int ooAcceptCall(OOH323CallData *call) +{ + int ret = 0, i=0; + H225Connect_UUIE *connect; + H225TransportAddress_ipAddress *h245IpAddr; + H225VendorIdentifier *vendor; + Q931Message *q931msg=NULL; + OOCTXT *pctxt = &gH323ep.msgctxt; + + ret = ooCreateQ931Message(&q931msg, Q931ConnectMsg); + if(ret != OO_OK) + { + OOTRACEERR1("Error: In allocating memory for - H225 " + "Connect message\n"); + return OO_FAILED; + } + q931msg->callReference = call->callReference; + + /* Set bearer capability */ + if(OO_OK != ooSetBearerCapabilityIE(q931msg, Q931CCITTStd, + Q931TransferUnrestrictedDigital, Q931TransferPacketMode, + Q931TransferRatePacketMode, Q931UserInfoLayer1G722G725)) + // Q931TransferSpeech, Q931TransferCircuitMode, + // Q931TransferRate64Kbps, Q931UserInfoLayer1G711ULaw)) + { + OOTRACEERR3("Error: Failed to set bearer capability ie. (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + q931msg->userInfo = (H225H323_UserInformation*) + memAllocZ (pctxt,sizeof(H225H323_UserInformation)); + + if(!q931msg->userInfo) + { + OOTRACEERR1("ERROR:Memory - ooAcceptCall - userInfo\n"); + return OO_FAILED; + } + + q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=TRUE; + + q931msg->userInfo->h323_uu_pdu.h245Tunneling = + OO_TESTFLAG (call->flags, OO_M_TUNNELING); + + q931msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_connect; + + connect = (H225Connect_UUIE*) + memAllocZ (pctxt, sizeof(H225Connect_UUIE)); + + if(!connect) + { + OOTRACEERR1("ERROR:Memory - ooAcceptCall - connect\n"); + return OO_FAILED; + } + + q931msg->userInfo->h323_uu_pdu.h323_message_body.u.connect = connect; + connect->m.fastStartPresent = 0; + connect->m.multipleCallsPresent = 1; + connect->m.maintainConnectionPresent = 1; + connect->multipleCalls = FALSE; + connect->maintainConnection = FALSE; + + + connect->conferenceID.numocts = 16; + for (i = 0; i < 16; i++) + connect->conferenceID.data[i] = i + 1; + + connect->m.callIdentifierPresent = 1; + connect->callIdentifier.guid.numocts = + call->callIdentifier.guid.numocts; + memcpy(connect->callIdentifier.guid.data, call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + + connect->conferenceID.numocts = call->confIdentifier.numocts; + memcpy(connect->conferenceID.data, call->confIdentifier.data, + call->confIdentifier.numocts); + /* Populate alias addresses */ + connect->m.connectedAddressPresent = TRUE; + if(call->ourAliases) + ret = ooPopulateAliasList(pctxt, call->ourAliases, + &connect->connectedAddress); + else + ret = ooPopulateAliasList(pctxt, gH323ep.aliases, + &connect->connectedAddress); + if(OO_OK != ret) + { + OOTRACEERR1("Error:Failed to populate alias list in Connect message\n"); + memReset(pctxt); + return OO_FAILED; + } + connect->m.presentationIndicatorPresent = TRUE; + connect->presentationIndicator.t = + T_H225PresentationIndicator_presentationAllowed; + connect->m.screeningIndicatorPresent = TRUE; + connect->screeningIndicator = userProvidedNotScreened; + + connect->protocolIdentifier = gProtocolID; + + /* Pose as Terminal or Gateway */ + if(gH323ep.isGateway) + connect->destinationInfo.m.gatewayPresent = TRUE; + else + connect->destinationInfo.m.terminalPresent = TRUE; + + + connect->destinationInfo.m.vendorPresent = 1; + vendor = &connect->destinationInfo.vendor; + + vendor->vendor.t35CountryCode = gH323ep.t35CountryCode; + vendor->vendor.t35Extension = gH323ep.t35Extension; + vendor->vendor.manufacturerCode = gH323ep.manufacturerCode; + if(gH323ep.productID) + { + vendor->m.productIdPresent = 1; + vendor->productId.numocts = ASN1MIN(strlen(gH323ep.productID), + sizeof(vendor->productId.data)); + strncpy(vendor->productId.data, gH323ep.productID, + vendor->productId.numocts); + } + if(gH323ep.versionID) + { + vendor->m.versionIdPresent = 1; + vendor->versionId.numocts = ASN1MIN(strlen(gH323ep.versionID), + sizeof(vendor->versionId.data)); + strncpy(vendor->versionId.data, gH323ep.versionID, + vendor->versionId.numocts); + } + + ret = ooSetFastStartResponse(call, q931msg, + &connect->fastStart.n, &connect->fastStart.elem); + if(ret != ASN_OK) { return ret; } + if(connect->fastStart.n > 0) { + connect->m.fastStartPresent = TRUE; + } + else { + connect->m.fastStartPresent = FALSE; + } + + /* Add h245 listener address. Do not add H245 listener address in case + of fast-start. */ + if ((!OO_TESTFLAG(call->flags, OO_M_FASTSTART) || + call->remoteFastStartOLCs.count == 0) && + !OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + ooCreateH245Listener(call); /* First create an H.245 listener */ + connect->m.h245AddressPresent = TRUE; + connect->h245Address.t = T_H225TransportAddress_ipAddress; + + h245IpAddr = (H225TransportAddress_ipAddress*) + memAllocZ (pctxt, sizeof(H225TransportAddress_ipAddress)); + if(!h245IpAddr) + { + OOTRACEERR3("Error:Memory - ooAcceptCall - h245IpAddr" + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ooSocketConvertIpToNwAddr(call->localIP, h245IpAddr->ip.data); + h245IpAddr->ip.numocts=4; + h245IpAddr->port = *(call->h245listenport); + connect->h245Address.u.ipAddress = h245IpAddr; + } + + OOTRACEDBGA3("Built H.225 Connect message (%s, %s)\n", call->callType, + call->callToken); + + /* H225 message callback */ + if(gH323ep.h225Callbacks.onBuiltConnect) + gH323ep.h225Callbacks.onBuiltConnect(call, q931msg); + + ret=ooSendH225Msg(call, q931msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue Connect message to outbound queue.(%s, %s)\n", call->callType, call->callToken); + memReset(&gH323ep.msgctxt); + return OO_FAILED; + } + memReset(&gH323ep.msgctxt); + +#if 0 + if (OO_TESTFLAG (call->flags, OO_M_TUNNELING)) + { + /* Start terminal capability exchange and master slave determination */ + ret = ooSendTermCapMsg(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Terminal capability message (%s, %s)\n", + call->callType, call->callToken); + return ret; + } + ret = ooSendMasterSlaveDetermination(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Sending Master-slave determination message " + "(%s, %s)\n", call->callType, call->callToken); + return ret; + } + } +#endif + return OO_OK; +} + +int ooH323HandleCallFwdRequest(OOH323CallData *call) +{ + OOH323CallData *fwdedCall=NULL; + OOCTXT *pctxt; + ooAliases *pNewAlias=NULL, *alias=NULL; + int i=0, irand=0, ret = OO_OK; + /* Note: We keep same callToken, for new call which is going + to replace an existing call, thus treating it as a single call.*/ + + fwdedCall = ooCreateCall("outgoing", call->callToken); + + pctxt = fwdedCall->pctxt; + + /* Retrieve new destination info from original call */ + if(!ooUtilsIsStrEmpty(call->pCallFwdData->ip)) + { + strcpy(fwdedCall->remoteIP, call->pCallFwdData->ip); + } + fwdedCall->remotePort = call->pCallFwdData->port; + + if(call->pCallFwdData->aliases) + { + alias = call->pCallFwdData->aliases; + while(alias) + { + pNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases)); + pNewAlias->value = (char*) memAlloc(pctxt, strlen(alias->value)+1); + if(!pNewAlias || !pNewAlias->value) + { + OOTRACEERR3("Error:Memory - ooH323HandleCallFwdRequest - " + "pNewAlias/pNewAlias->value" + "(%s, %s)\n", call->callType, call->callToken); + ooCleanCall(fwdedCall); + return OO_FAILED; + } + pNewAlias->type = alias->type; + strcpy(pNewAlias->value, alias->value); + pNewAlias->next = fwdedCall->remoteAliases; + fwdedCall->remoteAliases = pNewAlias; + alias = alias->next; + pNewAlias = NULL; + } + } + + fwdedCall->callReference = ooGenerateCallReference(); + ooGenerateCallIdentifier(&fwdedCall->callIdentifier); + fwdedCall->confIdentifier.numocts = 16; + irand = rand(); + for (i = 0; i < 16; i++) { + fwdedCall->confIdentifier.data[i] = irand++; + } + + + if(gH323ep.gkClient && !OO_TESTFLAG(fwdedCall->flags, OO_M_DISABLEGK)) + { + /* No need to check registration status here as it is already checked for + MakeCall command */ + ret = ooGkClientSendAdmissionRequest(gH323ep.gkClient, fwdedCall, FALSE); + fwdedCall->callState = OO_CALL_WAITING_ADMISSION; + } + else { + ret = ooH323CallAdmitted (fwdedCall); + } + + return OO_OK; + +} + +int ooH323MakeCall(char *dest, char *callToken, ooCallOptions *opts) +{ + OOCTXT *pctxt; + OOH323CallData *call; + int ret=0, i=0, irand=0; + char tmp[30]="\0"; + char *ip=NULL, *port = NULL; + + if(!dest) + { + OOTRACEERR1("ERROR:Invalid destination for new call\n"); + return OO_FAILED; + } + if(!callToken) + { + OOTRACEERR1("ERROR: Invalid callToken parameter to make call\n"); + return OO_FAILED; + } + + call = ooCreateCall("outgoing", callToken); + pctxt = call->pctxt; + if(opts) + { + if(opts->fastStart) + OO_SETFLAG(call->flags, OO_M_FASTSTART); + else + OO_CLRFLAG(call->flags, OO_M_FASTSTART); + + if(opts->tunneling) + OO_SETFLAG(call->flags, OO_M_TUNNELING); + else + OO_CLRFLAG(call->flags, OO_M_TUNNELING); + + if(opts->disableGk) + OO_SETFLAG(call->flags, OO_M_DISABLEGK); + else + OO_CLRFLAG(call->flags, OO_M_DISABLEGK); + + call->callMode = opts->callMode; + } + + + ret = ooParseDestination(call, dest, tmp, 30, &call->remoteAliases); + if(ret != OO_OK) + { + OOTRACEERR2("Error: Failed to parse the destination string %s for " + "new call\n", dest); + ooCleanCall(call); + return OO_FAILED; + } + + /* Check whether we have ip address */ + if(!ooUtilsIsStrEmpty(tmp)) { + ip = tmp; + port = strchr(tmp, ':'); + *port = '\0'; + port++; + strcpy(call->remoteIP, ip); + call->remotePort = atoi(port); + } + + strcpy(callToken, call->callToken); + call->callReference = ooGenerateCallReference(); + ooGenerateCallIdentifier(&call->callIdentifier); + call->confIdentifier.numocts = 16; + irand = rand(); + for (i = 0; i < 16; i++) { + call->confIdentifier.data[i] = irand++; + } + + + if(gH323ep.gkClient && !OO_TESTFLAG(call->flags, OO_M_DISABLEGK)) + { + /* No need to check registration status here as it is already checked for + MakeCall command */ + ret = ooGkClientSendAdmissionRequest(gH323ep.gkClient, call, FALSE); + call->callState = OO_CALL_WAITING_ADMISSION; + } + else { + /* Send as H225 message to calling endpoint */ + ret = ooH323CallAdmitted (call); + } + + return OO_OK; +} + + +int ooH323CallAdmitted(OOH323CallData *call) +{ + int ret=0; + + if(!call) + { + /* Call not supplied. Must locate it in list */ + OOTRACEERR1("ERROR: Invalid call parameter to ooH323CallAdmitted"); + return OO_FAILED; + } + + if(!strcmp(call->callType, "outgoing")) { + ret = ooCreateH225Connection(call); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR:Failed to create H225 connection to %s:%d\n", + call->remoteIP, call->remotePort); + if(call->callState< OO_CALL_CLEAR) + { + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_UNKNOWN; + } + return OO_FAILED; + } + + ret = ooH323MakeCall_helper(call); + } + else { + /* incoming call */ + if(gH323ep.h323Callbacks.onIncomingCall) { + /* Incoming call callback function */ + gH323ep.h323Callbacks.onIncomingCall(call); + } + + /* Check for manual ringback generation */ + if(!OO_TESTFLAG(gH323ep.flags, OO_M_MANUALRINGBACK)) + { + ooSendAlerting(call); /* Send alerting message */ + + if(OO_TESTFLAG(gH323ep.flags, OO_M_AUTOANSWER)) { + ooSendConnect(call); /* Send connect message - call accepted */ + } + } + } + + return OO_OK; +} + +int ooH323MakeCall_helper(OOH323CallData *call) +{ + int ret=0,i=0, k; + Q931Message *q931msg = NULL; + H225Setup_UUIE *setup; + + ASN1DynOctStr *pFS=NULL; + H225TransportAddress_ipAddress *destCallSignalIpAddress; + + H225TransportAddress_ipAddress *srcCallSignalIpAddress; + ooH323EpCapability *epCap=NULL; + OOCTXT *pctxt = NULL; + H245OpenLogicalChannel *olc, printOlc; + ASN1BOOL aligned = 1; + ooAliases *pAlias = NULL; + + pctxt = &gH323ep.msgctxt; + + ret = ooCreateQ931Message(&q931msg, Q931SetupMsg); + if(ret != OO_OK) + { + OOTRACEERR1("ERROR:Failed to Create Q931 SETUP Message\n "); + return OO_FAILED; + } + + q931msg->callReference = call->callReference; + + /* Set bearer capability */ + if(OO_OK != ooSetBearerCapabilityIE(q931msg, Q931CCITTStd, + Q931TransferUnrestrictedDigital, Q931TransferPacketMode, + Q931TransferRatePacketMode, Q931UserInfoLayer1G722G725)) +// Q931TransferRate64Kbps, Q931UserInfoLayer1G711ULaw)) + { + OOTRACEERR3("Error: Failed to set bearer capability ie.(%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + /* Set calling party number Q931 IE */ + if(call->callingPartyNumber) + ooQ931SetCallingPartyNumberIE(q931msg, + (const char*)call->callingPartyNumber, 1, 0, 0, 0); + + + /* Set called party number Q931 IE */ + if(call->calledPartyNumber) + ooQ931SetCalledPartyNumberIE(q931msg, + (const char*)call->calledPartyNumber, 1, 0); + else if(call->remoteAliases) { + pAlias = call->remoteAliases; + while(pAlias) { + if(pAlias->type == T_H225AliasAddress_dialedDigits) + break; + pAlias = pAlias->next; + } + if(pAlias) + { + call->calledPartyNumber = (char*)memAlloc(call->pctxt, + strlen(pAlias->value)+1); + if(!call->calledPartyNumber) + { + OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - " + "calledPartyNumber(%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + strcpy(call->calledPartyNumber, pAlias->value); + ooQ931SetCalledPartyNumberIE(q931msg, + (const char*)call->calledPartyNumber, 1, 0); + } + + } + + q931msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt, + sizeof(H225H323_UserInformation)); + if(!q931msg->userInfo) + { + OOTRACEERR1("ERROR:Memory - ooH323MakeCall_helper - userInfo\n"); + return OO_FAILED; + } + memset(q931msg->userInfo, 0, sizeof(H225H323_UserInformation)); + + setup = (H225Setup_UUIE*) memAlloc(pctxt, sizeof(H225Setup_UUIE)); + if(!setup) + { + OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - setup (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + memset (setup, 0, sizeof(H225Setup_UUIE)); + setup->protocolIdentifier = gProtocolID; + + /* Populate Alias Address.*/ + + if(call->ourAliases || gH323ep.aliases) + { + setup->m.sourceAddressPresent = TRUE; + if(call->ourAliases) + ret = ooPopulateAliasList(pctxt, call->ourAliases, + &setup->sourceAddress); + else if(gH323ep.aliases) + ret = ooPopulateAliasList(pctxt, gH323ep.aliases, + &setup->sourceAddress); + if(OO_OK != ret) + { + OOTRACEERR1("Error:Failed to populate alias list in SETUP message\n"); + memReset(pctxt); + return OO_FAILED; + } + } + + setup->m.presentationIndicatorPresent = TRUE; + setup->presentationIndicator.t = + T_H225PresentationIndicator_presentationAllowed; + setup->m.screeningIndicatorPresent = TRUE; + setup->screeningIndicator = userProvidedNotScreened; + + setup->m.multipleCallsPresent = TRUE; + setup->multipleCalls = FALSE; + setup->m.maintainConnectionPresent = TRUE; + setup->maintainConnection = FALSE; + + /* Populate Destination aliases */ + if(call->remoteAliases) + { + setup->m.destinationAddressPresent = TRUE; + ret = ooPopulateAliasList(pctxt, call->remoteAliases, + &setup->destinationAddress); + if(OO_OK != ret) + { + OOTRACEERR1("Error:Failed to populate destination alias list in SETUP" + "message\n"); + memReset(pctxt); + return OO_FAILED; + } + } + + /* Populate the vendor information */ + if(gH323ep.isGateway) + setup->sourceInfo.m.gatewayPresent = TRUE; + else + setup->sourceInfo.m.terminalPresent = TRUE; + + setup->sourceInfo.m.vendorPresent=TRUE; + setup->sourceInfo.vendor.vendor.t35CountryCode = gH323ep.t35CountryCode; + setup->sourceInfo.vendor.vendor.t35Extension = gH323ep.t35Extension; + setup->sourceInfo.vendor.vendor.manufacturerCode= gH323ep.manufacturerCode; + + if(gH323ep.productID) + { + setup->sourceInfo.vendor.m.productIdPresent=TRUE; + setup->sourceInfo.vendor.productId.numocts = ASN1MIN( + strlen(gH323ep.productID), + sizeof(setup->sourceInfo.vendor.productId.data)); + strncpy((char*)setup->sourceInfo.vendor.productId.data, + gH323ep.productID, setup->sourceInfo.vendor.productId.numocts); + } + else + setup->sourceInfo.vendor.m.productIdPresent=FALSE; + + if(gH323ep.versionID) + { + setup->sourceInfo.vendor.m.versionIdPresent=TRUE; + setup->sourceInfo.vendor.versionId.numocts = ASN1MIN( + strlen(gH323ep.versionID), + sizeof(setup->sourceInfo.vendor.versionId.data)); + strncpy((char*)setup->sourceInfo.vendor.versionId.data, + gH323ep.versionID, setup->sourceInfo.vendor.versionId.numocts); + } + else + setup->sourceInfo.vendor.m.versionIdPresent=FALSE; + + setup->sourceInfo.mc = FALSE; + setup->sourceInfo.undefinedNode = FALSE; + + /* Populate the destination Call Signal Address */ + setup->destCallSignalAddress.t=T_H225TransportAddress_ipAddress; + destCallSignalIpAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + if(!destCallSignalIpAddress) + { + OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - " + "destCallSignalAddress. (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + ooSocketConvertIpToNwAddr(call->remoteIP, destCallSignalIpAddress->ip.data); + + destCallSignalIpAddress->ip.numocts=4; + destCallSignalIpAddress->port = call->remotePort; + + setup->destCallSignalAddress.u.ipAddress = destCallSignalIpAddress; + setup->m.destCallSignalAddressPresent=TRUE; + setup->activeMC=FALSE; + + /* Populate the source Call Signal Address */ + setup->sourceCallSignalAddress.t=T_H225TransportAddress_ipAddress; + srcCallSignalIpAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + if(!srcCallSignalIpAddress) + { + OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - srcCallSignalAddress" + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ooSocketConvertIpToNwAddr(call->localIP, srcCallSignalIpAddress->ip.data); + + srcCallSignalIpAddress->ip.numocts=4; + srcCallSignalIpAddress->port= call->pH225Channel->port; + setup->sourceCallSignalAddress.u.ipAddress = srcCallSignalIpAddress; + setup->m.sourceCallSignalAddressPresent=TRUE; + /* No fast start */ + if(!OO_TESTFLAG(gH323ep.flags, OO_M_FASTSTART)) + { + setup->m.fastStartPresent = FALSE; + } + else{ + setup->m.fastStartPresent = TRUE; + pFS = (ASN1DynOctStr*)memAlloc(pctxt, gH323ep.noOfCaps* + sizeof(ASN1DynOctStr)); + if(!pFS) + { + OOTRACEERR3("Error:Memory - ooH323MakeCall_helper - pFS(%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + /* Use preference order of codecs */ + i=0; + for(k=0; k< call->capPrefs.index; k++) + { + OOTRACEDBGC5("Preffered capability at index %d is %s. (%s, %s)\n", + k, ooGetCapTypeText(call->capPrefs.order[k]), + call->callType, call->callToken); + + if(call->ourCaps) { + epCap = call->ourCaps; + OOTRACEDBGC3("Using call specific capabilities in faststart of " + "setup message. (%s, %s)\n", call->callType, + call->callToken); + } + else{ + epCap = gH323ep.myCaps; + OOTRACEDBGC3("Using end-point capabilities for faststart of setup" + "message. (%s, %s)\n", call->callType, + call->callToken); + } + + while(epCap){ + if(epCap->cap == call->capPrefs.order[k]) break; + else epCap = epCap->next; + } + if(!epCap) + { + OOTRACEWARN4("Warn:Preferred capability %s is abscent in " + "capability list. (%s, %s)\n", + ooGetCapTypeText(call->capPrefs.order[k]), + call->callType, call->callToken); + continue; + } + + + + OOTRACEDBGC4("Building olcs with capability %s. (%s, %s)\n", + ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + if(epCap->dir & OORX) + { + olc = (H245OpenLogicalChannel*)memAlloc(pctxt, + sizeof(H245OpenLogicalChannel)); + if(!olc) + { + OOTRACEERR3("ERROR:Memory - ooH323MakeCall_helper - olc(%s, %s)" + "\n", call->callType, call->callToken); + ooFreeQ931Message(q931msg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + memset(olc, 0, sizeof(H245OpenLogicalChannel)); + olc->forwardLogicalChannelNumber = call->logicalChanNoCur++; + if(call->logicalChanNoCur > call->logicalChanNoMax) + call->logicalChanNoCur = call->logicalChanNoBase; + + ooBuildFastStartOLC(call, olc, epCap, pctxt, OORX); + /* Do not specify msg buffer let automatic allocation work */ + setPERBuffer(pctxt, NULL, 0, aligned); + if(asn1PE_H245OpenLogicalChannel(pctxt, olc) != ASN_OK) + { + OOTRACEERR3("ERROR:Encoding of olc failed for faststart(%s, %s)" + "\n", call->callType, call->callToken); + ooFreeQ931Message(q931msg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + pFS[i].data = encodeGetMsgPtr(pctxt, &(pFS[i].numocts)); + + + /* Dump faststart element in logfile for debugging purpose */ + setPERBuffer(pctxt, (char*)pFS[i].data, pFS[i].numocts, 1); + initializePrintHandler(&printHandler, "FastStart Element"); + setEventHandler (pctxt, &printHandler); + memset(&printOlc, 0, sizeof(printOlc)); + ret = asn1PD_H245OpenLogicalChannel(pctxt, &(printOlc)); + if(ret != ASN_OK) + { + OOTRACEERR3("Error: Failed decoding FastStart Element." + "(%s, %s)\n", call->callType, call->callToken); + ooFreeQ931Message(q931msg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + finishPrint(); + removeEventHandler(pctxt); + + + olc = NULL; + i++; + OOTRACEDBGC5("Added RX fs element %d with capability %s(%s, %s)\n", + i, ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + } + + if(epCap->dir & OOTX) + { + olc = (H245OpenLogicalChannel*)memAlloc(pctxt, + sizeof(H245OpenLogicalChannel)); + if(!olc) + { + OOTRACEERR3("ERROR:Memory - ooH323MakeCall_helper - olc(%s, %s)" + "\n", call->callType, call->callToken); + ooFreeQ931Message(q931msg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + memset(olc, 0, sizeof(H245OpenLogicalChannel)); + olc->forwardLogicalChannelNumber = call->logicalChanNoCur++; + if(call->logicalChanNoCur > call->logicalChanNoMax) + call->logicalChanNoCur = call->logicalChanNoBase; + + ooBuildFastStartOLC(call, olc, epCap, pctxt, OOTX); + /* Do not specify msg buffer let automatic allocation work */ + setPERBuffer(pctxt, NULL, 0, aligned); + if(asn1PE_H245OpenLogicalChannel(pctxt, olc) != ASN_OK) + { + OOTRACEERR3("ERROR:Encoding of olc failed for faststart(%s, %s)" + "\n", call->callType, call->callToken); + ooFreeQ931Message(q931msg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + pFS[i].data = encodeGetMsgPtr(pctxt, &(pFS[i].numocts)); + + /* Dump faststart element in logfile for debugging purpose */ + setPERBuffer(pctxt, (char*)pFS[i].data, pFS[i].numocts, 1); + initializePrintHandler(&printHandler, "FastStart Element"); + setEventHandler (pctxt, &printHandler); + memset(&printOlc, 0, sizeof(printOlc)); + ret = asn1PD_H245OpenLogicalChannel(pctxt, &(printOlc)); + if(ret != ASN_OK) + { + OOTRACEERR3("Error: Failed decoding FastStart Element." + "(%s, %s)\n", call->callType, call->callToken); + ooFreeQ931Message(q931msg); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = OO_REASON_LOCAL_CLEARED; + call->callState = OO_CALL_CLEAR; + } + return OO_FAILED; + } + finishPrint(); + removeEventHandler(pctxt); + + + olc = NULL; + i++; + OOTRACEDBGC5("Added TX fs element %d with capability %s(%s, %s)\n", + i, ooGetCapTypeText(epCap->cap), call->callType, + call->callToken); + } + + } + OOTRACEDBGA4("Added %d fast start elements to SETUP message (%s, %s)\n", + i, call->callType, call->callToken); + setup->fastStart.n = i; + setup->fastStart.elem = pFS; + } + + setup->conferenceID.numocts= call->confIdentifier.numocts; + memcpy(setup->conferenceID.data, call->confIdentifier.data, + call->confIdentifier.numocts); + + setup->conferenceGoal.t = T_H225Setup_UUIE_conferenceGoal_create; + /* H.225 point to point call */ + setup->callType.t = T_H225CallType_pointToPoint; + + /* Populate optional fields */ + setup->m.callIdentifierPresent = TRUE; + /*ooGenerateCallIdentifier(&setup->callIdentifier);*/ + setup->callIdentifier.guid.numocts = call->callIdentifier.guid.numocts; + memcpy(setup->callIdentifier.guid.data, call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + + setup->m.mediaWaitForConnectPresent = TRUE; + if(OO_TESTFLAG(call->flags, OO_M_MEDIAWAITFORCONN)) { + setup->mediaWaitForConnect = TRUE; + } + else { + setup->mediaWaitForConnect = FALSE; + } + setup->m.canOverlapSendPresent = TRUE; + setup->canOverlapSend = FALSE; + + /* Populate the userInfo structure with the setup UUIE */ + + q931msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_setup; + q931msg->userInfo->h323_uu_pdu.h323_message_body.u.setup = setup; + q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; + + q931msg->userInfo->h323_uu_pdu.h245Tunneling = + OO_TESTFLAG (call->flags, OO_M_TUNNELING); + + /* For H.323 version 4 and higher, if fast connect, tunneling should be + supported. + */ + if(OO_TESTFLAG(call->flags, OO_M_FASTSTART)) + q931msg->userInfo->h323_uu_pdu.h245Tunneling = TRUE; + + OOTRACEDBGA3("Built SETUP message (%s, %s)\n", call->callType, + call->callToken); + + /* H225 message callback */ + if(gH323ep.h225Callbacks.onBuiltSetup) + gH323ep.h225Callbacks.onBuiltSetup(call, q931msg); + + ret=ooSendH225Msg(call, q931msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue SETUP message to outbound queue. (%s, %s)\n", call->callType, call->callToken); + } + memReset(&gH323ep.msgctxt); + + return ret; +} + + + +int ooQ931SendDTMFAsKeyPadIE(OOH323CallData *call, const char* data) +{ + int ret; + H225Information_UUIE *information=NULL; + Q931Message *q931msg=NULL; + OOCTXT *pctxt = &gH323ep.msgctxt; + + ret = ooCreateQ931Message(&q931msg, Q931InformationMsg); + if(ret != OO_OK) + { + OOTRACEERR3("Error: In allocating memory for - H225 Information message." + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + q931msg->callReference = call->callReference; + + q931msg->userInfo = (H225H323_UserInformation*)memAllocZ(pctxt, + sizeof(H225H323_UserInformation)); + if(!q931msg->userInfo) + { + OOTRACEERR3("ERROR:Memory - ooQ931SendDTMFAsKeypadIE - userInfo" + "(%s, %s)\n", call->callType, call->callToken); + memReset(&gH323ep.msgctxt); + return OO_FAILED; + } + q931msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; + q931msg->userInfo->h323_uu_pdu.h245Tunneling = OO_TESTFLAG(gH323ep.flags, + OO_M_TUNNELING); + q931msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_information; + + information = (H225Information_UUIE*)memAllocZ(pctxt, + sizeof(H225Information_UUIE)); + if(!information) + { + OOTRACEERR3("ERROR:Memory - ooQ931SendDTMFAsKeypadIE - information" + "(%s, %s)\n", call->callType, call->callToken); + memReset(&gH323ep.msgctxt); + return OO_FAILED; + } + q931msg->userInfo->h323_uu_pdu.h323_message_body.u.information = + information; + information->m.callIdentifierPresent = 1; + information->callIdentifier.guid.numocts = + call->callIdentifier.guid.numocts; + memcpy(information->callIdentifier.guid.data, + call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + information->protocolIdentifier = gProtocolID; + + /*Add keypad IE*/ + ret = ooQ931SetKeypadIE(q931msg, data); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Creating keypad IE for (%s, %s)\n", call->callType, + call->callToken); + memReset(&gH323ep.msgctxt); + return OO_FAILED; + } + + ret=ooSendH225Msg(call, q931msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue Information message to outbound " + "queue. (%s, %s)\n", call->callType, call->callToken); + } + memReset(&gH323ep.msgctxt); + + return ret; + +} + +int ooH323ForwardCall(char* callToken, char *dest) +{ + int ret=0; + Q931Message *pQ931Msg = NULL; + H225Facility_UUIE *facility=NULL; + OOCTXT *pctxt = &gH323ep.msgctxt; + OOH323CallData *call; + char ip[30]="\0", *pcPort=NULL; + H225TransportAddress_ipAddress *fwdCallSignalIpAddress; + + call= ooFindCallByToken(callToken); + if(!call) + { + OOTRACEERR2("ERROR: Invalid call token for forward - %s\n", callToken); + return OO_FAILED; + } + OOTRACEDBGA3("Building Facility message for call forward (%s, %s)\n", + call->callType, call->callToken); + call->pCallFwdData = (OOCallFwdData*)memAllocZ(call->pctxt, + sizeof(OOCallFwdData)); + if(!call->pCallFwdData) + { + OOTRACEERR3("Error:Memory - ooH323ForwardCall - pCallFwdData (%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + + ret = ooParseDestination(call, dest, ip, 20, + &call->pCallFwdData->aliases); + if(ret != OO_OK) + { + OOTRACEERR4("Error:Failed to parse the destination %s for call fwd." + "(%s, %s)\n", dest, call->callType, call->callToken); + memFreePtr(call->pctxt, call->pCallFwdData); + return OO_FAILED; + } + + if(!ooUtilsIsStrEmpty(ip)) + { + pcPort = strchr(ip, ':'); + if(pcPort) + { + *pcPort = '\0'; + pcPort++; + call->pCallFwdData->port = atoi(pcPort); + } + strcpy(call->pCallFwdData->ip, ip); + } + + ret = ooCreateQ931Message(&pQ931Msg, Q931FacilityMsg); + if(ret != OO_OK) + { + OOTRACEERR3 + ("ERROR: In allocating memory for call transfer facility message " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + pQ931Msg->callReference = call->callReference; + + pQ931Msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt, + sizeof(H225H323_UserInformation)); + if(!pQ931Msg->userInfo) + { + OOTRACEERR3("ERROR:Memory - ooH323ForwardCall - userInfo(%s, %s)\n", + call->callType, call->callToken); + return OO_FAILED; + } + memset (pQ931Msg->userInfo, 0, sizeof(H225H323_UserInformation)); + pQ931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; + + pQ931Msg->userInfo->h323_uu_pdu.h245Tunneling = + OO_TESTFLAG (call->flags, OO_M_TUNNELING); + + pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_facility; + + facility = (H225Facility_UUIE*) + memAllocZ (pctxt, sizeof(H225Facility_UUIE)); + + if(!facility) + { + OOTRACEERR3("ERROR:Memory - ooH323ForwardCall - facility (%s, %s)" + "\n", call->callType, call->callToken); + return OO_FAILED; + } + + pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.u.facility = facility; + + facility->protocolIdentifier = gProtocolID; + facility->m.callIdentifierPresent = 1; + facility->callIdentifier.guid.numocts = + call->callIdentifier.guid.numocts; + + memcpy(facility->callIdentifier.guid.data, + call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + + facility->reason.t = T_H225FacilityReason_callForwarded; + + if(!ooUtilsIsStrEmpty(call->pCallFwdData->ip)) + { + facility->m.alternativeAddressPresent = TRUE; + facility->alternativeAddress.t=T_H225TransportAddress_ipAddress; + fwdCallSignalIpAddress = (H225TransportAddress_ipAddress*)memAlloc(pctxt, + sizeof(H225TransportAddress_ipAddress)); + if(!fwdCallSignalIpAddress) + { + OOTRACEERR3("Error:Memory - ooH323ForwardCall - fwdCallSignalAddress" + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + ooSocketConvertIpToNwAddr(call->pCallFwdData->ip, + fwdCallSignalIpAddress->ip.data); + + fwdCallSignalIpAddress->ip.numocts=4; + fwdCallSignalIpAddress->port = call->pCallFwdData->port; + facility->alternativeAddress.u.ipAddress = fwdCallSignalIpAddress; + } + + if(call->pCallFwdData->aliases) + { + facility->m.alternativeAliasAddressPresent = TRUE; + ret = ooPopulateAliasList(pctxt, call->pCallFwdData->aliases, + &facility->alternativeAliasAddress); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to populate alternate aliases in " + "ooH323ForwardCall. (%s, %s)\n", call->callType, + call->callToken); + return OO_FAILED; + } + } + + ret = ooSendH225Msg(call, pQ931Msg); + if(ret != OO_OK) + { + OOTRACEERR3 + ("Error:Failed to enqueue Forward Facility message to outbound " + "queue.(%s, %s)\n", call->callType, call->callToken); + } + call->callEndReason = OO_REASON_LOCAL_FWDED; + memReset (&gH323ep.msgctxt); + return ret; +} + +int ooH323HangCall(char * callToken, OOCallClearReason reason) +{ + OOH323CallData *call; + + call= ooFindCallByToken(callToken); + if(!call) + { + OOTRACEWARN2("WARN: Call hangup failed - Call %s not present\n", + callToken); + return OO_FAILED; + } + OOTRACEINFO3("Hanging up call (%s, %s)\n", call->callType, call->callToken); + if(call->callState < OO_CALL_CLEAR) + { + call->callEndReason = reason; + call->callState = OO_CALL_CLEAR; + } + return OO_OK; +} + +int ooSetBearerCapabilityIE + (Q931Message *pmsg, enum Q931CodingStandard codingStandard, + enum Q931InformationTransferCapability capability, + enum Q931TransferMode transferMode, enum Q931TransferRate transferRate, + enum Q931UserInfoLayer1Protocol userInfoLayer1) +{ + unsigned size = 3; + OOCTXT *pctxt = &gH323ep.msgctxt; + + if(pmsg->bearerCapabilityIE) + { + memFreePtr(pctxt, pmsg->bearerCapabilityIE); + pmsg->bearerCapabilityIE = NULL; + } + + pmsg->bearerCapabilityIE = (Q931InformationElement*) + memAlloc(pctxt, sizeof(Q931InformationElement)+size-1); + if(!pmsg->bearerCapabilityIE) + { + OOTRACEERR1("Error:Memory - ooSetBearerCapabilityIE - bearerCapabilityIE" + "\n"); + return OO_FAILED; + } + + pmsg->bearerCapabilityIE->discriminator = Q931BearerCapabilityIE; + pmsg->bearerCapabilityIE->length = size; + pmsg->bearerCapabilityIE->data[0] = (ASN1OCTET)(0x80 | ((codingStandard&3) << 5) | (capability&31)); + + pmsg->bearerCapabilityIE->data[1] = (0x80 | ((transferMode & 3) << 5) | (transferRate & 31)); + + pmsg->bearerCapabilityIE->data[2] = (0x80 | (1<<5) | userInfoLayer1); + + return OO_OK; +} + +int ooQ931SetKeypadIE(Q931Message *pmsg, const char* data) +{ + unsigned len = 0; + OOCTXT *pctxt = &gH323ep.msgctxt; + + len = strlen(data); + pmsg->keypadIE = (Q931InformationElement*) + memAlloc(pctxt, sizeof(Q931InformationElement)+len-1); + if(!pmsg->keypadIE) + { + OOTRACEERR1("Error:Memory - ooQ931SetKeypadIE - keypadIE\n"); + return OO_FAILED; + } + + pmsg->keypadIE->discriminator = Q931KeypadIE; + pmsg->keypadIE->length = len; + memcpy(pmsg->keypadIE->data, data, len); + return OO_OK; +} + + + + +int ooQ931SetCallingPartyNumberIE + (Q931Message *pmsg, const char *number, unsigned plan, unsigned type, + unsigned presentation, unsigned screening) +{ + unsigned len = 0; + OOCTXT *pctxt = &gH323ep.msgctxt; + + if(pmsg->callingPartyNumberIE) + { + memFreePtr(pctxt, pmsg->callingPartyNumberIE); + pmsg->callingPartyNumberIE = NULL; + } + + len = strlen(number); + pmsg->callingPartyNumberIE = (Q931InformationElement*) + memAlloc(pctxt, sizeof(Q931InformationElement)+len+2-1); + if(!pmsg->callingPartyNumberIE) + { + OOTRACEERR1("Error:Memory - ooQ931SetCallingPartyNumberIE - " + "callingPartyNumberIE\n"); + return OO_FAILED; + } + pmsg->callingPartyNumberIE->discriminator = Q931CallingPartyNumberIE; + pmsg->callingPartyNumberIE->length = len+2; + pmsg->callingPartyNumberIE->data[0] = (((type&7)<<4)|(plan&15)); + pmsg->callingPartyNumberIE->data[1] = (0x80|((presentation&3)<<5)|(screening&3)); + memcpy(pmsg->callingPartyNumberIE->data+2, number, len); + + return OO_OK; +} + +int ooQ931SetCalledPartyNumberIE + (Q931Message *pmsg, const char *number, unsigned plan, unsigned type) +{ + unsigned len = 0; + OOCTXT *pctxt = &gH323ep.msgctxt; + + if(pmsg->calledPartyNumberIE) + { + memFreePtr(pctxt, pmsg->calledPartyNumberIE); + pmsg->calledPartyNumberIE = NULL; + } + + len = strlen(number); + pmsg->calledPartyNumberIE = (Q931InformationElement*) + memAlloc(pctxt, sizeof(Q931InformationElement)+len+1-1); + if(!pmsg->calledPartyNumberIE) + { + OOTRACEERR1("Error:Memory - ooQ931SetCalledPartyNumberIE - " + "calledPartyNumberIE\n"); + return OO_FAILED; + } + pmsg->calledPartyNumberIE->discriminator = Q931CalledPartyNumberIE; + pmsg->calledPartyNumberIE->length = len+1; + pmsg->calledPartyNumberIE->data[0] = (0x80|((type&7)<<4)|(plan&15)); + memcpy(pmsg->calledPartyNumberIE->data+1, number, len); + + return OO_OK; +} + +int ooQ931SetCauseIE + (Q931Message *pmsg, enum Q931CauseValues cause, unsigned coding, + unsigned location) +{ + OOCTXT *pctxt = &gH323ep.msgctxt; + + if(pmsg->causeIE){ + memFreePtr(pctxt, pmsg->causeIE); + pmsg->causeIE = NULL; + } + + pmsg->causeIE = (Q931InformationElement*) + memAlloc(pctxt, sizeof(Q931InformationElement)+1); + if(!pmsg->causeIE) + { + OOTRACEERR1("Error:Memory - ooQ931SetCauseIE - causeIE\n"); + return OO_FAILED; + } + pmsg->causeIE->discriminator = Q931CauseIE; + pmsg->causeIE->length = 2; + pmsg->causeIE->data[0] = (0x80 | ((coding & 0x03) <<5) | (location & 0x0F)); + + pmsg->causeIE->data[1] = (0x80 | cause); + + return OO_OK; +} + + +/* Build a Facility message and tunnel H.245 message through it */ +int ooSendAsTunneledMessage(OOH323CallData *call, ASN1OCTET* msgbuf, + int h245Len, int h245MsgType, int associatedChan) +{ + Q931Message *pQ931Msg = NULL; + H225H323_UU_PDU *pH323UUPDU = NULL; + H225H323_UU_PDU_h245Control *pH245Control = NULL; + ASN1DynOctStr * elem; + int ret =0; + H225Facility_UUIE *facility=NULL; + OOCTXT *pctxt = &gH323ep.msgctxt; + + OOTRACEDBGA4("Building Facility message for tunneling %s (%s, %s)\n", + ooGetMsgTypeText(h245MsgType), call->callType, call->callToken); + + ret = ooCreateQ931Message(&pQ931Msg, Q931FacilityMsg); + if(ret != OO_OK) + { + OOTRACEERR3("ERROR: In allocating memory for facility message " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + + pQ931Msg->callReference = call->callReference; + + pQ931Msg->userInfo = (H225H323_UserInformation*)memAlloc(pctxt, + sizeof(H225H323_UserInformation)); + if(!pQ931Msg->userInfo) + { + OOTRACEERR3("ERROR:Memory - ooSendAsTunneledMessage - userInfo" + " (%s, %s)\n", call->callType, call->callToken); + memReset(&gH323ep.msgctxt); + return OO_FAILED; + } + memset (pQ931Msg->userInfo, 0, sizeof(H225H323_UserInformation)); + pQ931Msg->userInfo->h323_uu_pdu.m.h245TunnelingPresent=1; + + pQ931Msg->userInfo->h323_uu_pdu.h245Tunneling = + OO_TESTFLAG (call->flags, OO_M_TUNNELING); + + pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.t = + T_H225H323_UU_PDU_h323_message_body_facility; + + facility = (H225Facility_UUIE*) + memAllocZ (pctxt, sizeof(H225Facility_UUIE)); + + if(!facility) + { + OOTRACEERR3("ERROR:Memory - ooSendAsTunneledMessage - facility (%s, %s)" + "\n", call->callType, call->callToken); + memReset(&gH323ep.msgctxt); + return OO_FAILED; + } + + pQ931Msg->userInfo->h323_uu_pdu.h323_message_body.u.facility = facility; + /* Populate Facility UUIE */ + facility->protocolIdentifier = gProtocolID; + facility->m.callIdentifierPresent = 1; + facility->callIdentifier.guid.numocts = + call->callIdentifier.guid.numocts; + + memcpy(facility->callIdentifier.guid.data, + call->callIdentifier.guid.data, + call->callIdentifier.guid.numocts); + + facility->reason.t = T_H225FacilityReason_transportedInformation; + + pH323UUPDU = (H225H323_UU_PDU*) &pQ931Msg->userInfo->h323_uu_pdu; + pH323UUPDU->m.h245TunnelingPresent = TRUE; + pH323UUPDU->m.h245ControlPresent = TRUE; + pH323UUPDU->h245Tunneling = TRUE; + pH245Control = (H225H323_UU_PDU_h245Control*) + &pH323UUPDU->h245Control; + + elem = (ASN1DynOctStr*) memAlloc(pctxt, + sizeof(ASN1DynOctStr)); + if(!elem) + { + OOTRACEERR3("ERROR:Memory - ooSendAsTunneledMessage - elem " + "(%s, %s)\n", call->callType, call->callToken); + return OO_FAILED; + } + elem->data = msgbuf; + elem->numocts = h245Len; + pH245Control->elem = elem; + pH245Control->n = 1; + pQ931Msg->tunneledMsgType = h245MsgType; + pQ931Msg->logicalChannelNo = associatedChan; + + + ret = ooSendH225Msg(call, pQ931Msg); + if(ret != OO_OK) + { + OOTRACEERR3("Error:Failed to enqueue Facility(tunneling) message to " + "outbound queue.(%s, %s)\n", call->callType, call->callToken); + } + + /* Can't do memReset here because if we are sending H.245 message as a + response to received tunneled h.245 message, we can't reset unless the \ + main received H225 message processing is finished. Rule. No reset when + tunneling + */ + memFreePtr(&gH323ep.msgctxt, pQ931Msg); + return ret; +} + +int ooCallEstbTimerExpired(void *data) +{ + + ooTimerCallback *cbData = (ooTimerCallback*) data; + OOH323CallData *call = cbData->call; + OOTRACEINFO3("Call Establishment timer expired. (%s, %s)\n", + call->callType, call->callToken); + memFreePtr(call->pctxt, cbData); + if(call->callState < OO_CALL_CLEAR){ + call->callState = OO_CALL_CLEAR; + call->callEndReason = OO_REASON_LOCAL_CLEARED; + } + + return OO_OK; +} + + +int ooQ931GetCauseAndReasonCodeFromCallClearReason + (OOCallClearReason clearReason, enum Q931CauseValues *cause, + unsigned *reasonCode) +{ + switch(clearReason) + { + case OO_REASON_INVALIDMESSAGE: + case OO_REASON_TRANSPORTFAILURE: + *reasonCode = T_H225ReleaseCompleteReason_undefinedReason; + *cause = Q931ProtocolErrorUnspecified; + break; + case OO_REASON_NOBW: + *reasonCode = T_H225ReleaseCompleteReason_noBandwidth; + *cause = Q931ErrorInCauseIE; + break; + case OO_REASON_GK_NOCALLEDUSER: + *reasonCode = T_H225ReleaseCompleteReason_calledPartyNotRegistered; + *cause = Q931SubscriberAbsent; + break; + case OO_REASON_GK_NOCALLERUSER: + *reasonCode = T_H225ReleaseCompleteReason_callerNotRegistered; + *cause = Q931SubscriberAbsent; + break; + case OO_REASON_GK_UNREACHABLE: + *reasonCode = T_H225ReleaseCompleteReason_unreachableGatekeeper; + *cause = Q931TemporaryFailure; + break; + case OO_REASON_GK_NORESOURCES: + case OO_REASON_GK_CLEARED: + *reasonCode = T_H225ReleaseCompleteReason_gatekeeperResources; + *cause = Q931Congestion; + break; + case OO_REASON_NOCOMMON_CAPABILITIES: + *reasonCode = T_H225ReleaseCompleteReason_undefinedReason; + *cause = Q931IncompatibleDestination; + break; + case OO_REASON_LOCAL_FWDED: + case OO_REASON_REMOTE_FWDED: + *reasonCode = T_H225ReleaseCompleteReason_facilityCallDeflection; + *cause = Q931Redirection; + break; + case OO_REASON_REMOTE_CLEARED: + case OO_REASON_LOCAL_CLEARED: + *reasonCode = T_H225ReleaseCompleteReason_undefinedReason; + *cause = Q931NormalCallClearing; + break; + case OO_REASON_REMOTE_BUSY: + case OO_REASON_LOCAL_BUSY: + *reasonCode = T_H225ReleaseCompleteReason_inConf; + *cause = Q931UserBusy; + break; + case OO_REASON_REMOTE_NOANSWER: + case OO_REASON_LOCAL_NOTANSWERED: + *reasonCode = T_H225ReleaseCompleteReason_undefinedReason; + *cause = Q931NoAnswer; + break; + case OO_REASON_REMOTE_REJECTED: + case OO_REASON_LOCAL_REJECTED: + *reasonCode = T_H225ReleaseCompleteReason_destinationRejection; + *cause = Q931CallRejected; + break; + case OO_REASON_REMOTE_CONGESTED: + case OO_REASON_LOCAL_CONGESTED: + *reasonCode = T_H225ReleaseCompleteReason_noBandwidth; + *cause = Q931Congestion; + break; + case OO_REASON_NOROUTE: + *reasonCode = T_H225ReleaseCompleteReason_unreachableDestination; + *cause = Q931NoRouteToDestination; + break; + case OO_REASON_NOUSER: + *reasonCode = T_H225ReleaseCompleteReason_undefinedReason; + *cause = Q931SubscriberAbsent; + break; + case OO_REASON_UNKNOWN: + default: + *reasonCode = T_H225ReleaseCompleteReason_undefinedReason; + *cause = Q931NormalUnspecified; + } + + return OO_OK; +} + +enum OOCallClearReason ooGetCallClearReasonFromCauseAndReasonCode + (enum Q931CauseValues cause, unsigned reasonCode) +{ + switch(cause) + { + case Q931NormalCallClearing: + return OO_REASON_REMOTE_CLEARED; + + case Q931UserBusy: + return OO_REASON_REMOTE_BUSY; + + case Q931NoResponse: + case Q931NoAnswer: + return OO_REASON_REMOTE_NOANSWER; + + case Q931CallRejected: + return OO_REASON_REMOTE_REJECTED; + + case Q931Redirection: + return OO_REASON_REMOTE_FWDED; + + case Q931NetworkOutOfOrder: + case Q931TemporaryFailure: + return OO_REASON_TRANSPORTFAILURE; + + case Q931NoCircuitChannelAvailable: + case Q931Congestion: + case Q931RequestedCircuitUnAvailable: + case Q931ResourcesUnavailable: + return OO_REASON_REMOTE_CONGESTED; + + case Q931NoRouteToDestination: + case Q931NoRouteToNetwork: + return OO_REASON_NOROUTE; + case Q931NumberChanged: + case Q931UnallocatedNumber: + case Q931SubscriberAbsent: + return OO_REASON_NOUSER; + case Q931ChannelUnacceptable: + case Q931DestinationOutOfOrder: + case Q931InvalidNumberFormat: + case Q931NormalUnspecified: + case Q931StatusEnquiryResponse: + case Q931IncompatibleDestination: + case Q931ProtocolErrorUnspecified: + case Q931RecoveryOnTimerExpiry: + case Q931InvalidCallReference: + default: + switch(reasonCode) + { + case T_H225ReleaseCompleteReason_noBandwidth: + return OO_REASON_NOBW; + case T_H225ReleaseCompleteReason_gatekeeperResources: + return OO_REASON_GK_NORESOURCES; + case T_H225ReleaseCompleteReason_unreachableDestination: + return OO_REASON_NOROUTE; + case T_H225ReleaseCompleteReason_destinationRejection: + return OO_REASON_REMOTE_REJECTED; + case T_H225ReleaseCompleteReason_inConf: + return OO_REASON_REMOTE_BUSY; + case T_H225ReleaseCompleteReason_facilityCallDeflection: + return OO_REASON_REMOTE_FWDED; + case T_H225ReleaseCompleteReason_calledPartyNotRegistered: + return OO_REASON_GK_NOCALLEDUSER; + case T_H225ReleaseCompleteReason_callerNotRegistered: + return OO_REASON_GK_NOCALLERUSER; + case T_H225ReleaseCompleteReason_gatewayResources: + return OO_REASON_GK_NORESOURCES; + case T_H225ReleaseCompleteReason_unreachableGatekeeper: + return OO_REASON_GK_UNREACHABLE; + case T_H225ReleaseCompleteReason_invalidRevision: + case T_H225ReleaseCompleteReason_noPermission: + case T_H225ReleaseCompleteReason_badFormatAddress: + case T_H225ReleaseCompleteReason_adaptiveBusy: + case T_H225ReleaseCompleteReason_undefinedReason: + case T_H225ReleaseCompleteReason_securityDenied: + case T_H225ReleaseCompleteReason_newConnectionNeeded: + case T_H225ReleaseCompleteReason_nonStandardReason: + case T_H225ReleaseCompleteReason_replaceWithConferenceInvite: + case T_H225ReleaseCompleteReason_genericDataReason: + case T_H225ReleaseCompleteReason_neededFeatureNotSupported: + case T_H225ReleaseCompleteReason_tunnelledSignallingRejected: + case T_H225ReleaseCompleteReason_invalidCID: + case T_H225ReleaseCompleteReason_securityError: + case T_H225ReleaseCompleteReason_hopCountExceeded: + case T_H225ReleaseCompleteReason_extElem1: + default: + return OO_REASON_UNKNOWN; + } + } + return OO_REASON_UNKNOWN; +} + +/** + This function is used to parse destination string passed to ooH323MakeCall and + ooH323ForwardCall. If the string contains ip address and port, it is returned + in the parsedIP buffer and if it contains alias, it is added to aliasList +*/ +int ooParseDestination + (struct OOH323CallData *call, char *dest, char* parsedIP, unsigned len, + ooAliases** aliasList) +{ + int iEk=-1, iDon=-1, iTeen=-1, iChaar=-1, iPort = -1, i; + ooAliases * psNewAlias = NULL; + char *cAt = NULL, *host=NULL; + char tmp[256], buf[30]; + char *alias=NULL; + OOCTXT *pctxt = call->pctxt; + parsedIP[0] = '\0'; + + OOTRACEINFO2("Parsing destination %s\n", dest); + + /* Test for an IP address:Note that only supports dotted IPv4. + IPv6 won't pass the test and so will numeric IP representation*/ + + sscanf(dest, "%d.%d.%d.%d:%d", &iEk, &iDon, &iTeen, &iChaar, &iPort); + if((iEk > 0 && iEk <= 255) && + (iDon >= 0 && iDon <= 255) && + (iTeen >=0 && iTeen <= 255) && + (iChaar >= 0 && iChaar <= 255) && + (!strchr(dest, ':') || iPort != -1)) + { + if(!strchr(dest, ':')) + iPort = 1720; /*Default h.323 port */ + + sprintf(buf, "%d.%d.%d.%d:%d", iEk, iDon, iTeen, iChaar, iPort); + if(strlen(buf)+1>len) + { + OOTRACEERR1("Error:Insufficient buffer space for parsed ip - " + "ooParseDestination\n"); + return OO_FAILED; + } + + strcpy(parsedIP, buf); + return OO_OK; + } + + /* alias@host */ + strncpy(tmp, dest, sizeof(tmp)-1); + tmp[sizeof(tmp)-1]='\0'; + if((host=strchr(tmp, '@')) != NULL) + { + *host = '\0'; + host++; + sscanf(host, "%d.%d.%d.%d:%d", &iEk, &iDon, &iTeen, &iChaar, &iPort); + if((iEk > 0 && iEk <= 255) && + (iDon >= 0 && iDon <= 255) && + (iTeen >=0 && iTeen <= 255) && + (iChaar >= 0 && iChaar <= 255) && + (!strchr(host, ':') || iPort != -1)) + { + if(!strchr(dest, ':')) + iPort = 1720; /*Default h.323 port */ + + sprintf(buf, "%d.%d.%d.%d:%d", iEk, iDon, iTeen, iChaar, iPort); + if(strlen(buf)+1>len) + { + OOTRACEERR1("Error:Insufficient buffer space for parsed ip - " + "ooParseDestination\n"); + return OO_FAILED; + } + + strncpy(parsedIP, buf, len-1); + parsedIP[len-1]='\0'; + alias = tmp; + } + } + + if(!alias) + { + alias = dest; + } + /* url test */ + if(alias == strstr(alias, "http://")) + { + psNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias\n"); + return OO_FAILED; + } + psNewAlias->type = T_H225AliasAddress_url_ID; + psNewAlias->value = (char*) memAlloc(pctxt, strlen(alias)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error:Memory - ooParseDestination - " + "psNewAlias->value\n"); + memFreePtr(pctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, alias); + psNewAlias->next = *aliasList; + *aliasList = psNewAlias; + OOTRACEINFO2("Destination parsed as url %s\n", psNewAlias->value); + return OO_OK; + } + + /* E-mail ID test */ + if((cAt = strchr(alias, '@')) && alias != strchr(alias, '@')) + { + if(strchr(cAt, '.')) + { + psNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias\n"); + return OO_FAILED; + } + psNewAlias->type = T_H225AliasAddress_email_ID; + psNewAlias->value = (char*) memAlloc(pctxt, strlen(alias)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error:Memory - ooParseDestination - " + "psNewAlias->value\n"); + memFreePtr(pctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, alias); + psNewAlias->next = *aliasList; + *aliasList = psNewAlias; + OOTRACEINFO2("Destination is parsed as email %s\n",psNewAlias->value); + return OO_OK; + } + } + + + /* e-164 */ + /* strspn(dest, "1234567890*#,") == strlen(dest)*/ + /* Dialed digits test*/ + for(i=0; *(alias+i) != '\0'; i++) + { + if(!isdigit(alias[i]) && alias[i] != '#' && alias[i] != '*' && + alias[i] != ',') + break; + } + if(*(alias+i) == '\0') + { + psNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias\n"); + return OO_FAILED; + } + /* memset(psNewAlias, 0, sizeof(ooAliases));*/ + psNewAlias->type = T_H225AliasAddress_dialedDigits; + psNewAlias->value = (char*) memAlloc(pctxt, strlen(alias)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error:Memroy - ooParseDestination - " + "psNewAlias->value\n"); + memFreePtr(pctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, alias); + psNewAlias->next = *aliasList; + *aliasList = psNewAlias; + OOTRACEINFO2("Destination is parsed as dialed digits %s\n", + psNewAlias->value); + /* Also set called party number */ + if(!call->calledPartyNumber) + { + if(ooCallSetCalledPartyNumber(call, alias) != OO_OK) + { + OOTRACEWARN3("Warning:Failed to set calling party number." + "(%s, %s)\n", call->callType, call->callToken); + } + } + return OO_OK; + } + /* Evrything else is an h323-id for now */ + psNewAlias = (ooAliases*) memAlloc(pctxt, sizeof(ooAliases)); + if(!psNewAlias) + { + OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias\n"); + return OO_FAILED; + } + psNewAlias->type = T_H225AliasAddress_h323_ID; + psNewAlias->value = (char*) memAlloc(pctxt, strlen(alias)+1); + if(!psNewAlias->value) + { + OOTRACEERR1("Error:Memory - ooParseDestination - psNewAlias->value\n"); + memFreePtr(pctxt, psNewAlias); + return OO_FAILED; + } + strcpy(psNewAlias->value, alias); + psNewAlias->next = *aliasList; + *aliasList = psNewAlias; + OOTRACEINFO2("Destination for new call is parsed as h323-id %s \n", + psNewAlias->value); + return OO_OK; +} + +const char* ooGetMsgTypeText (int msgType) +{ + static const char *msgTypeText[]={ + "OOQ931MSG", + "OOH245MSG", + "OOSetup", + "OOCallProceeding", + "OOAlert", + "OOConnect", + "OOReleaseComplete", + "OOFacility", + "OOInformation", + "OOMasterSlaveDetermination", + "OOMasterSlaveAck", + "OOMasterSlaveReject", + "OOMasterSlaveRelease", + "OOTerminalCapabilitySet", + "OOTerminalCapabilitySetAck", + "OOTerminalCapabilitySetReject", + "OOTerminalCapabilitySetRelease", + "OOOpenLogicalChannel", + "OOOpenLogicalChannelAck", + "OOOpenLogicalChannelReject", + "OOOpenLogicalChannelRelease", + "OOOpenLogicalChannelConfirm", + "OOCloseLogicalChannel", + "OOCloseLogicalChannelAck", + "OORequestChannelClose", + "OORequestChannelCloseAck", + "OORequestChannelCloseReject", + "OORequestChannelCloseRelease", + "OOEndSessionCommand" + }; + int idx = msgType - OO_MSGTYPE_MIN; + return ooUtilsGetText (idx, msgTypeText, OONUMBEROF(msgTypeText)); +} + +const char* ooGetQ931CauseValueText(int val) +{ + switch(val) + { + case Q931UnallocatedNumber: + return "Q931UnallocatedNumber"; + case Q931NoRouteToNetwork: + return "Q931NoRouteToNetwork"; + case Q931NoRouteToDestination: + return "Q931NoRouteToDestination"; + case Q931ChannelUnacceptable: + return "Q931ChannelUnacceptable"; + case Q931NormalCallClearing: + return "Q931NormalCallClearing"; + case Q931UserBusy: + return "Q931UserBusy"; + case Q931NoResponse: + return "Q931NoResponse"; + case Q931NoAnswer: + return "Q931NoAnswer"; + case Q931SubscriberAbsent: + return "Q931SubscriberAbsent"; + case Q931CallRejected: + return "Q931CallRejected"; + case Q931NumberChanged: + return "Q931NumberChanged"; + case Q931Redirection: + return "Q931Redirection"; + case Q931DestinationOutOfOrder: + return "Q931DestinationOutOfOrder"; + case Q931InvalidNumberFormat: + return "Q931InvalidNumberFormat"; + case Q931NormalUnspecified: + return "Q931NormalUnspecified"; + case Q931StatusEnquiryResponse: + return "Q931StatusEnquiryResponse"; + case Q931NoCircuitChannelAvailable: + return "Q931NoCircuitChannelAvailable"; + case Q931NetworkOutOfOrder: + return "Q931NetworkOutOfOrder"; + case Q931TemporaryFailure: + return "Q931TemporaryFailure"; + case Q931Congestion: + return "Q931Congestion"; + case Q931RequestedCircuitUnAvailable: + return "Q931RequestedCircuitUnavailable"; + case Q931ResourcesUnavailable: + return "Q931ResourcesUnavailable"; + case Q931IncompatibleDestination: + return "Q931IncompatibleDestination"; + case Q931ProtocolErrorUnspecified: + return "Q931ProtocolErrorUnspecified"; + case Q931RecoveryOnTimerExpiry: + return "Q931RecoveryOnTimerExpiry"; + case Q931InvalidCallReference: + return "Q931InvaliedCallReference"; + default: + return "Unsupported Cause Type"; + } + return "Unsupported Cause Type"; +} + diff --git a/addons/ooh323c/src/ooq931.h b/addons/ooh323c/src/ooq931.h new file mode 100644 index 000000000..a61ef8e6e --- /dev/null +++ b/addons/ooh323c/src/ooq931.h @@ -0,0 +1,766 @@ +/* + * 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. + * + *****************************************************************************/ +/** + * @file ooq931.h + * This file contains functions to support call signalling. + */ + +#ifndef _OOQ931HDR_H_ +#define _OOQ931HDR_H_ + +#include "ooasn1.h" +#include "ootypes.h" +#include "H323-MESSAGES.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +/** + * @defgroup q931 Q.931/H.2250 Message Handling + * @{ + */ +/* Maximum length of the Calling/Called party number number */ +#define OO_MAX_NUMBER_LENGTH 50 + +/* Maximum value for a call token identifier */ +#define OO_MAX_CALL_TOKEN 9999 + +/* Q.931 packet must be at least 5 bytes long */ +#define Q931_E_TOOSHORT (-1001) +/* callReference field must be 2 bytes long */ +#define Q931_E_INVCALLREF (-1002) +/* invalid length of message */ +#define Q931_E_INVLENGTH (-1003) + +enum Q931MsgTypes { + Q931NationalEscapeMsg = 0x00, + Q931AlertingMsg = 0x01, + Q931CallProceedingMsg = 0x02, + Q931ConnectMsg = 0x07, + Q931ConnectAckMsg = 0x0f, + Q931ProgressMsg = 0x03, + Q931SetupMsg = 0x05, + Q931SetupAckMsg = 0x0d, + Q931ResumeMsg = 0x26, + Q931ResumeAckMsg = 0x2e, + Q931ResumeRejectMsg = 0x22, + Q931SuspendMsg = 0x25, + Q931SuspendAckMsg = 0x2d, + Q931SuspendRejectMsg = 0x21, + Q931UserInformationMsg = 0x20, + Q931DisconnectMsg = 0x45, + Q931ReleaseMsg = 0x4d, + Q931ReleaseCompleteMsg = 0x5a, + Q931RestartMsg = 0x46, + Q931RestartAckMsg = 0x4e, + Q931SegmentMsg = 0x60, + Q931CongestionCtrlMsg = 0x79, + Q931InformationMsg = 0x7b, + Q931NotifyMsg = 0x6e, + Q931StatusMsg = 0x7d, + Q931StatusEnquiryMsg = 0x75, + Q931FacilityMsg = 0x62 +}; + +enum Q931IECodes { + Q931BearerCapabilityIE = 0x04, + Q931CauseIE = 0x08, + Q931FacilityIE = 0x1c, + Q931ProgressIndicatorIE = 0x1e, + Q931CallStateIE = 0x14, + Q931DisplayIE = 0x28, + Q931SignalIE = 0x34, + Q931CallingPartyNumberIE = 0x6c, + Q931CalledPartyNumberIE = 0x70, + Q931RedirectingNumberIE = 0x74, + Q931UserUserIE = 0x7e, + Q931KeypadIE = 0x2c +}; + +enum Q931InformationTransferCapability { + Q931TransferSpeech, + Q931TransferUnrestrictedDigital = 8, + Q931TransferRestrictedDigital = 9, + Q931Transfer3_1kHzAudio = 16, + Q931TrasnferUnrestrictedDigitalWithTones = 17, + Q931TransferVideo = 24 +}; + +enum Q931CauseValues { + Q931UnallocatedNumber = 0x01, + Q931NoRouteToNetwork = 0x02, + Q931NoRouteToDestination = 0x03, + Q931ChannelUnacceptable = 0x06, + Q931NormalCallClearing = 0x10, + Q931UserBusy = 0x11, + Q931NoResponse = 0x12, + Q931NoAnswer = 0x13, + Q931SubscriberAbsent = 0x14, + Q931CallRejected = 0x15, + Q931NumberChanged = 0x16, + Q931Redirection = 0x17, + Q931DestinationOutOfOrder = 0x1b, + Q931InvalidNumberFormat = 0x1c, + Q931NormalUnspecified = 0x1f, + Q931StatusEnquiryResponse = 0x1e, + Q931NoCircuitChannelAvailable = 0x22, + Q931NetworkOutOfOrder = 0x26, + Q931TemporaryFailure = 0x29, + Q931Congestion = 0x2a, + Q931RequestedCircuitUnAvailable = 0x2c, + Q931ResourcesUnavailable = 0x2f, + Q931IncompatibleDestination = 0x58, + Q931ProtocolErrorUnspecified = 0x6f, + Q931RecoveryOnTimerExpiry = 0x66, + Q931InvalidCallReference = 0x51, + Q931ErrorInCauseIE = 0 +}; + +enum Q931SignalInfo { + Q931SignalDialToneOn, + Q931SignalRingBackToneOn, + Q931SignalInterceptToneOn, + Q931SignalNetworkCongestionToneOn, + Q931SignalBusyToneOn, + Q931SignalConfirmToneOn, + Q931SignalAnswerToneOn, + Q931SignalCallWaitingTone, + Q931SignalOffhookWarningTone, + Q931SignalPreemptionToneOn, + Q931SignalTonesOff = 0x3f, + Q931SignalAlertingPattern0 = 0x40, + Q931SignalAlertingPattern1, + Q931SignalAlertingPattern2, + Q931SignalAlertingPattern3, + Q931SignalAlertingPattern4, + Q931SignalAlertingPattern5, + Q931SignalAlertingPattern6, + Q931SignalAlertingPattern7, + Q931SignalAlretingOff = 0x4f, + Q931SignalErrorInIE = 0x100 +}; + +enum Q931NumberingPlanCodes { + Q931UnknownPlan = 0x00, + Q931ISDNPlan = 0x01, + Q931DataPlan = 0x03, + Q931TelexPlan = 0x04, + Q931NationalStandardPlan = 0x08, + Q931PrivatePlan = 0x09, + Q931ReservedPlan = 0x0f +}; + +enum Q931TypeOfNumberCodes { + Q931UnknownType = 0x00, + Q931InternationalType = 0x01, + Q931NationalType = 0x02, + Q931NetworkSpecificType = 0x03, + Q931SubscriberType = 0x04, + Q931AbbreviatedType = 0x06, + Q931ReservedType = 0x07 +}; + +enum Q931CodingStandard{ + Q931CCITTStd = 0, + Q931ReservedInternationalStd, + Q931NationalStd, + Q931NetworkStd +}; + +enum Q931TransferMode { + Q931TransferCircuitMode = 0, /* 00 */ + Q931TransferPacketMode = 2 /* 10 */ +}; + +enum Q931TransferRate{ + Q931TransferRatePacketMode = 0x00, /* 00000 */ + Q931TransferRate64Kbps = 0x10, /* 10000 */ + Q931TransferRate128kbps = 0x11, /* 10001 */ + Q931TransferRate384kbps = 0x13, /* 10011 */ + Q931TransferRate1536kbps = 0x15, /* 10101 */ + Q931TransferRate1920kbps = 0x17 /* 10111 */ +}; + +enum Q931UserInfoLayer1Protocol{ + Q931UserInfoLayer1CCITTStdRate = 1, + Q931UserInfoLayer1G711ULaw, + Q931UserInfoLayer1G711ALaw, + Q931UserInfoLayer1G721ADPCM, + Q931UserInfoLayer1G722G725, + Q931UserInfoLayer1H261, + Q931UserInfoLayer1NonCCITTStdRate, + Q931UserInfoLayer1CCITTStdRateV120, + Q931UserInfoLayer1X31 +}; + +/* + Structure to build store outgoing encoded UUIE + The different fields in the structure have octet lengths + as specified in the spec. +*/ +typedef struct Q931InformationElement { + int discriminator; + int offset; + int length; + ASN1OCTET data[1]; +} Q931InformationElement; + +/** + * Q.931 message structure. Contains context for memory allocation, + * protocol discriminator, call reference, meesage type and list of + * user-user information elements (IEs). + */ +typedef struct Q931Message { + ASN1UINT protocolDiscriminator; + ASN1UINT callReference; + ASN1BOOL fromDestination; + ASN1UINT messageType; /* Q931MsgTypes */ + ASN1UINT tunneledMsgType; /* The H245 message this message is tunneling*/ + ASN1INT logicalChannelNo; /* channel number associated with tunneled */ + /* message, 0 if no channel */ + DList ies; + Q931InformationElement *bearerCapabilityIE; + Q931InformationElement *callingPartyNumberIE; + Q931InformationElement *calledPartyNumberIE; + Q931InformationElement *causeIE; + Q931InformationElement *keypadIE; + H225H323_UserInformation *userInfo; +} Q931Message; + +/** + * This structure is used to hold an H.323 alias address. + */ +typedef struct OOAliases { + int type; /*!< H.225 AliasAddress choice option (t value) */ + char *value; /*!< H.225 AliasAddress value */ + OOBOOL registered; + struct OOAliases *next; +} OOAliases; + +#define ooAliases OOAliases + +struct OOH323CallData; + +/* + * These are message callbacks which can be used by user applications + * to perform application specific things on receiving a particular + * message or before sending a particular message. For ex. user application + * can change values of some parameters of setup message before it is actually + * sent out. + */ +/** + * This callback is triggered when an H.225 SETUP message is received by + * the application. + * @param call The call the message is associated with. + * @param pmsg Q.931 message structure. + * @return OO_OK if message processing successful or OO_FAILED if not. + */ +typedef int (*cb_OnReceivedSetup) + (struct OOH323CallData *call, struct Q931Message *pmsg); + +/** + * This callback is triggered when an H.225 CONNECT message is received by + * the application. + * @param call The call the message is associated with. + * @param pmsg Q.931 message structure. + * @return OO_OK if message processing successful or OO_FAILED if not. + */ +typedef int (*cb_OnReceivedConnect) + (struct OOH323CallData *call, struct Q931Message *pmsg); + +/** + * This callback is triggered after an H.225 SETUP message has been + * constructed and is ready to be sent out. It provides the application + * with an opportunity to add additional non-standard information. + * @param call The call the message is associated with. + * @param pmsg Q.931 message structure. + * @return OO_OK if message processing successful or OO_FAILED if not. + */ +typedef int (*cb_OnBuiltSetup) + (struct OOH323CallData *call, struct Q931Message *pmsg); + +/** + * This callback is triggered after an H.225 CONNECT message has been + * constructed and is ready to be sent out. It provides the application + * with an opportunity to add additional non-standard information. + * @param call The call the message is associated with. + * @param pmsg Q.931 message structure. + * @return OO_OK if message processing successful or OO_FAILED if not. + */ +typedef int (*cb_OnBuiltConnect) + (struct OOH323CallData *call, struct Q931Message *pmsg); + +/** + * This structure holds the various callback functions that are + * triggered when H.225 messages are received or constructed. + * @see ooH323EpSetH225MsgCallbacks + */ +typedef struct OOH225MsgCallbacks { + cb_OnReceivedSetup onReceivedSetup; + cb_OnReceivedConnect onReceivedConnect; + cb_OnBuiltSetup onBuiltSetup; + cb_OnBuiltConnect onBuiltConnect; +} OOH225MsgCallbacks; + +/** + * This function is invoked to decode a Q931 message. + * + * @param call Handle to call which owns the message. + * @param msg Pointer to the Q931 message + * @param length Length of the encoded data + * @param data Pointer to the data to be decoded + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooQ931Decode +(struct OOH323CallData *call, Q931Message* msg, int length, ASN1OCTET *data); + +/** + * This function is used to decode the UUIE of the message from the list of + * ies. It decodes the User-User ie and populates the userInfo field of the + * message. + * @param q931Msg Pointer to the message whose User-User ie has to be + * decoded. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooDecodeUUIE(Q931Message *q931Msg); + +/** + * This function is used to encode the UUIE field of the Q931 message. + * It encodes UUIE and adds the encoded data to the list of ies. + * @param q931msg Pointer to the Q931 message whose UUIE field has to be + * encoded. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooEncodeUUIE(Q931Message *q931msg); + +/** + * This function is invoked to retrieve an IE element from a Q931 message. + * + * @param q931msg Pointer to the Q931 message + * @param ieCode IE code for the IE element to be retrieved + * + * @return Pointer to a Q931InformationElement contating + * the IE element. + */ +EXTERN Q931InformationElement* ooQ931GetIE (const Q931Message* q931msg, + int ieCode); + +/** + * This function is invoked to print a Q931 message. + * + * @param q931msg Pointer to the Q931 message + * + * @return - none + */ +EXTERN void ooQ931Print (const Q931Message* q931msg); + + +/** + * This function is invoked to create an outgoing Q931 message. + * + * @param msg Reference to the pointer of type Q931 message. + * @param msgType Type of Q931 message to be created + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooCreateQ931Message(Q931Message **msg, int msgType); + +/** + * This function is invoked to generate a unique call reference number. + * + * @return - call reference number + */ +EXTERN ASN1USINT ooGenerateCallReference(void); + + +/** + * This function is used to generate a unique call identifier for the call. + * @param callid Pointer to the callid structure, which will be populated + * with the generated callid. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooGenerateCallIdentifier(H225CallIdentifier *callid); + +/** + * This function is invoked to release the memory used up by a Q931 message + * + * @param q931Msg Pointer to a Q931 message which has to be freed. + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooFreeQ931Message(Q931Message *q931Msg); + +/** + * This function is invoked to retrive the outgoing message buffer for + * Q931 message + * + * @param call Pointer to call for which outgoing Q931 message has to be + * retrieved. + * @param msgbuf Pointer to a buffer in which retrieved message will + * be returned. + * @param len Pointer to int in which length of the buffer will + * be returned. + * @param msgType Pointer to integer in which message type of the ougoing + * message is returned. + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooGetOutgoingQ931Msgbuf +(struct OOH323CallData *call, ASN1OCTET * msgbuf, int* len, int *msgType); + +/** + * This function is invoked to send a ReleaseComplete message for + * the currently active call. + * + * @param call Pointer to the call for which ReleaseComplete message have + * to be sent. + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooSendReleaseComplete(struct OOH323CallData *call); + +/** + * This function is invoked to send a call proceeding message in response to + * received setup message. + * + * @param call Pointer to the call for which CallProceeding message have to + * be sent. + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooSendCallProceeding(struct OOH323CallData *call); + +/** + * This function is invoked to send alerting message in response to received + * setup message. + * + * @param call Pointer to the call for which Alerting message have to be + * sent. + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooSendAlerting(struct OOH323CallData *call); + +/** + * This function is invoked to send Facility message. + * + * @param call Pointer to the call for which Facility message have to be + * sent. + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooSendFacility(struct OOH323CallData *call); + + +/** + * This function is used to send dtmf data as Q931 keypad information element + * as part of information message. + * @param call Pointer to the call for dtmf data has to be sent. + * @param data Dtmf data to be sent. + * + * @return OO_OK, on success; OO_FAILED, on failure. + */ +EXTERN int ooQ931SendDTMFAsKeyPadIE + (struct OOH323CallData *call, const char* data); + +/** + * This function is invoked to send a Connect message in response to received + * setup message. + * + * @param call Pointer to the call for which connect message has to be + * sent. + * + * @return Completion status - 0 on success, -1 on failure + */ +EXTERN int ooSendConnect(struct OOH323CallData *call); + +/** + * This function is used to send a SETUP message for outgoing call. It first + * creates an H.225 TCP connection with the remote end point and then sends + * SETUP message over this connection. + * @param dest Destination - IP:Port/alias. + * @param callToken Unique token for the new call. + * @param opts Call specific options. If passed a non-null value, these + * options will override global endpoint settings. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +EXTERN int ooH323MakeCall(char *dest, char *callToken, ooCallOptions *opts); + +/** + * Helper function used to make a call once it is approved by the Gk. + * In case of no gk, this function is directly called to make a call. + * @param call Handle to the new call. + * + * @return OO_OK, on success. OO_FAILED, on failure + */ +int ooH323CallAdmitted( struct OOH323CallData *call); + +/** + * This function is used to handle a call forward request sent to local + * endpoint by remote endpoint. + * @param call Handle to the call which is being forwarded + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooH323HandleCallFwdRequest(struct OOH323CallData *call); + +/** + * This function is used for forwarding/redirecting a call to third party. + * @param callToken callToken for the call which has to be redirected. + * @param dest Address to which call has to be forwarded. Can be + * IP:Port or alias. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooH323ForwardCall(char* callToken, char *dest); + +/** + * This function is used to hangup a currently active call. It sets the call + * state to CLEARING and initiates closing of all logical channels. + * @param callToken Unique token of the call to be hanged. + * @param reason Reason for ending call. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooH323HangCall(char * callToken, OOCallClearReason reason); + + +/** + * Function to accept a call by sending connect. This function is used + * as a helper function to ooSendConnect. + * @param call Pointer to the call for which connect has to be sent + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooAcceptCall(struct OOH323CallData *call); + +/* + * An helper function to ooMakeCall. + * @param call Pointer to the new call. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooH323MakeCall_helper(struct OOH323CallData *call); + +/** + * This function is used to parse the destination + * @param call Handle to related call. + * @param dest Destination string to be parsed. + * @param parsedIP Pointer to buffer in which parsed ip:port will be returned. + * @param len Length of the buffer passed. + * @param aliasList Aliase List in which new aliases will be added. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooParseDestination + (struct OOH323CallData *call, char *dest, char *parsedIP, unsigned len, + OOAliases** aliasList); + +/** + * This function is used to generate a new call token + * @param callToken Handle to the buffer in which new call token will be + * returned + * @param size size of the buffer + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooGenerateCallToken (char *callToken, size_t size); + + +/** + * This function sends an encoded H.245 message buffer as a tunneled + * H.245 Facility message. + * @param call Pointer to the call for which H.245 message has to + * be tunneled. + * @param msgbuf Pointer to the encoded H.245 message to be tunneled. + * + * @param h245Len Length of the encoded H.245 message buffer. + * @param h245MsgType Type of the H245 message + * @param associatedChan The logical channel number with which the tunneled + * message is associated. In case of no channel, this + * value should be 0. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooSendAsTunneledMessage +(struct OOH323CallData *call, ASN1OCTET* msgbuf, + int h245Len, int h245MsgType, int associatedChan); + + +/** + * This function is used to encode an H.225 message. + * @param call Handle to the call. + * @param pq931Msg Pointer to the message to be encoded. + * @param msgbuf Pointer to the buffer in which encoded message will + * be returned. + * @param size Size of the buffer passed. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooEncodeH225Message(struct OOH323CallData *call, Q931Message *pq931Msg, + char *msgbuf, int size); + +/** + * This is a callback function which is called when there is no CONNECT + * response from the remote endpoint after the SETUP has been sent and timeout + * period has passed. + * @param data The callback data registered at the time of timer + * creation. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +int ooCallEstbTimerExpired(void *data); + + + +/** + * This function is used to add a keypad IE to a Q931 message for sending dtmf. + * @param pmsg Q931 message to which keypad ie has to be + * added. + * @param data DTMF data to be sent. + * + * @return OO_OK on success, OO_FAILED, on failure. + */ +EXTERN int ooQ931SetKeypadIE(Q931Message *pmsg, const char* data); + +/** + * This function is used to add a bearer capability IE to a Q931 message. + * @param pmsg Q931 message to which bearer capability ie has to be + * added. + * @param codingStandard Coding standard to be used. + * @param capability Information transfer capability + * @param transferMode Information transfer mode.(circuit/packet modes). + * @param transferRate Information transfer rate. + * @param userInfoLayer1 User information layer 1 protocol. + * + * @return OO_OK on success, OO_FAILED, on failure. + */ +EXTERN int ooSetBearerCapabilityIE + (Q931Message *pmsg, enum Q931CodingStandard codingStandard, + enum Q931InformationTransferCapability capability, + enum Q931TransferMode transferMode, enum Q931TransferRate transferRate, + enum Q931UserInfoLayer1Protocol userInfoLayer1); + +/** + * This function is used to add a called party number ie to a q931 message. + * @param pmsg Q931 message to which CalledPartyNumber IE has to be + * added. + * @param number Number for called party. + * @param plan Numbering Plan used + * @param type Type of number + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooQ931SetCalledPartyNumberIE + (Q931Message *pmsg, const char *number, unsigned plan, unsigned type); + + +/** + * This function is used to add a CallingPartyNumber ie to a q931 message. + * @param pmsg Q931 message to which CallingPartyNumber IE has to be + * added. + * @param number Number for calling party. + * @param plan Numbering Plan used + * @param type Type of number + * @param presentation Presentation of the address is allowed or restricted. + * @param screening Whether address was provided by endpoint or screened + * by gatekeeper. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooQ931SetCallingPartyNumberIE + (Q931Message *pmsg, const char *number, unsigned plan, unsigned type, + unsigned presentation, unsigned screening); + +/** + * This function is used to set a cause ie for a q931 message. + * @param pmsg Valid Q931 Message + * @param cause Q931 Cause Value + * @param coding coding standard used. 0 for ITU-T standard coding + * @param location location. 0 for user. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooQ931SetCauseIE + (Q931Message *pmsg,enum Q931CauseValues cause, unsigned coding, + unsigned location); + +/** + * This function is used to convert a call clear reason to cause and + * reason code. It is used when local user is endoing the call and + * sending releaseComplete. + * @param clearReason Reason for ending call. + * @param cause Pointer to Q931CauseVaules enum in which cause + * will be returned. + * @param reasonCode Pointer to unsigned int in which reasonCode will + * be returned. + * + * @return OO_OK, on success. OO_FAILED, on failure. + */ +EXTERN int ooQ931GetCauseAndReasonCodeFromCallClearReason + (OOCallClearReason clearReason, enum Q931CauseValues *cause, + unsigned *reasonCode); + +/** + * This function is used to convert a cause value and reason code received + * in ReleaseComplete message from remote endpoint into a CallClearReason. + * @param cause cause value received. + * @param reasonCode reasonCode received. + * + * @return Returns a CallClearReason. + */ +EXTERN OOCallClearReason ooGetCallClearReasonFromCauseAndReasonCode + (enum Q931CauseValues cause, unsigned reasonCode); + +/** + * This function is used to retrieve the description text for a + * message type. + * + * @param msgType Message type. + * @return The text description string. + */ +EXTERN const char* ooGetMsgTypeText (int msgType); + +/** + * This function is used to retrieve the text description for a Q931 Cause + * value in Cause IE. + * @param val Q931 Cause value + * @return The text description string + */ +EXTERN const char* ooGetQ931CauseValueText (int val); + +/** + * @} + */ +#ifdef __cplusplus +} +#endif + +#endif /* __Q931HDR_H */ diff --git a/addons/ooh323c/src/ootrace.c b/addons/ooh323c/src/ootrace.c new file mode 100644 index 000000000..0fd5a68ed --- /dev/null +++ b/addons/ooh323c/src/ootrace.c @@ -0,0 +1,131 @@ +/* + * 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 +#include +#include +#include + +#include "ootypes.h" +#include "ootrace.h" +#include "ooCommon.h" +#include "ooCapability.h" +#include "ooq931.h" +#include "ooh245.h" +#include "ooh323ep.h" + +/** Global endpoint structure */ +extern OOH323EndPoint gH323ep; + +static OOUINT32 gs_traceLevel = TRACELVL; + +void ooSetTraceThreshold(OOUINT32 traceLevel) +{ + gs_traceLevel = traceLevel; +} + +void ooTrace(OOUINT32 traceLevel, const char * fmtspec, ...) +{ + va_list arglist; + char logMessage[MAXLOGMSGLEN]; + if(traceLevel > gs_traceLevel) return; + va_start (arglist, fmtspec); + /* memset(logMessage, 0, MAXLOGMSGLEN);*/ + vsprintf(logMessage, fmtspec, arglist); + va_end(arglist); + ooTraceLogMessage(logMessage); +} + +void ooTraceLogMessage(const char * logMessage) +{ + char timeString[100]; + char currtime[3]; + static int lasttime=25; + int printDate =0; + static int printTime=1; + +#ifdef _WIN32 + + SYSTEMTIME systemTime; + GetLocalTime(&systemTime); + GetTimeFormat(LOCALE_SYSTEM_DEFAULT,0, &systemTime, "HH':'mm':'ss", + timeString, 100); + GetTimeFormat(LOCALE_SYSTEM_DEFAULT,0, &systemTime, "H", currtime, 3); + if(lasttime> atoi(currtime)) + printDate=1; + lasttime = atoi(currtime); + +#else + struct tm *ptime; + char dateString[15]; + time_t t = time(NULL); + ptime = localtime(&t); + strftime(timeString, 100, "%H:%M:%S", ptime); + strftime(currtime, 3, "%H", ptime); + if(lasttime>atoi(currtime)) + printDate = 1; + lasttime = atoi(currtime); +#endif + + +#ifdef _WIN32 + if(printDate) + { + printDate = 0; + fprintf(gH323ep.fptraceFile, "---------Date %d/%d/%d---------\n", + systemTime.wMonth, systemTime.wDay, systemTime.wYear); + } + if(printTime) { + fprintf(gH323ep.fptraceFile, "%s:%03d %s", timeString, + systemTime.wMilliseconds, logMessage); + } + else + fprintf(gH323ep.fptraceFile, "%s", logMessage); + + fflush(gH323ep.fptraceFile); +#else + if(printDate) + { + printDate = 0; + strftime(dateString, 15, "%m/%d/%Y", ptime); + fprintf(gH323ep.fptraceFile, "---------Date %s---------\n", + dateString); + } + if(printTime) { + struct timeval systemTime; + gettimeofday(&systemTime, NULL); + fprintf(gH323ep.fptraceFile, "%s:%03ld %s", timeString, + systemTime.tv_usec/1000, logMessage); + } + else + fprintf(gH323ep.fptraceFile, "%s", logMessage); + + fflush(gH323ep.fptraceFile); +#endif + + if(strchr(logMessage, '\n')) + printTime = 1; + else + printTime = 0; + +} + +int ooLogAsn1Error(int stat, const char * fname, int lno) +{ + OOTRACEERR4("Asn1Error: %d at %s:%d\n", stat, fname, lno); + return stat; +} + diff --git a/addons/ooh323c/src/ootrace.h b/addons/ooh323c/src/ootrace.h new file mode 100644 index 000000000..9678c8979 --- /dev/null +++ b/addons/ooh323c/src/ootrace.h @@ -0,0 +1,152 @@ +/* + * 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. + * + *****************************************************************************/ + +/** + * @file ootrace.h + * This file defines the trace functionality + */ +#include "ooCommon.h" +#ifndef _OOTRACE_H_ +#define _OOTRACE_H_ + + +/* tracing */ +#define OOTRCLVLERR 1 +#define OOTRCLVLWARN 2 +#define OOTRCLVLINFO 3 +#define OOTRCLVLDBGA 4 +#define OOTRCLVLDBGB 5 +#define OOTRCLVLDBGC 6 + +#ifdef _OOWARNING +#define TRACELVL OOTRCLVLWARN +#endif +#ifdef _OOINFO +#define TRACELVL OOTRCLVLINFO +#endif +#ifdef _OODEBUGA +#define TRACELVL OOTRCLVLDBGA +#endif +#ifdef _OODEBUGB +#define TRACELVL OOTRCLVLDBGB +#endif +#ifdef _OODEBUGC +#define TRACELVL OOTRCLVLDBGC +#endif + +/* Ensure we always log error messages */ +#ifndef TRACELVL +#define TRACELVL 1 +#endif + +#define OOTRACEERR1(a) ooTrace(OOTRCLVLERR,"%s", a) +#define OOTRACEERR2(a,b) ooTrace(OOTRCLVLERR,a,b) +#define OOTRACEERR3(a,b,c) ooTrace(OOTRCLVLERR,a,b,c) +#define OOTRACEERR4(a,b,c,d) ooTrace(OOTRCLVLERR,a,b,c,d) +#define OOTRACEWARN1(a) ooTrace(OOTRCLVLWARN,a) +#define OOTRACEWARN2(a,b) ooTrace(OOTRCLVLWARN,a,b) +#define OOTRACEWARN3(a,b,c) ooTrace(OOTRCLVLWARN,a,b,c) +#define OOTRACEWARN4(a,b,c,d) ooTrace(OOTRCLVLWARN,a,b,c,d) +#define OOTRACEINFO1(a) ooTrace(OOTRCLVLINFO, a) +#define OOTRACEINFO2(a,b) ooTrace(OOTRCLVLINFO,a,b) +#define OOTRACEINFO3(a,b,c) ooTrace(OOTRCLVLINFO,a,b,c) +#define OOTRACEINFO4(a,b,c,d) ooTrace(OOTRCLVLINFO,a,b,c,d) +#define OOTRACEINFO5(a,b,c,d,e) ooTrace(OOTRCLVLINFO,a,b,c,d,e) +#define OOTRACEINFO6(a,b,c,d,e,f) ooTrace(OOTRCLVLINFO,a,b,c,d,e, f) +#ifndef _COMPACT +#define OOTRACEDBGA1(a) ooTrace(OOTRCLVLDBGA,a) +#define OOTRACEDBGA2(a,b) ooTrace(OOTRCLVLDBGA,a,b) +#define OOTRACEDBGA3(a,b,c) ooTrace(OOTRCLVLDBGA,a,b,c) +#define OOTRACEDBGA4(a,b,c,d) ooTrace(OOTRCLVLDBGA,a,b,c,d) +#define OOTRACEDBGA5(a,b,c,d,e) ooTrace(OOTRCLVLDBGA,a,b,c,d,e) +#define OOTRACEDBGB1(a) ooTrace(OOTRCLVLDBGB,"%s",a) +#define OOTRACEDBGB2(a,b) ooTrace(OOTRCLVLDBGB,a,b) +#define OOTRACEDBGB3(a,b,c) ooTrace(OOTRCLVLDBGB,a,b,c) +#define OOTRACEDBGB4(a,b,c,d) ooTrace(OOTRCLVLDBGB,a,b,c,d) +#define OOTRACEDBGC1(a) ooTrace(OOTRCLVLDBGC,a) +#define OOTRACEDBGC2(a,b) ooTrace(OOTRCLVLDBGC,a,b) +#define OOTRACEDBGC3(a,b,c) ooTrace(OOTRCLVLDBGC,a,b,c) +#define OOTRACEDBGC4(a,b,c,d) ooTrace(OOTRCLVLDBGC,a,b,c,d) +#define OOTRACEDBGC5(a,b,c,d,e) ooTrace(OOTRCLVLDBGC,a,b,c,d,e) +#else +#define OOTRACEDBGA1(a) +#define OOTRACEDBGA2(a,b) +#define OOTRACEDBGA3(a,b,c) +#define OOTRACEDBGA4(a,b,c,d) +#define OOTRACEDBGA5(a,b,c,d,e) +#define OOTRACEDBGB1(a) +#define OOTRACEDBGB2(a,b) +#define OOTRACEDBGB3(a,b,c) +#define OOTRACEDBGB4(a,b,c,d) +#define OOTRACEDBGC1(a) +#define OOTRACEDBGC2(a,b) +#define OOTRACEDBGC3(a,b,c) +#define OOTRACEDBGC4(a,b,c,d) +#define OOTRACEDBGC5(a,b,c,d,e) +#endif + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +/** + * This function is used to set the trace level. + * @param traceLevel New trace level. Various values are: OOTRCLVLERR, + * OOTRCLVLWARN, OOTRCLVLINFO, OOTRCLVLDBGA, OOTRCLVLDBGB, + * OOTRCLVLDBGC + * + * @return None + */ +EXTERN void ooSetTraceThreshold(OOUINT32 traceLevel); + +/** + * This function is used to write the messages to the trace file. + * + * @param traceLevel Trace level for the message. + * @param fmtspec Printf style format spec. + * @param ... Printf style variable list of arguments + * + * @return - none + */ +EXTERN void ooTrace(OOUINT32 traceLevel, const char * fmtspec, ...)__attribute__((format(printf, 2, 3))); + +/** + * Helper function for the trace function. This function performs actual + * writing to file. + * @param logMessage Log message to be writted to file. + * + * @return - none + */ +void ooTraceLogMessage(const char * logMessage); + +/** + * + */ +void ooChangeIPToNWOrder(char * internetIP, char* networkIP); + +int ooLogAsn1Error(int stat, const char * fname, int lno); +#ifdef __cplusplus +} +#endif +#endif diff --git a/addons/ooh323c/src/ootypes.h b/addons/ooh323c/src/ootypes.h new file mode 100644 index 000000000..51b97e41c --- /dev/null +++ b/addons/ooh323c/src/ootypes.h @@ -0,0 +1,256 @@ +/* + * 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. + * + *****************************************************************************/ +/*! \mainpage + *

ooH323c Stack Functions

+ * + * The Objective Open H.323 for C (ooH323c) protocol stack is an + * open source applications program interface (API) for building H.323 based + * applications. The stack implements Q.931/H.225 call signaling procedures, + * H.245 logical channel operations, and Registration, Admission, and Status + * (RAS) messaging for Gatekeeper communications. + * + * The categories of user functions provided are as follows: + *
    + *
  • Stack command functions. These are high level functions used to + * initiate common H.323 telephony operations (for example, to make a + * call).
    • + *
  • Gatekeeper functions. These are high level functions for + * managing communications with a gatekeeper using RAS messages.
    • + *
  • H.323 endpoint management functions. These are function for + * used for managing the global H.323 endpoint.
    • + *
  • Call management functions. These are functions used to manage + * active calls within the stack.
    • + *
  • Capability management functions. These functions are used for + * negotiating capabilities between two different terminals.
    • + *
  • H.225 and H.245 message handling functions. Functions for + * creating and handling H.323 standard ASN.1 messages.
    • + *
  • Q.931 functions. Functions for the execution of various + * standard Q.931 operations.
    • + *
  • TCP/IP and UDP socket communication functions. Low-level + * functions for writing data to and receiving data from sockets.
    • + *
+ */ +/** + * @file ootypes.h + * This file contains definitions of common constants and data structures. + */ +#ifndef _OOTYPES_H_ +#define _OOTYPES_H_ + +#include "ooSocket.h" +#include "MULTIMEDIA-SYSTEM-CONTROL.h" +#include "H323-MESSAGES.h" +#include "ooasn1.h" + +#ifdef HAVE_CONFIG_H +#include "config.h" +#endif + + + +#define OOH323C_VERSION "v0.8.3" + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ + +/** + * @defgroup ootypes Common type and constant definitions. + * @{ + */ +/* Function return codes */ +#define OO_FAILED -1 +#define OO_OK 0 + +/* TODO: States for both local and remote initiation should be maintained + separately */ +/** + * States defined for master/slave determination procedure. + */ +typedef enum OOMasterSlaveState { + OO_MasterSlave_Idle, + OO_MasterSlave_DetermineSent, + OO_MasterSlave_AckReceived, + OO_MasterSlave_Master, + OO_MasterSlave_Slave +} OOMasterSlaveState; + +/** + * States defined for the capability exchange procedure. + */ +typedef enum { + OO_LocalTermCapExchange_Idle, + OO_LocalTermCapSetSent, + OO_LocalTermCapSetAckRecvd, + OO_RemoteTermCapExchange_Idle, + OO_RemoteTermCapSetRecvd, + OO_RemoteTermCapSetAckSent +} OOCapExchangeState; + +/** + * Call clear reason codes. + */ +typedef enum OOCallClearReason { + OO_REASON_UNKNOWN=0, + OO_REASON_INVALIDMESSAGE, + OO_REASON_TRANSPORTFAILURE, + OO_REASON_NOROUTE, + OO_REASON_NOUSER, + OO_REASON_NOBW, + OO_REASON_GK_NOCALLEDUSER, + OO_REASON_GK_NOCALLERUSER, + OO_REASON_GK_NORESOURCES, + OO_REASON_GK_UNREACHABLE, + OO_REASON_GK_CLEARED, + OO_REASON_NOCOMMON_CAPABILITIES, + OO_REASON_REMOTE_FWDED, + OO_REASON_LOCAL_FWDED, + OO_REASON_REMOTE_CLEARED, + OO_REASON_LOCAL_CLEARED, + OO_REASON_REMOTE_BUSY, + OO_REASON_LOCAL_BUSY, + OO_REASON_REMOTE_NOANSWER, + OO_REASON_LOCAL_NOTANSWERED, + OO_REASON_REMOTE_REJECTED, + OO_REASON_LOCAL_REJECTED, + OO_REASON_REMOTE_CONGESTED, + OO_REASON_LOCAL_CONGESTED +} OOCallClearReason; + +/** Terminal type of the endpoint. Default is 60. */ +#define OOTERMTYPE 60 + +/** Maximum length of an IP address (xxx.xxx.xxx.xxx). */ +#define MAX_IP_LENGTH 15 + +/** Maximum length of a log file message */ +#define MAXLOGMSGLEN 2048 + +/** Number of times to retry a failed operation. */ +#define DEFAULT_MAX_RETRIES 3 + +/** + Various message types for H225 and H245 messages +*/ +#define OO_MSGTYPE_MIN 101 +#define OOQ931MSG 101 +#define OOH245MSG 102 +#define OOSetup 103 +#define OOCallProceeding 104 +#define OOAlert 105 +#define OOConnect 106 +#define OOReleaseComplete 107 +#define OOFacility 108 +#define OOInformationMessage 109 +#define OOMasterSlaveDetermination 110 +#define OOMasterSlaveAck 111 +#define OOMasterSlaveReject 112 +#define OOMasterSlaveRelease 113 +#define OOTerminalCapabilitySet 114 +#define OOTerminalCapabilitySetAck 115 +#define OOTerminalCapabilitySetReject 116 +#define OOTerminalCapabilitySetRelease 117 +#define OOOpenLogicalChannel 118 +#define OOOpenLogicalChannelAck 119 +#define OOOpenLogicalChannelReject 120 +#define OOOpenLogicalChannelRelease 121 +#define OOOpenLogicalChannelConfirm 122 +#define OOCloseLogicalChannel 123 +#define OOCloseLogicalChannelAck 124 +#define OORequestChannelClose 125 +#define OORequestChannelCloseAck 126 +#define OORequestChannelCloseReject 127 +#define OORequestChannelCloseRelease 128 +#define OOEndSessionCommand 129 +#define OOUserInputIndication 130 + +#define OO_MSGTYPE_MAX 130 + +/* Timer types */ +#define OO_CALLESTB_TIMER (1<<0) +#define OO_MSD_TIMER (1<<1) +#define OO_TCS_TIMER (1<<2) +#define OO_OLC_TIMER (1<<3) +#define OO_CLC_TIMER (1<<4) +#define OO_RCC_TIMER (1<<5) +#define OO_SESSION_TIMER (1<<6) +#define OO_H245CONNECT_TIMER (1<<7) + +/** Maximum length for received messages */ +#define MAXMSGLEN 4096 + +/** Maximum length of a filename */ +#define MAXFILENAME 256 + +/** + * Endpoint call modes. The call mode of the endpoint dictates what type + * of channels are created for the calls placed by the endpoint or received + * by the endpoint. + */ +typedef enum OOCallMode { + OO_CALLMODE_AUDIOCALL, /*!< Audio call */ + OO_CALLMODE_AUDIORX, /*!< Audio call - receive only */ + OO_CALLMODE_AUDIOTX, /*!< Audio call - transmit only */ + OO_CALLMODE_VIDEOCALL, /*!< Video call */ + OO_CALLMODE_FAX /*!< Fax transmission */ +} OOCallMode; + +/* + * Flag macros - these operate on bit mask flags using mask values + */ +/** This macro sets a flag within a bit mask */ +#define OO_SETFLAG(flags,mask) (flags |= (ASN1UINT)mask) + +/** This macro clears a flag within a bit mask */ +#define OO_CLRFLAG(flags,mask) (flags &= ~(ASN1UINT)mask) + +/** This macro tests a flag with a bit mask */ +#define OO_TESTFLAG(flags,mask) (((ASN1UINT)flags & (ASN1UINT)mask) != 0) + + + +/*TODO: Should add caller-id, callername etc. So that they can be changed per + call basis*/ +/** + * This structure defines options that can be set at the level of an + * individual call. They override options set in the H.323 endpoint + * structure. + */ +typedef struct ooCallOptions { + OOBOOL fastStart; /*!< Use FastStart signaling */ + OOBOOL tunneling; /*!< Use H.245 tunneling */ + OOBOOL disableGk; /*!< Disable use of gatekeeper */ + OOCallMode callMode; /*!< Type of channel to setup with FastStart */ +}ooCallOptions; + + +struct OOH323CallData; + +typedef struct ooTimerCallback{ + struct OOH323CallData* call; + ASN1UINT timerType; + ASN1UINT channelNumber; +} ooTimerCallback; + +/** + * @} + */ +#endif + diff --git a/addons/ooh323c/src/perutil.c b/addons/ooh323c/src/perutil.c new file mode 100644 index 000000000..c3c7b3696 --- /dev/null +++ b/addons/ooh323c/src/perutil.c @@ -0,0 +1,287 @@ +/* + * Copyright (C) 1997-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 "ooper.h" + +ASN1BOOL isExtendableSize (Asn1SizeCnst* pSizeList); +static ASN1BOOL isFixedSize (Asn1SizeCnst* pSizeList); + +ASN1BOOL alignCharStr +(OOCTXT* pctxt, ASN1UINT len, ASN1UINT nbits, Asn1SizeCnst* pSize) +{ + if (TRUE) { + ASN1UINT lower, upper; + ASN1BOOL doAlign = (len > 0), extendable; + + pSize = checkSize (pSize, len, &extendable); + + if (0 != pSize) { + lower = pSize->lower; + upper = pSize->upper; + } + else { + lower = 0; + upper = ASN1UINT_MAX; + } + + if (!extendable && upper < 65536) { + ASN1UINT bitRange = upper * nbits; + if (upper == lower) { + /* X.691, clause 26.5.6 */ + if (bitRange <= 16) doAlign = FALSE; + } + else { + /* X.691, clause 26.5.7 */ + if (bitRange < 16) doAlign = FALSE; + } + } + + return doAlign; + } + else + return FALSE; +} + +int bitAndOctetStringAlignmentTest (Asn1SizeCnst* pSizeList, + ASN1UINT itemCount, + ASN1BOOL bitStrFlag, + ASN1BOOL* pAlignFlag) +{ + ASN1UINT threshold = (bitStrFlag) ? 16 : 2; + + if (pSizeList == 0 || itemCount > threshold) + *pAlignFlag = TRUE; + else if (isFixedSize(pSizeList)) + *pAlignFlag = FALSE; + else { + + /* Variable length case: check size.. no alignment required if */ + /* lower == upper and not extended.. */ + + ASN1BOOL extended; + Asn1SizeCnst* pSize = checkSize (pSizeList, itemCount, &extended); + + if (pSize != 0) + *pAlignFlag = ((pSize->upper != pSize->lower) || pSize->extended); + else { + /* Note: we never should get here because constraint */ + /* violation should have been caught when length was encoded */ + /* or decoded.. */ + return (ASN_E_CONSVIO); + } + } + + return (ASN_OK); +} + +Asn1SizeCnst* checkSize (Asn1SizeCnst* pSizeList, + ASN1UINT value, + ASN1BOOL* pExtendable) +{ + Asn1SizeCnst* lpSize = pSizeList; + *pExtendable = isExtendableSize (lpSize); + + while (lpSize) { + if (value >= lpSize->lower && value <= lpSize->upper) { + return (lpSize); + } + else lpSize = lpSize->next; + } + + return 0; +} + +int getPERMsgLen (OOCTXT* pctxt) +{ + return (pctxt->buffer.bitOffset == 8) ? + pctxt->buffer.byteIndex : pctxt->buffer.byteIndex + 1; +} + +int addSizeConstraint (OOCTXT* pctxt, Asn1SizeCnst* pSize) +{ + Asn1SizeCnst* lpSize; + int stat = ASN_OK; + + /* If constraint does not already exist, add it */ + + if (!pctxt->pSizeConstraint) { + pctxt->pSizeConstraint = pSize; + } + + /* Otherwise, check to make sure given constraint is larger than */ + /* the existing constraint.. */ + + else { + lpSize = pSize; + while (lpSize) { + if (pctxt->pSizeConstraint->lower <= lpSize->lower || + pctxt->pSizeConstraint->upper >= lpSize->upper) + { + /* Set the extension flag to the value of the size */ + /* constraint structure that the item falls within.. */ + + /* pctxt->pSizeConstraint->extended = lpSize->extended; */ + + break; + } + lpSize = lpSize->next; + } + + if (!lpSize) + stat = ASN_E_CONSVIO; + } + + return stat; +} + +Asn1SizeCnst* getSizeConstraint (OOCTXT* pctxt, ASN1BOOL extbit) +{ + Asn1SizeCnst* lpSize = pctxt->pSizeConstraint; + + while (lpSize) { + if (lpSize->extended == extbit) + return lpSize; + else + lpSize = lpSize->next; + } + + return NULL; +} + +int checkSizeConstraint(OOCTXT* pctxt, int size) +{ + Asn1SizeCnst* pSize; + ASN1UINT lower, upper; + ASN1BOOL extbit; + int stat; + + /* If size constraint is present and extendable, decode extension */ + /* bit.. */ + + if (isExtendableSize(pctxt->pSizeConstraint)) { + stat = DE_BIT (pctxt, &extbit); + if (stat != ASN_OK) return LOG_ASN1ERR (pctxt, stat); + } + else extbit = 0; + + /* Now use the value of the extension bit to select the proper */ + /* size constraint range specification.. */ + + pSize = getSizeConstraint (pctxt, extbit); + + lower = (pSize) ? pSize->lower : 0; + upper = (pSize) ? pSize->upper : ASN1UINT_MAX; + + if (upper < (ASN1UINT)size) { + return LOG_ASN1ERR (pctxt, ASN_E_CONSVIO); + } + + return ASN_OK; +} + +ASN1UINT getUIntBitCount (ASN1UINT value) +{ + /* Binary search - decision tree (5 tests, rarely 6) */ + return + ((value < 1<<15) ? + ((value < 1<<7) ? + ((value < 1<<3) ? + ((value < 1<<1) ? ((value < 1<<0) ? 0 : 1) : + ((value < 1<<2) ? 2 : 3)) : + ((value < 1<<5) ? ((value < 1<<4) ? 4 : 5) : + ((value < 1<<6) ? 6 : 7))) : + ((value < 1<<11) ? + ((value < 1<<9) ? ((value < 1<<8) ? 8 : 9) : + ((value < 1<<10) ? 10 : 11)) : + ((value < 1<<13) ? ((value < 1<<12) ? 12 : 13) : + ((value < 1<<14) ? 14 : 15)))) : + ((value < 1<<23) ? + ((value < 1<<19) ? + ((value < 1<<17) ? ((value < 1<<16) ? 16 : 17) : + ((value < 1<<18) ? 18 : 19)) : + ((value < 1<<21) ? ((value < 1<<20) ? 20 : 21) : + ((value < 1<<22) ? 22 : 23))) : + ((value < 1<<27) ? + ((value < 1<<25) ? ((value < 1<<24) ? 24 : 25) : + ((value < 1<<26) ? 26 : 27)) : + ((value < 1<<29) ? ((value < 1<<28) ? 28 : 29) : + ((value < 1<<30) ? 30 : + ((value < 1UL<<31) ? 31 : 32)))))); +} + +void init16BitCharSet (Asn116BitCharSet* pCharSet, ASN116BITCHAR first, + ASN116BITCHAR last, ASN1UINT abits, ASN1UINT ubits) +{ + pCharSet->charSet.nchars = 0; + pCharSet->charSet.data = 0; + pCharSet->firstChar = first; + pCharSet->lastChar = last; + pCharSet->unalignedBits = ubits; + pCharSet->alignedBits = abits; +} + +ASN1BOOL isExtendableSize (Asn1SizeCnst* pSizeList) +{ + Asn1SizeCnst* lpSize = pSizeList; + while (lpSize) { + if (lpSize->extended) + return TRUE; + else + lpSize = lpSize->next; + } + return FALSE; +} + +static ASN1BOOL isFixedSize (Asn1SizeCnst* pSizeList) +{ + Asn1SizeCnst* lpSize = pSizeList; + if (lpSize && !lpSize->extended && !lpSize->next) { + return (ASN1BOOL) (lpSize->lower == lpSize->upper); + } + return FALSE; +} + +void set16BitCharSet +(OOCTXT* pctxt, Asn116BitCharSet* pCharSet, Asn116BitCharSet* pAlphabet) +{ + /* Permitted alphabet range can either be specified as a range of */ + /* characters or as a discrete set.. */ + + if (pAlphabet->charSet.data) { + int nocts = pAlphabet->charSet.nchars * 2; + pCharSet->charSet.nchars = pAlphabet->charSet.nchars; + + pCharSet->charSet.data = + (ASN116BITCHAR*) ASN1MALLOC (pctxt, nocts); + + if (pCharSet->charSet.data != NULL) + memcpy (pCharSet->charSet.data, pAlphabet->charSet.data, nocts); + } + else { + pCharSet->firstChar = pAlphabet->firstChar; + pCharSet->lastChar = pAlphabet->lastChar; + pCharSet->charSet.nchars = pCharSet->lastChar - pCharSet->firstChar; + } + + pCharSet->unalignedBits = getUIntBitCount (pCharSet->charSet.nchars); + + pCharSet->alignedBits = 1; + while (pCharSet->unalignedBits > pCharSet->alignedBits) + pCharSet->alignedBits <<= 1; + +} + diff --git a/addons/ooh323c/src/printHandler.c b/addons/ooh323c/src/printHandler.c new file mode 100644 index 000000000..097aac877 --- /dev/null +++ b/addons/ooh323c/src/printHandler.c @@ -0,0 +1,273 @@ +/* + * 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. + * + *****************************************************************************/ +/* This is an implementation of a simple print handler. It outputs + the fields of an encoded PER message to stdout in a structured output + format.. +*/ +#include +#ifdef HAVE_MALLOC_H +#include +#endif +#include "printHandler.h" +#include "ootypes.h" +#include "rtctype.h" +#include "ootrace.h" + +EventHandler printHandler; + +static const char* pVarName; +static int gIndentSpaces; + +static const char* bitStrToString +(ASN1UINT numbits, const ASN1OCTET* data, char* buffer, size_t bufsiz); + +static const char* octStrToString +(ASN1UINT numocts, const ASN1OCTET* data, char* buffer, size_t bufsiz); + +void initializePrintHandler(EventHandler *printHandler, char * varname) +{ + printHandler->startElement = &printStartElement; + printHandler->endElement = &printEndElement; + printHandler->boolValue = &printBoolValue; + printHandler->intValue = &printIntValue; + printHandler->uIntValue = &printuIntValue ; + printHandler->bitStrValue = &printBitStrValue; + printHandler->octStrValue = &printOctStrValue; + printHandler->charStrValue = &printCharStrValue; + printHandler->charStr16BitValue = &printCharStr16BitValue ; + printHandler->nullValue = &printNullValue; + printHandler->oidValue = &printOidValue; + printHandler->enumValue = &printEnumValue; + printHandler->openTypeValue = &printOpenTypeValue; + pVarName = varname; + OOTRACEDBGB2("%s = {\n", pVarName); + gIndentSpaces += 3; + +} + +void finishPrint() +{ + OOTRACEDBGB1 ("}\n"); + gIndentSpaces -= 3; + if (gIndentSpaces != 0) { + OOTRACEDBGB1 ("ERROR: unbalanced structure\n"); + } +} + +void indent () +{ + int i=0; + for (i = 0; i < gIndentSpaces; i++) OOTRACEDBGB1 (" "); +} + +void printStartElement (const char* name, int index) +{ + indent (); + OOTRACEDBGB1 (name); + if (index >= 0) OOTRACEDBGB2 ("[%d]", index); + OOTRACEDBGB1 (" = {\n"); + gIndentSpaces += 3; +} + +void printEndElement (const char* name, int index) +{ + gIndentSpaces -= 3; + indent (); + OOTRACEDBGB1 ("}\n"); +} + +void printBoolValue (ASN1BOOL value) +{ + const char* s = value ? "TRUE" : "FALSE"; + indent (); + OOTRACEDBGB2 ("%s\n", s); +} + +void printIntValue (ASN1INT value) +{ + indent (); + OOTRACEDBGB2 ("%d\n", value); +} + +void printuIntValue (ASN1UINT value) +{ + indent (); + OOTRACEDBGB2 ("%u\n", value); +} + +void printBitStrValue (ASN1UINT numbits, const ASN1OCTET* data) +{ +#ifdef __MINGW32__ + char s[numbits + 8]; + indent (); + OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8)); +#else + char* s = (char*)malloc(numbits + 8); + indent (); + OOTRACEDBGB2("%s\n", bitStrToString (numbits, data, s, numbits+8)); + free(s); +#endif +} + +void printOctStrValue (ASN1UINT numocts, const ASN1OCTET* data) +{ + int bufsiz = (numocts * 2) + 8; +#ifdef __MINGW32__ + char s[bufsiz]; + indent (); + OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz)); +#else + char* s = (char*)malloc(bufsiz); + indent (); + OOTRACEDBGB2 ("%s\n", octStrToString (numocts, data, s, bufsiz)); + free(s); +#endif +} + +void printCharStrValue (const char* value) +{ + indent (); + OOTRACEDBGB2 ("\"%s\"\n", value); +} + +void printCharStr16BitValue (ASN1UINT nchars, ASN116BITCHAR* data) +{ + ASN1UINT ui; + indent (); + + for (ui = 0; ui < nchars; ui++) { + if (data[ui] >= 32 && data[ui] <= 127) + OOTRACEDBGB2 ("%c", (char)data[ui]); + else + OOTRACEDBGB1 ("?"); + } + + OOTRACEDBGB1 ("\n"); +} + +void printCharStr32BitValue (ASN1UINT nchars, ASN132BITCHAR* data) +{ + ASN1UINT ui; + indent (); + + for ( ui = 0; ui < nchars; ui++) { + if (data[ui] >= 32 && data[ui] <= 127) + OOTRACEDBGB2 ("%c", (char)data[ui]); + else + OOTRACEDBGB2 ("\\%d", data[ui]); + } + + OOTRACEDBGB1 ("\n"); +} + +void printNullValue () +{ + indent (); + OOTRACEDBGB1 ("NULL\n"); +} + +void ooPrintOIDValue (ASN1OBJID* pOID) +{ + ASN1UINT ui; + OOTRACEDBGB1 ("{ \n"); + for (ui = 0; ui < pOID->numids; ui++) { + OOTRACEDBGB2 ("%d ", pOID->subid[ui]); + } + OOTRACEDBGB1 ("}\n"); +} + +void printOidValue (ASN1UINT numSubIds, ASN1UINT* pSubIds) +{ + ASN1UINT ui; + ASN1OBJID oid; + oid.numids = numSubIds; + + for ( ui = 0; ui < numSubIds; ui++) + oid.subid[ui] = pSubIds[ui]; + + indent (); + ooPrintOIDValue (&oid); +} + +void printRealValue (double value) +{ + indent (); + OOTRACEDBGB2 ("%f\n", value); +} + +void printEnumValue (ASN1UINT value) +{ + indent (); + OOTRACEDBGB2 ("%u\n", value); +} + +void printOpenTypeValue (ASN1UINT numocts, const ASN1OCTET* data) +{ + indent (); + OOTRACEDBGB1 ("< encoded data >\n"); +} + +static const char* bitStrToString +(ASN1UINT numbits, const ASN1OCTET* data, char* buffer, size_t bufsiz) +{ + size_t i; + unsigned char mask = 0x80; + + if (bufsiz > 0) { + buffer[0] = '\''; + for (i = 0; i < numbits; i++) { + if (i < bufsiz - 1) { + buffer[i+1] = (char) (((data[i/8] & mask) != 0) ? '1' : '0'); + mask >>= 1; + if (0 == mask) mask = 0x80; + } + else break; + } + i++; + if (i < bufsiz - 1) buffer[i++] = '\''; + if (i < bufsiz - 1) buffer[i++] = 'B'; + if (i < bufsiz - 1) buffer[i] = '\0'; + else buffer[bufsiz - 1] = '\0'; + } + + return buffer; +} + +static const char* octStrToString +(ASN1UINT numocts, const ASN1OCTET* data, char* buffer, size_t bufsiz) +{ + size_t i; + char lbuf[4]; + + if (bufsiz > 0) { + buffer[0] = '\''; + if (bufsiz > 1) buffer[1] = '\0'; + for (i = 0; i < numocts; i++) { + if (i < bufsiz - 1) { + sprintf (lbuf, "%02x", data[i]); + strcat (&buffer[(i*2)+1], lbuf); + } + else break; + } + i = i*2 + 1; + if (i < bufsiz - 1) buffer[i++] = '\''; + if (i < bufsiz - 1) buffer[i++] = 'H'; + if (i < bufsiz - 1) buffer[i] = '\0'; + else buffer[bufsiz - 1] = '\0'; + } + + return buffer; +} diff --git a/addons/ooh323c/src/printHandler.h b/addons/ooh323c/src/printHandler.h new file mode 100644 index 000000000..30d87295d --- /dev/null +++ b/addons/ooh323c/src/printHandler.h @@ -0,0 +1,47 @@ +/* + * 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. + * + *****************************************************************************/ +/** + @file printHandler.h + This is an implementation of a simple print handler. It outputs + the fields of an encoded PER message to stdout in a structured output + format.. +*/ + +#ifndef _PRINTHANDLER_H_ +#define _PRINTHANDLER_H_ + +#include "eventHandler.h" + +extern EventHandler printHandler; + +void initializePrintHandler(EventHandler *printHandler, char * varname); +void finishPrint(); +void indent (); +void printStartElement (const char* name, int index ); +void printEndElement (const char* name, int index ); +void printBoolValue (ASN1BOOL value); +void printIntValue (ASN1INT value); +void printuIntValue (ASN1UINT value); +void printBitStrValue (ASN1UINT numbits, const ASN1OCTET* data); +void printOctStrValue (ASN1UINT numocts, const ASN1OCTET* data); +void printCharStrValue (const char* value); +void printCharStr16BitValue (ASN1UINT nchars, ASN116BITCHAR* data); +void printNullValue (); +void printOidValue (ASN1UINT numSubIds, ASN1UINT* pSubIds); +void printEnumValue (ASN1UINT value); +void printOpenTypeValue (ASN1UINT numocts, const ASN1OCTET* data); + +#endif diff --git a/addons/ooh323c/src/rtctype.c b/addons/ooh323c/src/rtctype.c new file mode 100644 index 000000000..4ea7977f3 --- /dev/null +++ b/addons/ooh323c/src/rtctype.c @@ -0,0 +1,168 @@ +/* + * Copyright (C) 1997-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. + * + *****************************************************************************/ + +/* Run-time ctype substitution */ + +#include "ooasn1.h" +#include "rtctype.h" + +const ASN1OCTET rtCtypeTable[256] = { + OS_CTYPE_CTRL, /* 00 (NUL) */ + OS_CTYPE_CTRL, /* 01 (SOH) */ + OS_CTYPE_CTRL, /* 02 (STX) */ + OS_CTYPE_CTRL, /* 03 (ETX) */ + OS_CTYPE_CTRL, /* 04 (EOT) */ + OS_CTYPE_CTRL, /* 05 (ENQ) */ + OS_CTYPE_CTRL, /* 06 (ACK) */ + OS_CTYPE_CTRL, /* 07 (BEL) */ + OS_CTYPE_CTRL, /* 08 (BS) */ + OS_CTYPE_CTRL|OS_CTYPE_SPACE, /* 09 (HT) */ + OS_CTYPE_CTRL|OS_CTYPE_SPACE, /* 0A (LF) */ + OS_CTYPE_CTRL|OS_CTYPE_SPACE, /* 0B (VT) */ + OS_CTYPE_CTRL|OS_CTYPE_SPACE, /* 0C (FF) */ + OS_CTYPE_CTRL|OS_CTYPE_SPACE, /* 0D (CR) */ + OS_CTYPE_CTRL, /* 0E (SI) */ + OS_CTYPE_CTRL, /* 0F (SO) */ + OS_CTYPE_CTRL, /* 10 (DLE) */ + OS_CTYPE_CTRL, /* 11 (DC1) */ + OS_CTYPE_CTRL, /* 12 (DC2) */ + OS_CTYPE_CTRL, /* 13 (DC3) */ + OS_CTYPE_CTRL, /* 14 (DC4) */ + OS_CTYPE_CTRL, /* 15 (NAK) */ + OS_CTYPE_CTRL, /* 16 (SYN) */ + OS_CTYPE_CTRL, /* 17 (ETB) */ + OS_CTYPE_CTRL, /* 18 (CAN) */ + OS_CTYPE_CTRL, /* 19 (EM) */ + OS_CTYPE_CTRL, /* 1A (SUB) */ + OS_CTYPE_CTRL, /* 1B (ESC) */ + OS_CTYPE_CTRL, /* 1C (FS) */ + OS_CTYPE_CTRL, /* 1D (GS) */ + OS_CTYPE_CTRL, /* 1E (RS) */ + OS_CTYPE_CTRL, /* 1F (US) */ + OS_CTYPE_SPACE|OS_CTYPE_BLANK, /* 20 SPACE */ + OS_CTYPE_PUNCT, /* 21 ! */ + OS_CTYPE_PUNCT, /* 22 " */ + OS_CTYPE_PUNCT, /* 23 # */ + OS_CTYPE_PUNCT, /* 24 $ */ + OS_CTYPE_PUNCT, /* 25 % */ + OS_CTYPE_PUNCT, /* 26 & */ + OS_CTYPE_PUNCT, /* 27 ' */ + OS_CTYPE_PUNCT, /* 28 ( */ + OS_CTYPE_PUNCT, /* 29 ) */ + OS_CTYPE_PUNCT, /* 2A * */ + OS_CTYPE_PUNCT, /* 2B + */ + OS_CTYPE_PUNCT, /* 2C , */ + OS_CTYPE_PUNCT, /* 2D - */ + OS_CTYPE_PUNCT, /* 2E . */ + OS_CTYPE_PUNCT, /* 2F / */ + OS_CTYPE_NUMBER, /* 30 0 */ + OS_CTYPE_NUMBER, /* 31 1 */ + OS_CTYPE_NUMBER, /* 32 2 */ + OS_CTYPE_NUMBER, /* 33 3 */ + OS_CTYPE_NUMBER, /* 34 4 */ + OS_CTYPE_NUMBER, /* 35 5 */ + OS_CTYPE_NUMBER, /* 36 6 */ + OS_CTYPE_NUMBER, /* 37 7 */ + OS_CTYPE_NUMBER, /* 38 8 */ + OS_CTYPE_NUMBER, /* 39 9 */ + OS_CTYPE_PUNCT, /* 3A : */ + OS_CTYPE_PUNCT, /* 3B ; */ + OS_CTYPE_PUNCT, /* 3C < */ + OS_CTYPE_PUNCT, /* 3D = */ + OS_CTYPE_PUNCT, /* 3E > */ + OS_CTYPE_PUNCT, /* 3F ? */ + OS_CTYPE_PUNCT, /* 40 @ */ + OS_CTYPE_UPPER|OS_CTYPE_HEX, /* 41 A */ + OS_CTYPE_UPPER|OS_CTYPE_HEX, /* 42 B */ + OS_CTYPE_UPPER|OS_CTYPE_HEX, /* 43 C */ + OS_CTYPE_UPPER|OS_CTYPE_HEX, /* 44 D */ + OS_CTYPE_UPPER|OS_CTYPE_HEX, /* 45 E */ + OS_CTYPE_UPPER|OS_CTYPE_HEX, /* 46 F */ + OS_CTYPE_UPPER, /* 47 G */ + OS_CTYPE_UPPER, /* 48 H */ + OS_CTYPE_UPPER, /* 49 I */ + OS_CTYPE_UPPER, /* 4A J */ + OS_CTYPE_UPPER, /* 4B K */ + OS_CTYPE_UPPER, /* 4C L */ + OS_CTYPE_UPPER, /* 4D M */ + OS_CTYPE_UPPER, /* 4E N */ + OS_CTYPE_UPPER, /* 4F O */ + OS_CTYPE_UPPER, /* 50 P */ + OS_CTYPE_UPPER, /* 51 Q */ + OS_CTYPE_UPPER, /* 52 R */ + OS_CTYPE_UPPER, /* 53 S */ + OS_CTYPE_UPPER, /* 54 T */ + OS_CTYPE_UPPER, /* 55 U */ + OS_CTYPE_UPPER, /* 56 V */ + OS_CTYPE_UPPER, /* 57 W */ + OS_CTYPE_UPPER, /* 58 X */ + OS_CTYPE_UPPER, /* 59 Y */ + OS_CTYPE_UPPER, /* 5A Z */ + OS_CTYPE_PUNCT, /* 5B [ */ + OS_CTYPE_PUNCT, /* 5C \ */ + OS_CTYPE_PUNCT, /* 5D ] */ + OS_CTYPE_PUNCT, /* 5E ^ */ + OS_CTYPE_PUNCT, /* 5F _ */ + OS_CTYPE_PUNCT, /* 60 ` */ + OS_CTYPE_LOWER|OS_CTYPE_HEX, /* 61 a */ + OS_CTYPE_LOWER|OS_CTYPE_HEX, /* 62 b */ + OS_CTYPE_LOWER|OS_CTYPE_HEX, /* 63 c */ + OS_CTYPE_LOWER|OS_CTYPE_HEX, /* 64 d */ + OS_CTYPE_LOWER|OS_CTYPE_HEX, /* 65 e */ + OS_CTYPE_LOWER|OS_CTYPE_HEX, /* 66 f */ + OS_CTYPE_LOWER, /* 67 g */ + OS_CTYPE_LOWER, /* 68 h */ + OS_CTYPE_LOWER, /* 69 i */ + OS_CTYPE_LOWER, /* 6A j */ + OS_CTYPE_LOWER, /* 6B k */ + OS_CTYPE_LOWER, /* 6C l */ + OS_CTYPE_LOWER, /* 6D m */ + OS_CTYPE_LOWER, /* 6E n */ + OS_CTYPE_LOWER, /* 6F o */ + OS_CTYPE_LOWER, /* 70 p */ + OS_CTYPE_LOWER, /* 71 q */ + OS_CTYPE_LOWER, /* 72 r */ + OS_CTYPE_LOWER, /* 73 s */ + OS_CTYPE_LOWER, /* 74 t */ + OS_CTYPE_LOWER, /* 75 u */ + OS_CTYPE_LOWER, /* 76 v */ + OS_CTYPE_LOWER, /* 77 w */ + OS_CTYPE_LOWER, /* 78 x */ + OS_CTYPE_LOWER, /* 79 y */ + OS_CTYPE_LOWER, /* 7A z */ + OS_CTYPE_PUNCT, /* 7B { */ + OS_CTYPE_PUNCT, /* 7C | */ + OS_CTYPE_PUNCT, /* 7D } */ + OS_CTYPE_PUNCT, /* 7E ~ */ + OS_CTYPE_CTRL, /* 7F (DEL) */ + + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0 +}; diff --git a/addons/ooh323c/src/rtctype.h b/addons/ooh323c/src/rtctype.h new file mode 100644 index 000000000..ebb0a59b4 --- /dev/null +++ b/addons/ooh323c/src/rtctype.h @@ -0,0 +1,86 @@ +/* + * Copyright (C) 1997-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. + * + *****************************************************************************/ + +/** + * @file rtctype.h + */ +#ifndef _RTCTYPE_H_ +#define _RTCTYPE_H_ + +#include "ooasn1.h" + +/* Ctype module constants */ + +#define OS_CTYPE_UPPER 0x1 +#define OS_CTYPE_LOWER 0x2 +#define OS_CTYPE_NUMBER 0x4 +#define OS_CTYPE_SPACE 0x8 +#define OS_CTYPE_PUNCT 0x10 +#define OS_CTYPE_CTRL 0x20 +#define OS_CTYPE_HEX 0x40 +#define OS_CTYPE_BLANK 0x80 + +/* Ctype substitution macros */ + +#define OS_ISALPHA(c) \ +(rtCtypeTable[(unsigned)(c)]&(OS_CTYPE_UPPER|OS_CTYPE_LOWER)) +#define OS_ISUPPER(c) \ +(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_UPPER) +#define OS_ISLOWER(c) \ +(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_LOWER) +#define OS_ISDIGIT(c) \ +(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_NUMBER) +#define OS_ISXDIGIT(c) \ +(rtCtypeTable[(unsigned)(c)]&(OS_CTYPE_HEX|OS_CTYPE_NUMBER)) +#define OS_ISSPACE(c) \ +(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_SPACE) +#define OS_ISPUNCT(c) \ +(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_PUNCT) +#define OS_ISALNUM(c) \ +(rtCtypeTable[(unsigned)(c)]&(OS_CTYPE_UPPER|OS_CTYPE_LOWER|OS_CTYPE_NUMBER)) +#define OS_ISPRINT(c) \ +(rtCtypeTable[(unsigned)(c)]& \ +(OS_CTYPE_PUNCT|OS_CTYPE_UPPER|OS_CTYPE_LOWER|OS_CTYPE_NUMBER|OS_CTYPE_BLANK)) +#define OS_ISGRAPH(c) \ +(rtCtypeTable[(unsigned)(c)]& \ +(OS_CTYPE_PUNCT|OS_CTYPE_UPPER|OS_CTYPE_LOWER|OS_CTYPE_NUMBER)) +#define OS_ISCNTRL(c) \ +(rtCtypeTable[(unsigned)(c)]&OS_CTYPE_CTRL) + +#define OS_TOLOWER(c) (OS_ISUPPER(c) ? (c) - 'A' + 'a' : (c)) +#define OS_TOUPPER(c) (OS_ISLOWER(c) ? (c) - 'a' + 'A' : (c)) + +#ifdef __cplusplus +extern "C" { +#endif + +#ifndef EXTERN +#ifdef MAKE_DLL +#define EXTERN __declspec(dllexport) +#else +#define EXTERN +#endif /* MAKE_DLL */ +#endif /* EXTERN */ +/* ctype module table */ + +extern EXTERN const ASN1OCTET rtCtypeTable[256]; + +#ifdef __cplusplus +} +#endif + +#endif /* _RTCTYPE_H_ */ + diff --git a/addons/ooh323cDriver.c b/addons/ooh323cDriver.c new file mode 100644 index 000000000..5d7396abf --- /dev/null +++ b/addons/ooh323cDriver.c @@ -0,0 +1,361 @@ +/* + * 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 "ooh323cDriver.h" + +#include +#include +#include + +extern OOBOOL gH323Debug; +/* ooh323c stack thread. */ +static pthread_t ooh323c_thread = AST_PTHREADT_NULL; +static int grxframes = 240; + +static int gtxframes = 20; + +int ooh323c_start_receive_channel(ooCallData *call, ooLogicalChannel *pChannel); +int ooh323c_start_transmit_channel(ooCallData *call, ooLogicalChannel *pChannel); +int ooh323c_stop_receive_channel(ooCallData *call, ooLogicalChannel *pChannel); +int ooh323c_stop_transmit_channel(ooCallData *call, ooLogicalChannel *pChannel); + +void* ooh323c_stack_thread(void* dummy) +{ + + ooMonitorChannels(); + return dummy; +} + +int ooh323c_start_stack_thread() +{ + if(ast_pthread_create(&ooh323c_thread, NULL, ooh323c_stack_thread, NULL) < 0) + { + ast_log(LOG_ERROR, "Unable to start ooh323c thread.\n"); + return -1; + } + return 0; +} + +int ooh323c_stop_stack_thread(void) +{ + if(ooh323c_thread != AST_PTHREADT_NULL) + { + ooStopMonitor(); + pthread_join(ooh323c_thread, NULL); + ooh323c_thread = AST_PTHREADT_NULL; + } + return 0; +} + +int ooh323c_set_capability + (struct ast_codec_pref *prefs, int capability, int dtmf) +{ + int ret, x, format=0; + if(gH323Debug) + ast_verbose("\tAdding capabilities to H323 endpoint\n"); + + for(x=0; 0 != (format=ast_codec_pref_index(prefs, x)); x++) + { + if(format & AST_FORMAT_ULAW) + { + if(gH323Debug) + ast_verbose("\tAdding g711 ulaw capability to H323 endpoint\n"); + ret= ooH323EpAddG711Capability(OO_G711ULAW64K, gtxframes, grxframes, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + } + if(format & AST_FORMAT_ALAW) + { + if(gH323Debug) + ast_verbose("\tAdding g711 alaw capability to H323 endpoint\n"); + ret= ooH323EpAddG711Capability(OO_G711ALAW64K, gtxframes, grxframes, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + } + + if(format & AST_FORMAT_G729A) + { + if(gH323Debug) + ast_verbose("\tAdding g729A capability to H323 endpoint\n"); + ret = ooH323EpAddG729Capability(OO_G729A, 2, 24, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + + if(gH323Debug) + ast_verbose("\tAdding g729 capability to H323 endpoint\n"); + ret |= ooH323EpAddG729Capability(OO_G729, 2, 24, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + } + + if(format & AST_FORMAT_G723_1) + { + if(gH323Debug) + ast_verbose("\tAdding g7231 capability to H323 endpoint\n"); + ret = ooH323EpAddG7231Capability(OO_G7231, 4, 7, FALSE, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + + } + + if(format & AST_FORMAT_H263) + { + if(gH323Debug) + ast_verbose("\tAdding h263 capability to H323 endpoint\n"); + ret = ooH323EpAddH263VideoCapability(OO_H263VIDEO, 1, 0, 0, 0, 0, 320*1024, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + + } + + if(format & AST_FORMAT_GSM) + { + if(gH323Debug) + ast_verbose("\tAdding gsm capability to H323 endpoint\n"); + ret = ooH323EpAddGSMCapability(OO_GSMFULLRATE, 4, FALSE, FALSE, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + + } + + } + + if(dtmf & H323_DTMF_RFC2833) + ret |= ooH323EpEnableDTMFRFC2833(0); + else if(dtmf & H323_DTMF_H245ALPHANUMERIC) + ret |= ooH323EpEnableDTMFH245Alphanumeric(); + else if(dtmf & H323_DTMF_H245SIGNAL) + ret |= ooH323EpEnableDTMFH245Signal(); + + return ret; +} + +int ooh323c_set_capability_for_call + (ooCallData *call, struct ast_codec_pref *prefs, int capability, int dtmf) +{ + int ret, x, txframes; + int format=0; + if(gH323Debug) + ast_verbose("\tAdding capabilities to call(%s, %s)\n", call->callType, + call->callToken); + if(dtmf & H323_DTMF_RFC2833) + ret |= ooCallEnableDTMFRFC2833(call,0); + else if(dtmf & H323_DTMF_H245ALPHANUMERIC) + ret |= ooCallEnableDTMFH245Alphanumeric(call); + else if(dtmf & H323_DTMF_H245SIGNAL) + ret |= ooCallEnableDTMFH245Signal(call); + + + for(x=0; 0 !=(format=ast_codec_pref_index(prefs, x)); x++) + { + if(format & AST_FORMAT_ULAW) + { + if(gH323Debug) + ast_verbose("\tAdding g711 ulaw capability to call(%s, %s)\n", + call->callType, call->callToken); + txframes = prefs->framing[x]; + ret= ooCallAddG711Capability(call, OO_G711ULAW64K, txframes, + grxframes, OORXANDTX, + &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + } + if(format & AST_FORMAT_ALAW) + { + if(gH323Debug) + ast_verbose("\tAdding g711 alaw capability to call(%s, %s)\n", + call->callType, call->callToken); + txframes = prefs->framing[x]; + ret= ooCallAddG711Capability(call, OO_G711ALAW64K, txframes, + grxframes, OORXANDTX, + &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + } + + if(format & AST_FORMAT_G729A) + { + if(gH323Debug) + ast_verbose("\tAdding g729A capability to call(%s, %s)\n", + call->callType, call->callToken); + txframes = (prefs->framing[x])/10; + ret= ooCallAddG729Capability(call, OO_G729A, txframes, 24, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + + if(gH323Debug) + ast_verbose("\tAdding g729 capability to call(%s, %s)\n", + call->callType, call->callToken); + ret|= ooCallAddG729Capability(call, OO_G729, txframes, 24, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + } + + if(format & AST_FORMAT_G723_1) + { + if(gH323Debug) + ast_verbose("\tAdding g7231 capability to call (%s, %s)\n", + call->callType, call->callToken); + ret = ooCallAddG7231Capability(call, OO_G7231, 4, 7, FALSE, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + + } + + if(format & AST_FORMAT_H263) + { + if(gH323Debug) + ast_verbose("\tAdding h263 capability to call (%s, %s)\n", + call->callType, call->callToken); + ret = ooCallAddH263VideoCapability(call, OO_H263VIDEO, 1, 0, 0, 0, 0, 320*1024, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + + } + + if(format & AST_FORMAT_GSM) + { + if(gH323Debug) + ast_verbose("\tAdding gsm capability to call(%s, %s)\n", + call->callType, call->callToken); + ret = ooCallAddGSMCapability(call, OO_GSMFULLRATE, 4, FALSE, FALSE, + OORXANDTX, &ooh323c_start_receive_channel, + &ooh323c_start_transmit_channel, + &ooh323c_stop_receive_channel, + &ooh323c_stop_transmit_channel); + } + } +} + +int ooh323c_set_aliases(ooAliases * aliases) +{ + ooAliases *cur = aliases; + while(cur) + { + switch(cur->type) + { + case T_H225AliasAddress_dialedDigits: + ooH323EpAddAliasDialedDigits(cur->value); + break; + case T_H225AliasAddress_h323_ID: + ooH323EpAddAliasH323ID(cur->value); + break; + case T_H225AliasAddress_url_ID: + ooH323EpAddAliasURLID(cur->value); + break; + case T_H225AliasAddress_email_ID: + ooH323EpAddAliasEmailID(cur->value); + break; + default: + ast_debug(1, "Ignoring unknown alias type\n"); + } + cur = cur->next; + } + return 1; +} + +int ooh323c_start_receive_channel(ooCallData *call, ooLogicalChannel *pChannel) +{ + int fmt=-1; + fmt = convertH323CapToAsteriskCap(pChannel->chanCap->cap); + if(fmt>0) + ooh323_set_read_format(call, fmt); + else{ + ast_log(LOG_ERROR, "Invalid capability type for receive channel %s\n", + call->callToken); + return -1; + } + return 1; +} + +int ooh323c_start_transmit_channel(ooCallData *call, ooLogicalChannel *pChannel) +{ + int fmt=-1; + fmt = convertH323CapToAsteriskCap(pChannel->chanCap->cap); + if(fmt>0) + ooh323_set_write_format(call, fmt); + else{ + ast_log(LOG_ERROR, "Invalid capability type for receive channel %s\n", + call->callToken); + return -1; + } + setup_rtp_connection(call, pChannel->remoteIP, pChannel->remoteMediaPort); + return 1; +} + +int ooh323c_stop_receive_channel(ooCallData *call, ooLogicalChannel *pChannel) +{ + return 1; +} + +int ooh323c_stop_transmit_channel(ooCallData *call, ooLogicalChannel *pChannel) +{ + close_rtp_connection(call); + return 1; +} + +int convertH323CapToAsteriskCap(int cap) +{ + + switch(cap) + { + case OO_G711ULAW64K: + return AST_FORMAT_ULAW; + case OO_G711ALAW64K: + return AST_FORMAT_ALAW; + case OO_GSMFULLRATE: + return AST_FORMAT_GSM; + case OO_G729: + return AST_FORMAT_G729A; + case OO_G729A: + return AST_FORMAT_G729A; + case OO_G7231: + return AST_FORMAT_G723_1; + case OO_H263VIDEO: + return AST_FORMAT_H263; + default: + ast_debug(1, "Cap %d is not supported by driver yet\n", cap); + return -1; + } + + return -1; +} + + diff --git a/addons/ooh323cDriver.h b/addons/ooh323cDriver.h new file mode 100644 index 000000000..ebd965131 --- /dev/null +++ b/addons/ooh323cDriver.h @@ -0,0 +1,39 @@ +/* + * 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. + * + *****************************************************************************/ +#ifndef _OO_H323CDRIVER_H_ +#define __OO_H323DRIVER_H_ +#include "chan_ooh323.h" +#include "ootypes.h" +#include "ooh323ep.h" +#include "oochannels.h" +#include "ooCalls.h" +#include "ooCapability.h" +#include "ooStackCmds.h" +#define H323_DTMF_RFC2833 (1 << 0) +#define H323_DTMF_Q931 (1 << 1) +#define H323_DTMF_H245ALPHANUMERIC (1 << 2) +#define H323_DTMF_H245SIGNAL (1 << 3) +#define H323_DTMF_INBAND (1 << 4) + +struct h323_pvt; +int ooh323c_start_stack_thread(void); +int ooh323c_stop_stack_thread(void); +int ooh323c_set_capability + (struct ast_codec_pref *prefs, int capability, int dtmf); +int convertH323CapToAsteriskCap(int cap); +int ooh323c_set_capability_for_call + (ooCallData *call, struct ast_codec_pref *prefs, int capability, int dtmf); +#endif diff --git a/addons/res_config_mysql.c b/addons/res_config_mysql.c new file mode 100644 index 000000000..2cd1fa4f4 --- /dev/null +++ b/addons/res_config_mysql.c @@ -0,0 +1,1752 @@ +/* + * Asterisk -- An open source telephony toolkit. + * + * Copyright (C) 1999-2005, Digium, Inc. + * + * Mark Spencer - Asterisk Author + * Matthew Boehm - MySQL RealTime Driver Author + * + * See http://www.asterisk.org for more information about + * the Asterisk project. Please do not directly contact + * any of the maintainers of this project for assistance; + * the project provides a web site, mailing lists and IRC + * channels for your use. + * + * This program is free software, distributed under the terms of + * the GNU General Public License Version 2. See the LICENSE file + * at the top of the source tree. + */ + +/*! + * \file + * \brief MySQL CDR backend + */ + +/*** MODULEINFO + mysqlclient + no + ***/ + +#include "asterisk.h" + +ASTERISK_FILE_VERSION(__FILE__, "$Revision$") + +#include + +#include +#include +#include + +#include "asterisk/channel.h" +#include "asterisk/logger.h" +#include "asterisk/config.h" +#include "asterisk/module.h" +#include "asterisk/lock.h" +#include "asterisk/options.h" +#include "asterisk/cli.h" +#include "asterisk/utils.h" +#include "asterisk/threadstorage.h" + +#define RES_CONFIG_MYSQL_CONF "res_mysql.conf" +#define READHANDLE 0 +#define WRITEHANDLE 1 + +#define ESCAPE_STRING(buf, var) \ + do { \ + if ((valsz = strlen(var)) * 2 + 1 > ast_str_size(buf)) { \ + ast_str_make_space(&(buf), valsz * 2 + 1); \ + } \ + mysql_real_escape_string(&dbh->handle, ast_str_buffer(buf), var, valsz); \ + } while (0) + +AST_THREADSTORAGE(sql_buf); +AST_THREADSTORAGE(sql2_buf); +AST_THREADSTORAGE(find_buf); +AST_THREADSTORAGE(scratch_buf); +AST_THREADSTORAGE(modify_buf); +AST_THREADSTORAGE(modify2_buf); +AST_THREADSTORAGE(modify3_buf); + +enum requirements { RQ_WARN, RQ_CREATECLOSE, RQ_CREATECHAR }; + +struct mysql_conn { + AST_RWLIST_ENTRY(mysql_conn) list; + ast_mutex_t lock; + MYSQL handle; + char host[50]; + char name[50]; + char user[50]; + char pass[50]; + char sock[50]; + int port; + int connected; + time_t connect_time; + enum requirements requirements; + char unique_name[0]; +}; + +struct columns { + char *name; + char *type; + char *dflt; + char null; + int len; + AST_LIST_ENTRY(columns) list; +}; + +struct tables { + ast_mutex_t lock; + AST_LIST_HEAD_NOLOCK(mysql_columns, columns) columns; + AST_LIST_ENTRY(tables) list; + struct mysql_conn *database; + char name[0]; +}; + +static AST_LIST_HEAD_STATIC(mysql_tables, tables); +static AST_RWLIST_HEAD_STATIC(databases, mysql_conn); + +static int parse_config(int reload); +static int mysql_reconnect(struct mysql_conn *conn); +static char *handle_cli_realtime_mysql_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a); +static char *handle_cli_realtime_mysql_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a); +static int load_mysql_config(struct ast_config *config, const char *category, struct mysql_conn *conn); +static int require_mysql(const char *database, const char *tablename, va_list ap); +static int internal_require(const char *database, const char *table, ...) attribute_sentinel; + +static struct ast_cli_entry cli_realtime_mysql_status[] = { + AST_CLI_DEFINE(handle_cli_realtime_mysql_status, "Shows connection information for the MySQL RealTime driver"), + AST_CLI_DEFINE(handle_cli_realtime_mysql_cache, "Shows cached tables within the MySQL realtime driver"), +}; + +static struct mysql_conn *find_database(const char *database, int for_write) +{ + char *whichdb; + const char *ptr; + struct mysql_conn *cur; + + if ((ptr = strchr(database, '/'))) { + /* Multiple databases encoded within string */ + if (for_write) { + whichdb = ast_strdupa(ptr + 1); + } else { + whichdb = alloca(ptr - database + 1); + strncpy(whichdb, database, ptr - database); + whichdb[ptr - database] = '\0'; + } + } else { + whichdb = ast_strdupa(database); + } + + AST_RWLIST_RDLOCK(&databases); + AST_RWLIST_TRAVERSE(&databases, cur, list) { + if (!strcmp(cur->unique_name, whichdb)) { + ast_mutex_lock(&cur->lock); + break; + } + } + AST_RWLIST_UNLOCK(&databases); + return cur; +} + +#define release_database(a) ast_mutex_unlock(&(a)->lock) + +static int internal_require(const char *database, const char *table, ...) +{ + va_list ap; + int res; + va_start(ap, table); + res = require_mysql(database, table, ap); + va_end(ap); + return res; +} + +static void destroy_table(struct tables *table) +{ + struct columns *column; + ast_mutex_lock(&table->lock); + while ((column = AST_LIST_REMOVE_HEAD(&table->columns, list))) { + ast_free(column); + } + ast_mutex_unlock(&table->lock); + ast_mutex_destroy(&table->lock); + ast_free(table); +} + +static struct tables *find_table(const char *database, const char *tablename) +{ + struct columns *column; + struct tables *table; + struct ast_str *sql = ast_str_thread_get(&find_buf, 30); + char *fname, *ftype, *flen, *fdflt, *fnull; + struct mysql_conn *dbh; + MYSQL_RES *result; + MYSQL_ROW row; + + if (!(dbh = find_database(database, 1))) { + return NULL; + } + + AST_LIST_LOCK(&mysql_tables); + AST_LIST_TRAVERSE(&mysql_tables, table, list) { + if (!strcasecmp(table->name, tablename)) { + ast_mutex_lock(&table->lock); + AST_LIST_UNLOCK(&mysql_tables); + release_database(dbh); + return table; + } + } + + /* Not found, scan the table */ + ast_str_set(&sql, 0, "DESC %s", tablename); + + if (!mysql_reconnect(dbh)) { + release_database(dbh); + AST_LIST_UNLOCK(&mysql_tables); + return NULL; + } + + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_ERROR, "Failed to query database columns: %s\n", mysql_error(&dbh->handle)); + release_database(dbh); + AST_LIST_UNLOCK(&mysql_tables); + return NULL; + } + + if (!(table = ast_calloc(1, sizeof(*table) + strlen(tablename) + 1))) { + ast_log(LOG_ERROR, "Unable to allocate memory for new table structure\n"); + release_database(dbh); + AST_LIST_UNLOCK(&mysql_tables); + return NULL; + } + strcpy(table->name, tablename); /* SAFE */ + table->database = dbh; + ast_mutex_init(&table->lock); + AST_LIST_HEAD_INIT_NOLOCK(&table->columns); + + if ((result = mysql_store_result(&dbh->handle))) { + while ((row = mysql_fetch_row(result))) { + fname = row[0]; + ftype = row[1]; + fnull = row[2]; + fdflt = row[4]; + ast_verb(4, "Found column '%s' of type '%s'\n", fname, ftype); + + if (fdflt == NULL) { + fdflt = ""; + } + + if (!(column = ast_calloc(1, sizeof(*column) + strlen(fname) + strlen(ftype) + strlen(fdflt) + 3))) { + ast_log(LOG_ERROR, "Unable to allocate column element for %s, %s\n", tablename, fname); + destroy_table(table); + release_database(dbh); + AST_LIST_UNLOCK(&mysql_tables); + return NULL; + } + + if ((flen = strchr(ftype, '('))) { + sscanf(flen, "(%d)", &column->len); + } else { + /* Columns like dates, times, and timestamps don't have a length */ + column->len = -1; + } + + column->name = (char *)column + sizeof(*column); + column->type = (char *)column + sizeof(*column) + strlen(fname) + 1; + column->dflt = (char *)column + sizeof(*column) + strlen(fname) + 1 + strlen(ftype) + 1; + strcpy(column->name, fname); + strcpy(column->type, ftype); + strcpy(column->dflt, fdflt); + column->null = (strcmp(fnull, "YES") == 0 ? 1 : 0); + AST_LIST_INSERT_TAIL(&table->columns, column, list); + } + mysql_free_result(result); + } + + AST_LIST_INSERT_TAIL(&mysql_tables, table, list); + ast_mutex_lock(&table->lock); + AST_LIST_UNLOCK(&mysql_tables); + release_database(dbh); + return table; +} + +static void release_table(struct tables *table) +{ + if (table) { + ast_mutex_unlock(&table->lock); + } +} + +static struct columns *find_column(struct tables *table, const char *colname) +{ + struct columns *column; + + AST_LIST_TRAVERSE(&table->columns, column, list) { + if (strcmp(column->name, colname) == 0) { + break; + } + } + + return column; +} + +static struct ast_variable *realtime_mysql(const char *database, const char *table, va_list ap) +{ + struct mysql_conn *dbh; + MYSQL_RES *result; + MYSQL_ROW row; + MYSQL_FIELD *fields; + int numFields, i, valsz; + struct ast_str *sql = ast_str_thread_get(&sql_buf, 16); + struct ast_str *buf = ast_str_thread_get(&scratch_buf, 16); + char *stringp; + char *chunk; + char *op; + const char *newparam, *newval; + struct ast_variable *var=NULL, *prev=NULL; + + if (!(dbh = find_database(database, 0))) { + ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: %s\n", database); + return NULL; + } + + if (!table) { + ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n"); + release_database(dbh); + return NULL; + } + + /* Get the first parameter and first value in our list of passed paramater/value pairs */ + newparam = va_arg(ap, const char *); + newval = va_arg(ap, const char *); + if (!newparam || !newval) { + ast_log(LOG_WARNING, "MySQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n"); + release_database(dbh); + return NULL; + } + + /* Must connect to the server before anything else, as the escape function requires the mysql handle. */ + if (!mysql_reconnect(dbh)) { + release_database(dbh); + return NULL; + } + + /* Create the first part of the query using the first parameter/value pairs we just extracted + If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */ + + if (!strchr(newparam, ' ')) + op = " ="; + else + op = ""; + + ESCAPE_STRING(buf, newval); + ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s%s '%s'", table, newparam, op, ast_str_buffer(buf)); + while ((newparam = va_arg(ap, const char *))) { + newval = va_arg(ap, const char *); + if (!strchr(newparam, ' ')) + op = " ="; + else + op = ""; + ESCAPE_STRING(buf, newval); + ast_str_append(&sql, 0, " AND %s%s '%s'", newparam, op, ast_str_buffer(buf)); + } + va_end(ap); + + ast_debug(1, "MySQL RealTime: Retrieve SQL: %s\n", ast_str_buffer(sql)); + + /* Execution. */ + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle)); + release_database(dbh); + return NULL; + } + + if ((result = mysql_store_result(&dbh->handle))) { + numFields = mysql_num_fields(result); + fields = mysql_fetch_fields(result); + + while ((row = mysql_fetch_row(result))) { + for (i = 0; i < numFields; i++) { + if (ast_strlen_zero(row[i])) + continue; + for (stringp = ast_strdupa(row[i]), chunk = strsep(&stringp, ";"); chunk; chunk = strsep(&stringp, ";")) { + if (!chunk || ast_strlen_zero(ast_strip(chunk))) { + continue; + } + if (prev) { + if ((prev->next = ast_variable_new(fields[i].name, chunk, ""))) { + prev = prev->next; + } + } else { + prev = var = ast_variable_new(fields[i].name, chunk, ""); + } + } + } + } + } else { + ast_debug(1, "MySQL RealTime: Could not find any rows in table %s.\n", table); + } + + release_database(dbh); + mysql_free_result(result); + + return var; +} + +static struct ast_config *realtime_multi_mysql(const char *database, const char *table, va_list ap) +{ + struct mysql_conn *dbh; + MYSQL_RES *result; + MYSQL_ROW row; + MYSQL_FIELD *fields; + int numFields, i, valsz; + struct ast_str *sql = ast_str_thread_get(&sql_buf, 16); + struct ast_str *buf = ast_str_thread_get(&scratch_buf, 16); + const char *initfield = NULL; + char *stringp; + char *chunk; + char *op; + const char *newparam, *newval; + struct ast_variable *var = NULL; + struct ast_config *cfg = NULL; + struct ast_category *cat = NULL; + + if (!(dbh = find_database(database, 0))) { + ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'\n", database); + return NULL; + } + + if (!table) { + ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n"); + release_database(dbh); + return NULL; + } + + if (!(cfg = ast_config_new())) { + /* If I can't alloc memory at this point, why bother doing anything else? */ + ast_log(LOG_WARNING, "Out of memory!\n"); + release_database(dbh); + return NULL; + } + + /* Get the first parameter and first value in our list of passed paramater/value pairs */ + newparam = va_arg(ap, const char *); + newval = va_arg(ap, const char *); + if (!newparam || !newval) { + ast_log(LOG_WARNING, "MySQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n"); + ast_config_destroy(cfg); + release_database(dbh); + return NULL; + } + + initfield = ast_strdupa(newparam); + if (initfield && (op = strchr(initfield, ' '))) { + *op = '\0'; + } + + /* Must connect to the server before anything else, as the escape function requires the mysql handle. */ + if (!mysql_reconnect(dbh)) { + release_database(dbh); + ast_config_destroy(cfg); + return NULL; + } + + /* Create the first part of the query using the first parameter/value pairs we just extracted + If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */ + + if (!strchr(newparam, ' ')) + op = " ="; + else + op = ""; + + ESCAPE_STRING(buf, newval); + ast_str_set(&sql, 0, "SELECT * FROM %s WHERE %s%s '%s'", table, newparam, op, ast_str_buffer(buf)); + while ((newparam = va_arg(ap, const char *))) { + newval = va_arg(ap, const char *); + if (!strchr(newparam, ' ')) op = " ="; else op = ""; + ESCAPE_STRING(buf, newval); + ast_str_append(&sql, 0, " AND %s%s '%s'", newparam, op, ast_str_buffer(buf)); + } + + if (initfield) { + ast_str_append(&sql, 0, " ORDER BY %s", initfield); + } + + va_end(ap); + + ast_debug(1, "MySQL RealTime: Retrieve SQL: %s\n", ast_str_buffer(sql)); + + /* Execution. */ + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle)); + release_database(dbh); + ast_config_destroy(cfg); + return NULL; + } + + if ((result = mysql_store_result(&dbh->handle))) { + numFields = mysql_num_fields(result); + fields = mysql_fetch_fields(result); + + while ((row = mysql_fetch_row(result))) { + var = NULL; + cat = ast_category_new("", "", -1); + if (!cat) { + ast_log(LOG_WARNING, "Out of memory!\n"); + continue; + } + for (i = 0; i < numFields; i++) { + if (ast_strlen_zero(row[i])) + continue; + for (stringp = ast_strdupa(row[i]), chunk = strsep(&stringp, ";"); chunk; chunk = strsep(&stringp, ";")) { + if (chunk && !ast_strlen_zero(ast_strip(chunk))) { + if (initfield && !strcmp(initfield, fields[i].name)) { + ast_category_rename(cat, chunk); + } + var = ast_variable_new(fields[i].name, chunk, ""); + ast_variable_append(cat, var); + } + } + } + ast_category_append(cfg, cat); + } + } else { + ast_debug(1, "MySQL RealTime: Could not find any rows in table %s.\n", table); + } + + release_database(dbh); + mysql_free_result(result); + + return cfg; +} + +static int update_mysql(const char *database, const char *tablename, const char *keyfield, const char *lookup, va_list ap) +{ + struct mysql_conn *dbh; + my_ulonglong numrows; + int valsz; + const char *newparam, *newval; + struct ast_str *sql = ast_str_thread_get(&sql_buf, 100), *buf = ast_str_thread_get(&scratch_buf, 100); + struct tables *table; + struct columns *column = NULL; + + if (!(dbh = find_database(database, 1))) { + ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'.\n", database); + return -1; + } + + if (!tablename) { + ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n"); + release_database(dbh); + return -1; + } + + if (!(table = find_table(database, tablename))) { + ast_log(LOG_ERROR, "Table '%s' does not exist!!\n", tablename); + release_database(dbh); + return -1; + } + + if (!(column = find_column(table, keyfield))) { + ast_log(LOG_ERROR, "MySQL RealTime: Updating on column '%s', but that column does not exist within the table '%s'!\n", keyfield, tablename); + release_table(table); + release_database(dbh); + return -1; + } + + /* Get the first parameter and first value in our list of passed paramater/value pairs */ + newparam = va_arg(ap, const char *); + newval = va_arg(ap, const char *); + if (!newparam || !newval) { + ast_log(LOG_WARNING, "MySQL RealTime: Realtime retrieval requires at least 1 parameter and 1 value to search on.\n"); + release_table(table); + release_database(dbh); + return -1; + } + + /* Check that the column exists in the table */ + if (!(column = find_column(table, newparam))) { + ast_log(LOG_ERROR, "MySQL RealTime: Updating on column '%s', but that column does not exist within the table '%s'!\n", newparam, tablename); + release_table(table); + release_database(dbh); + return -1; + } + + /* Must connect to the server before anything else, as the escape function requires the mysql handle. */ + if (!mysql_reconnect(dbh)) { + release_table(table); + release_database(dbh); + return -1; + } + + /* Create the first part of the query using the first parameter/value pairs we just extracted + If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */ + + ESCAPE_STRING(buf, newval); + ast_str_set(&sql, 0, "UPDATE %s SET %s = '%s'", tablename, newparam, ast_str_buffer(buf)); + + /* If the column length isn't long enough, give a chance to lengthen it. */ + if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) { + internal_require(database, tablename, newparam, RQ_CHAR, valsz, SENTINEL); + } + + while ((newparam = va_arg(ap, const char *))) { + newval = va_arg(ap, const char *); + + /* If the column is not within the table, then skip it */ + if (!(column = find_column(table, newparam))) { + ast_log(LOG_WARNING, "Attempted to update column '%s' in table '%s', but column does not exist!\n", newparam, tablename); + continue; + } + + ESCAPE_STRING(buf, newval); + ast_str_append(&sql, 0, ", %s = '%s'", newparam, ast_str_buffer(buf)); + + /* If the column length isn't long enough, give a chance to lengthen it. */ + if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) { + internal_require(database, tablename, newparam, RQ_CHAR, valsz, SENTINEL); + } + } + va_end(ap); + + ESCAPE_STRING(buf, lookup); + ast_str_append(&sql, 0, " WHERE %s = '%s'", keyfield, ast_str_buffer(buf)); + + ast_debug(1, "MySQL RealTime: Update SQL: %s\n", ast_str_buffer(sql)); + + /* Execution. */ + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle)); + release_table(table); + release_database(dbh); + return -1; + } + + numrows = mysql_affected_rows(&dbh->handle); + release_table(table); + release_database(dbh); + + ast_debug(1, "MySQL RealTime: Updated %llu rows on table: %s\n", numrows, tablename); + + /* From http://dev.mysql.com/doc/mysql/en/mysql-affected-rows.html + * An integer greater than zero indicates the number of rows affected + * Zero indicates that no records were updated + * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.) + */ + + return (int)numrows; +} + +static int update2_mysql(const char *database, const char *tablename, va_list ap) +{ + struct mysql_conn *dbh; + my_ulonglong numrows; + int first = 1; + const char *newparam, *newval; + size_t valsz; + struct ast_str *sql = ast_str_thread_get(&sql_buf, 100), *buf = ast_str_thread_get(&scratch_buf, 100); + struct ast_str *where = ast_str_thread_get(&sql2_buf, 100); + struct tables *table; + struct columns *column = NULL; + + if (!tablename) { + ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n"); + return -1; + } + + if (!(dbh = find_database(database, 1))) { + ast_log(LOG_ERROR, "Invalid database specified: %s\n", database); + return -1; + } + + if (!(table = find_table(database, tablename))) { + ast_log(LOG_ERROR, "Table '%s' does not exist!!\n", tablename); + release_database(dbh); + return -1; + } + + if (!sql || !buf || !where) { + release_database(dbh); + release_table(table); + return -1; + } + + ast_str_set(&sql, 0, "UPDATE %s SET", tablename); + ast_str_set(&where, 0, "WHERE"); + + /* Must connect to the server before anything else, as the escape function requires the mysql handle. */ + if (!mysql_reconnect(dbh)) { + release_table(table); + release_database(dbh); + return -1; + } + + while ((newparam = va_arg(ap, const char *))) { + if (!(column = find_column(table, newparam))) { + ast_log(LOG_ERROR, "Updating on column '%s', but that column does not exist within the table '%s'!\n", newparam, tablename); + release_table(table); + release_database(dbh); + return -1; + } + if (!(newval = va_arg(ap, const char *))) { + ast_log(LOG_ERROR, "Invalid arguments: no value specified for column '%s' on '%s@%s'\n", newparam, tablename, database); + release_table(table); + release_database(dbh); + return -1; + } + ESCAPE_STRING(buf, newval); + ast_str_append(&where, 0, "%s %s='%s'", first ? "" : " AND", newparam, ast_str_buffer(buf)); + first = 0; + + /* If the column length isn't long enough, give a chance to lengthen it. */ + if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) { + internal_require(database, tablename, newparam, RQ_CHAR, valsz, SENTINEL); + } + } + + first = 1; + while ((newparam = va_arg(ap, const char *))) { + if (!(newval = va_arg(ap, const char *))) { + ast_log(LOG_ERROR, "Invalid arguments: no value specified for column '%s' on '%s@%s'\n", newparam, tablename, database); + release_table(table); + release_database(dbh); + return -1; + } + + /* If the column is not within the table, then skip it */ + if (!(column = find_column(table, newparam))) { + ast_log(LOG_WARNING, "Attempted to update column '%s' in table '%s', but column does not exist!\n", newparam, tablename); + continue; + } + + ESCAPE_STRING(buf, newval); + ast_str_append(&sql, 0, "%s %s = '%s'", first ? "" : ",", newparam, ast_str_buffer(buf)); + + /* If the column length isn't long enough, give a chance to lengthen it. */ + if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) { + internal_require(database, tablename, newparam, RQ_CHAR, valsz, SENTINEL); + } + } + va_end(ap); + release_table(table); + + ast_str_append(&sql, 0, " %s", ast_str_buffer(where)); + + ast_debug(1, "MySQL RealTime: Update SQL: %s\n", ast_str_buffer(sql)); + + /* Execution. */ + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle)); + release_table(table); + release_database(dbh); + return -1; + } + + numrows = mysql_affected_rows(&dbh->handle); + release_database(dbh); + + ast_debug(1, "MySQL RealTime: Updated %llu rows on table: %s\n", numrows, tablename); + + /* From http://dev.mysql.com/doc/mysql/en/mysql-affected-rows.html + * An integer greater than zero indicates the number of rows affected + * Zero indicates that no records were updated + * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.) + */ + + return (int)numrows; +} + +static int store_mysql(const char *database, const char *table, va_list ap) +{ + struct mysql_conn *dbh; + my_ulonglong insertid; + struct ast_str *sql = ast_str_thread_get(&sql_buf, 16); + struct ast_str *sql2 = ast_str_thread_get(&sql2_buf, 16); + struct ast_str *buf = ast_str_thread_get(&scratch_buf, 16); + int valsz; + const char *newparam, *newval; + + if (!(dbh = find_database(database, 1))) { + ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'.\n", database); + return -1; + } + + if (!table) { + ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n"); + release_database(dbh); + return -1; + } + /* Get the first parameter and first value in our list of passed paramater/value pairs */ + newparam = va_arg(ap, const char *); + newval = va_arg(ap, const char *); + if (!newparam || !newval) { + ast_log(LOG_WARNING, "MySQL RealTime: Realtime storage requires at least 1 parameter and 1 value to search on.\n"); + release_database(dbh); + return -1; + } + /* Must connect to the server before anything else, as the escape function requires the mysql handle. */ + if (!mysql_reconnect(dbh)) { + release_database(dbh); + return -1; + } + /* Create the first part of the query using the first parameter/value pairs we just extracted + If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */ + ESCAPE_STRING(buf, newval); + ast_str_set(&sql, 0, "INSERT INTO %s (%s", table, newparam); + ast_str_set(&sql2, 0, ") VALUES ('%s'", ast_str_buffer(buf)); + + internal_require(database, table, newparam, RQ_CHAR, valsz, SENTINEL); + + while ((newparam = va_arg(ap, const char *))) { + if ((newval = va_arg(ap, const char *))) { + ESCAPE_STRING(buf, newval); + } else { + valsz = 0; + ast_str_reset(buf); + } + if (internal_require(database, table, newparam, RQ_CHAR, valsz, SENTINEL) == 0) { + ast_str_append(&sql, 0, ", %s", newparam); + ast_str_append(&sql2, 0, ", '%s'", ast_str_buffer(buf)); + } + } + va_end(ap); + ast_str_append(&sql, 0, "%s)", ast_str_buffer(sql2)); + ast_debug(1,"MySQL RealTime: Insert SQL: %s\n", ast_str_buffer(sql)); + + /* Execution. */ + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle)); + release_database(dbh); + return -1; + } + + /*!\note The return value is non-portable and may change in future versions. */ + insertid = mysql_insert_id(&dbh->handle); + release_database(dbh); + + ast_debug(1, "MySQL RealTime: row inserted on table: %s, id: %llu\n", table, insertid); + + /* From http://dev.mysql.com/doc/mysql/en/mysql-affected-rows.html + * An integer greater than zero indicates the number of rows affected + * Zero indicates that no records were updated + * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.) + */ + return (int)insertid; +} + +static int destroy_mysql(const char *database, const char *table, const char *keyfield, const char *lookup, va_list ap) +{ + struct mysql_conn *dbh; + my_ulonglong numrows; + struct ast_str *sql = ast_str_thread_get(&sql_buf, 16); + struct ast_str *buf = ast_str_thread_get(&scratch_buf, 16); + int valsz; + const char *newparam, *newval; + + if (!(dbh = find_database(database, 1))) { + ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'.\n", database); + return -1; + } + + if (!table) { + ast_log(LOG_WARNING, "MySQL RealTime: No table specified.\n"); + release_database(dbh); + return -1; + } + + /* Get the first parameter and first value in our list of passed paramater/value pairs */ + /* newparam = va_arg(ap, const char *); + newval = va_arg(ap, const char *);*/ + if (ast_strlen_zero(keyfield) || ast_strlen_zero(lookup)) { + ast_log(LOG_WARNING, "MySQL RealTime: Realtime destroying requires at least 1 parameter and 1 value to search on.\n"); + release_database(dbh); + return -1; + } + + /* Must connect to the server before anything else, as the escape function requires the mysql handle. */ + if (!mysql_reconnect(dbh)) { + release_database(dbh); + return -1; + } + + /* Create the first part of the query using the first parameter/value pairs we just extracted + If there is only 1 set, then we have our query. Otherwise, loop thru the list and concat */ + ESCAPE_STRING(buf, lookup); + ast_str_set(&sql, 0, "DELETE FROM %s WHERE %s = '%s'", table, keyfield, ast_str_buffer(buf)); + while ((newparam = va_arg(ap, const char *))) { + newval = va_arg(ap, const char *); + ESCAPE_STRING(buf, newval); + ast_str_append(&sql, 0, " AND %s = '%s'", newparam, ast_str_buffer(buf)); + } + va_end(ap); + + ast_debug(1, "MySQL RealTime: Delete SQL: %s\n", ast_str_buffer(sql)); + + /* Execution. */ + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle)); + release_database(dbh); + return -1; + } + + numrows = mysql_affected_rows(&dbh->handle); + release_database(dbh); + + ast_debug(1, "MySQL RealTime: Deleted %llu rows on table: %s\n", numrows, table); + + /* From http://dev.mysql.com/doc/mysql/en/mysql-affected-rows.html + * An integer greater than zero indicates the number of rows affected + * Zero indicates that no records were updated + * -1 indicates that the query returned an error (although, if the query failed, it should have been caught above.) + */ + + return (int)numrows; +} + +static struct ast_config *config_mysql(const char *database, const char *table, const char *file, struct ast_config *cfg, struct ast_flags config_flags, const char *unused, const char *who_asked) +{ + struct mysql_conn *dbh; + MYSQL_RES *result; + MYSQL_ROW row; + my_ulonglong num_rows; + struct ast_variable *new_v; + struct ast_category *cur_cat = NULL; + struct ast_str *sql = ast_str_thread_get(&sql_buf, 200); + char last[80] = ""; + int last_cat_metric = 0; + + ast_clear_flag(&config_flags, CONFIG_FLAG_FILEUNCHANGED); + + if (!file || !strcmp(file, RES_CONFIG_MYSQL_CONF)) { + ast_log(LOG_WARNING, "MySQL RealTime: Cannot configure myself.\n"); + return NULL; + } + + if (!(dbh = find_database(database, 0))) { + ast_log(LOG_WARNING, "MySQL RealTime: Invalid database specified: '%s'\n", database); + return NULL; + } + + ast_str_set(&sql, 0, "SELECT category, var_name, var_val, cat_metric FROM %s WHERE filename='%s' and commented=1 ORDER BY filename, cat_metric desc, var_metric asc, category, var_name, var_val, id", table, file); + + ast_debug(1, "MySQL RealTime: Static SQL: %s\n", ast_str_buffer(sql)); + + /* We now have our complete statement; Lets connect to the server and execute it. */ + if (!mysql_reconnect(dbh)) { + return NULL; + } + + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database. Check debug for more info.\n"); + ast_debug(1, "MySQL RealTime: Query: %s\n", ast_str_buffer(sql)); + ast_debug(1, "MySQL RealTime: Query Failed because: %s\n", mysql_error(&dbh->handle)); + release_database(dbh); + return NULL; + } + + if ((result = mysql_store_result(&dbh->handle))) { + num_rows = mysql_num_rows(result); + ast_debug(1, "MySQL RealTime: Found %llu rows.\n", num_rows); + + /* There might exist a better way to access the column names other than counting, + * but I believe that would require another loop that we don't need. */ + + while ((row = mysql_fetch_row(result))) { + if (!strcmp(row[1], "#include")) { + if (!ast_config_internal_load(row[2], cfg, config_flags, "", who_asked)) { + mysql_free_result(result); + release_database(dbh); + ast_config_destroy(cfg); + return NULL; + } + continue; + } + + if (strcmp(last, row[0]) || last_cat_metric != atoi(row[3])) { + if (!(cur_cat = ast_category_new(row[0], "", -1))) { + ast_log(LOG_WARNING, "Out of memory!\n"); + break; + } + strcpy(last, row[0]); + last_cat_metric = atoi(row[3]); + ast_category_append(cfg, cur_cat); + } + new_v = ast_variable_new(row[1], row[2], ""); + if (cur_cat) + ast_variable_append(cur_cat, new_v); + } + } else { + ast_log(LOG_WARNING, "MySQL RealTime: Could not find config '%s' in database.\n", file); + } + + mysql_free_result(result); + release_database(dbh); + + return cfg; +} + +static int unload_mysql(const char *database, const char *tablename) +{ + struct tables *cur; + AST_LIST_LOCK(&mysql_tables); + AST_LIST_TRAVERSE_SAFE_BEGIN(&mysql_tables, cur, list) { + if (strcmp(cur->name, tablename) == 0) { + AST_LIST_REMOVE_CURRENT(list); + destroy_table(cur); + break; + } + } + AST_LIST_TRAVERSE_SAFE_END + AST_LIST_UNLOCK(&mysql_tables); + return cur ? 0 : -1; +} + +static int modify_mysql(const char *database, const char *tablename, struct columns *column, require_type type, int len) +{ + /*!\note Cannot use ANY of the same scratch space as is used in other functions, as this one is interspersed. */ + struct ast_str *sql = ast_str_thread_get(&modify_buf, 100), *escbuf = ast_str_thread_get(&modify2_buf, 100); + struct ast_str *typestr = ast_str_thread_get(&modify3_buf, 30); + int waschar = strncasecmp(column->type, "char", 4) == 0 ? 1 : 0; + int wasvarchar = strncasecmp(column->type, "varchar", 7) == 0 ? 1 : 0; + int res = 0; + struct mysql_conn *dbh; + + if (!(dbh = find_database(database, 1))) { + return -1; + } + + do { + if (type == RQ_CHAR || waschar || wasvarchar) { + if (wasvarchar) { + ast_str_set(&typestr, 0, "VARCHAR(%d)", len); + } else { + ast_str_set(&typestr, 0, "CHAR(%d)", len); + } + } else if (type == RQ_UINTEGER1) { + ast_str_set(&typestr, 0, "tinyint(3) unsigned"); + } else if (type == RQ_INTEGER1) { + ast_str_set(&typestr, 0, "tinyint(4)"); + } else if (type == RQ_UINTEGER2) { + ast_str_set(&typestr, 0, "smallint(5) unsigned"); + } else if (type == RQ_INTEGER2) { + ast_str_set(&typestr, 0, "smallint(6)"); + } else if (type == RQ_UINTEGER3) { + ast_str_set(&typestr, 0, "mediumint(8) unsigned"); + } else if (type == RQ_INTEGER3) { + ast_str_set(&typestr, 0, "mediumint(8)"); + } else if (type == RQ_UINTEGER4) { + ast_str_set(&typestr, 0, "int(10) unsigned"); + } else if (type == RQ_INTEGER4) { + ast_str_set(&typestr, 0, "int(11)"); + } else if (type == RQ_UINTEGER8) { + ast_str_set(&typestr, 0, "bigint(19) unsigned"); + } else if (type == RQ_INTEGER8) { + ast_str_set(&typestr, 0, "bigint(20)"); + } else if (type == RQ_DATETIME) { + ast_str_set(&typestr, 0, "datetime"); + } else if (type == RQ_DATE) { + ast_str_set(&typestr, 0, "date"); + } else if (type == RQ_FLOAT) { + ast_str_set(&typestr, 0, "FLOAT(%d,2)", len); + } else { + ast_log(LOG_ERROR, "Unknown type (should NEVER happen)\n"); + res = -1; + break; + } + ast_str_set(&sql, 0, "ALTER TABLE %s MODIFY %s %s", tablename, column->name, ast_str_buffer(typestr)); + if (!column->null) { + ast_str_append(&sql, 0, " NOT NULL"); + } + if (!ast_strlen_zero(column->dflt)) { + size_t valsz; + ESCAPE_STRING(escbuf, column->dflt); + ast_str_append(&sql, 0, " DEFAULT '%s'", ast_str_buffer(escbuf)); + } + + if (!mysql_reconnect(dbh)) { + ast_log(LOG_ERROR, "Unable to add column: %s\n", ast_str_buffer(sql)); + res = -1; + break; + } + + /* Execution. */ + if (mysql_real_query(&dbh->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database: %s\n", mysql_error(&dbh->handle)); + ast_debug(1, "MySQL RealTime: Query: %s\n", ast_str_buffer(sql)); + res = -1; + } + } while (0); + + release_database(dbh); + return res; +} + +#define PICK_WHICH_ALTER_ACTION(stringtype) \ + if (table->database->requirements == RQ_WARN) { \ + ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' may not be large enough for " \ + "the required data length: %d (detected stringtype)\n", \ + tablename, database, column->name, size); \ + res = -1; \ + } else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) { \ + table_altered = 1; \ + } else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) { \ + table_altered = 1; \ + } else { \ + res = -1; \ + } + +static int require_mysql(const char *database, const char *tablename, va_list ap) +{ + struct columns *column; + struct tables *table = find_table(database, tablename); + char *elm; + int type, size, res = 0, table_altered = 0; + + if (!table) { + ast_log(LOG_WARNING, "Table %s not found in database. This table should exist if you're using realtime.\n", tablename); + return -1; + } + + while ((elm = va_arg(ap, char *))) { + type = va_arg(ap, require_type); + size = va_arg(ap, int); + AST_LIST_TRAVERSE(&table->columns, column, list) { + if (strcmp(column->name, elm) == 0) { + /* Char can hold anything, as long as it is large enough */ + if (strncmp(column->type, "char", 4) == 0 || strncmp(column->type, "varchar", 7) == 0) { + if ((size > column->len) && column->len != -1) { + if (table->database->requirements == RQ_WARN) { + ast_log(LOG_WARNING, "Realtime table %s@%s: Column '%s' should be at least %d long, but is only %d long.\n", database, tablename, column->name, size, column->len); + res = -1; + } else if (modify_mysql(database, tablename, column, type, size) == 0) { + table_altered = 1; + } else { + res = -1; + } + } + } else if (strcasestr(column->type, "unsigned")) { + if (!ast_rq_is_int(type)) { + if (table->database->requirements == RQ_WARN) { + ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' cannot be type '%s' (need %s)\n", + database, tablename, column->name, column->type, + type == RQ_CHAR ? "char" : type == RQ_FLOAT ? "float" : + type == RQ_DATETIME ? "datetime" : type == RQ_DATE ? "date" : "a rather stiff drink"); + res = -1; + } else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) { + table_altered = 1; + } else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) { + table_altered = 1; + } else { + res = -1; + } + } else if (strncasecmp(column->type, "tinyint", 1) == 0) { + if (type != RQ_UINTEGER1) { + PICK_WHICH_ALTER_ACTION(unsigned tinyint) + } + } else if (strncasecmp(column->type, "smallint", 1) == 0) { + if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && type != RQ_UINTEGER2) { + PICK_WHICH_ALTER_ACTION(unsigned smallint) + } + } else if (strncasecmp(column->type, "mediumint", 1) == 0) { + if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && + type != RQ_UINTEGER2 && type != RQ_INTEGER2 && + type != RQ_UINTEGER3) { + PICK_WHICH_ALTER_ACTION(unsigned mediumint) + } + } else if (strncasecmp(column->type, "int", 1) == 0) { + if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && + type != RQ_UINTEGER2 && type != RQ_INTEGER2 && + type != RQ_UINTEGER3 && type != RQ_INTEGER3 && + type != RQ_UINTEGER4) { + PICK_WHICH_ALTER_ACTION(unsigned int) + } + } else if (strncasecmp(column->type, "bigint", 1) == 0) { + if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && + type != RQ_UINTEGER2 && type != RQ_INTEGER2 && + type != RQ_UINTEGER3 && type != RQ_INTEGER3 && + type != RQ_UINTEGER4 && type != RQ_INTEGER4 && + type != RQ_UINTEGER8) { + PICK_WHICH_ALTER_ACTION(unsigned bigint) + } + } + } else if (strcasestr(column->type, "int")) { + if (!ast_rq_is_int(type)) { + if (table->database->requirements == RQ_WARN) { + ast_log(LOG_WARNING, "Realtime table %s@%s: column '%s' cannot be type '%s' (need %s)\n", + database, tablename, column->name, column->type, + type == RQ_CHAR ? "char" : type == RQ_FLOAT ? "float" : + type == RQ_DATETIME ? "datetime" : type == RQ_DATE ? "date" : + "to get a life, rather than writing silly error messages"); + res = -1; + } else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) { + table_altered = 1; + } else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) { + table_altered = 1; + } else { + res = -1; + } + } else if (strncasecmp(column->type, "tinyint", 1) == 0) { + if (type != RQ_INTEGER1) { + PICK_WHICH_ALTER_ACTION(tinyint) + } + } else if (strncasecmp(column->type, "smallint", 1) == 0) { + if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && type != RQ_INTEGER2) { + PICK_WHICH_ALTER_ACTION(smallint) + } + } else if (strncasecmp(column->type, "mediumint", 1) == 0) { + if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && + type != RQ_UINTEGER2 && type != RQ_INTEGER2 && + type != RQ_INTEGER3) { + PICK_WHICH_ALTER_ACTION(mediumint) + } + } else if (strncasecmp(column->type, "int", 1) == 0) { + if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && + type != RQ_UINTEGER2 && type != RQ_INTEGER2 && + type != RQ_UINTEGER3 && type != RQ_INTEGER3 && + type != RQ_INTEGER4) { + PICK_WHICH_ALTER_ACTION(int) + } + } else if (strncasecmp(column->type, "bigint", 1) == 0) { + if (type != RQ_UINTEGER1 && type != RQ_INTEGER1 && + type != RQ_UINTEGER2 && type != RQ_INTEGER2 && + type != RQ_UINTEGER3 && type != RQ_INTEGER3 && + type != RQ_UINTEGER4 && type != RQ_INTEGER4 && + type != RQ_INTEGER8) { + PICK_WHICH_ALTER_ACTION(bigint) + } + } + } else if (strncmp(column->type, "float", 5) == 0 && !ast_rq_is_int(type) && type != RQ_FLOAT) { + if (table->database->requirements == RQ_WARN) { + ast_log(LOG_WARNING, "Realtime table %s@%s: Column %s cannot be a %s\n", tablename, database, column->name, column->type); + res = -1; + } else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) { + table_altered = 1; + } else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) { + table_altered = 1; + } else { + res = -1; + } + } else if ((strncmp(column->type, "datetime", 8) == 0 || strncmp(column->type, "timestamp", 9)) && type != RQ_DATETIME) { + if (table->database->requirements == RQ_WARN) { + ast_log(LOG_WARNING, "Realtime table %s@%s: Column %s cannot be a %s\n", tablename, database, column->name, column->type); + res = -1; + } else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) { + table_altered = 1; + } else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) { + table_altered = 1; + } else { + res = -1; + } + } else if ((strncmp(column->type, "date", 4) == 0) && type != RQ_DATE) { + if (table->database->requirements == RQ_WARN) { + ast_log(LOG_WARNING, "Realtime table %s@%s: Column %s cannot be a %s\n", tablename, database, column->name, column->type); + res = -1; + } else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) { + table_altered = 1; + } else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) { + table_altered = 1; + } else { + res = -1; + } + } else { /* Other, possibly unsupported types? */ + if (table->database->requirements == RQ_WARN) { + ast_log(LOG_WARNING, "Possibly unsupported column type '%s' on column '%s'\n", column->type, column->name); + res = -1; + } else if (table->database->requirements == RQ_CREATECLOSE && modify_mysql(database, tablename, column, type, size) == 0) { + table_altered = 1; + } else if (table->database->requirements == RQ_CREATECHAR && modify_mysql(database, tablename, column, RQ_CHAR, size) == 0) { + table_altered = 1; + } else { + } + } + break; + } + } + + if (!column) { + if (table->database->requirements == RQ_WARN) { + ast_log(LOG_WARNING, "Table %s requires a column '%s' of size '%d', but no such column exists.\n", tablename, elm, size); + } else { + struct ast_str *sql = ast_str_thread_get(&modify_buf, 100), *fieldtype = ast_str_thread_get(&modify3_buf, 16); + + if (table->database->requirements == RQ_CREATECHAR || type == RQ_CHAR) { + ast_str_set(&fieldtype, 0, "CHAR(%d)", size); + } else if (type == RQ_UINTEGER1 || type == RQ_UINTEGER2 || type == RQ_UINTEGER3 || type == RQ_UINTEGER4 || type == RQ_UINTEGER8) { + if (type == RQ_UINTEGER1) { + ast_str_set(&fieldtype, 0, "TINYINT(3) UNSIGNED"); + } else if (type == RQ_UINTEGER2) { + ast_str_set(&fieldtype, 0, "SMALLINT(5) UNSIGNED"); + } else if (type == RQ_UINTEGER3) { + ast_str_set(&fieldtype, 0, "MEDIUMINT(8) UNSIGNED"); + } else if (type == RQ_UINTEGER4) { + ast_str_set(&fieldtype, 0, "INT(10) UNSIGNED"); + } else if (type == RQ_UINTEGER8) { + ast_str_set(&fieldtype, 0, "BIGINT(20) UNSIGNED"); + } else { + ast_log(LOG_WARNING, "Somebody should check this code for a rather large bug... it's about to squash Tokyo.\n"); + continue; + } + } else if (ast_rq_is_int(type)) { + if (type == RQ_INTEGER1) { + ast_str_set(&fieldtype, 0, "TINYINT(3)"); + } else if (type == RQ_INTEGER2) { + ast_str_set(&fieldtype, 0, "SMALLINT(5)"); + } else if (type == RQ_INTEGER3) { + ast_str_set(&fieldtype, 0, "MEDIUMINT(8)"); + } else if (type == RQ_INTEGER4) { + ast_str_set(&fieldtype, 0, "INT(10)"); + } else if (type == RQ_INTEGER8) { + ast_str_set(&fieldtype, 0, "BIGINT(20)"); + } else { + ast_log(LOG_WARNING, "Somebody should check this code for a rather large bug... it's about to eat Cincinnati.\n"); + continue; + } + } else if (type == RQ_FLOAT) { + ast_str_set(&fieldtype, 0, "FLOAT"); + } else if (type == RQ_DATE) { + ast_str_set(&fieldtype, 0, "DATE"); + } else if (type == RQ_DATETIME) { + ast_str_set(&fieldtype, 0, "DATETIME"); + } else { + continue; + } + ast_str_set(&sql, 0, "ALTER TABLE %s ADD COLUMN %s %s", tablename, elm, ast_str_buffer(fieldtype)); + + ast_mutex_lock(&table->database->lock); + if (!mysql_reconnect(table->database)) { + ast_mutex_unlock(&table->database->lock); + ast_log(LOG_ERROR, "Unable to add column: %s\n", ast_str_buffer(sql)); + continue; + } + + /* Execution. */ + if (mysql_real_query(&table->database->handle, ast_str_buffer(sql), ast_str_strlen(sql))) { + ast_log(LOG_WARNING, "MySQL RealTime: Failed to query database. Check debug for more info.\n"); + ast_debug(1, "MySQL RealTime: Query: %s\n", ast_str_buffer(sql)); + ast_debug(1, "MySQL RealTime: Query Failed because: %s\n", mysql_error(&table->database->handle)); + } else { + table_altered = 1; + } + } + } + } + release_table(table); + + /* If we altered the table, we must refresh the cache */ + if (table_altered) { + unload_mysql(database, tablename); + release_table(find_table(database, tablename)); + } + return res; +} + +static struct ast_config_engine mysql_engine = { + .name = "mysql", + .load_func = config_mysql, + .realtime_func = realtime_mysql, + .realtime_multi_func = realtime_multi_mysql, + .store_func = store_mysql, + .destroy_func = destroy_mysql, + .update_func = update_mysql, + .update2_func = update2_mysql, + .require_func = require_mysql, + .unload_func = unload_mysql, +}; + +static int load_module(void) +{ + parse_config(0); + + ast_config_engine_register(&mysql_engine); + if (option_verbose > 1) + ast_verbose(VERBOSE_PREFIX_2 "MySQL RealTime driver loaded.\n"); + ast_cli_register_multiple(cli_realtime_mysql_status, sizeof(cli_realtime_mysql_status) / sizeof(struct ast_cli_entry)); + return 0; +} + +static int unload_module(void) +{ + struct mysql_conn *cur; + struct tables *table; + + ast_cli_unregister_multiple(cli_realtime_mysql_status, sizeof(cli_realtime_mysql_status) / sizeof(struct ast_cli_entry)); + ast_config_engine_deregister(&mysql_engine); + if (option_verbose > 1) + ast_verbose(VERBOSE_PREFIX_2 "MySQL RealTime unloaded.\n"); + + ast_module_user_hangup_all(); + + usleep(1); + AST_RWLIST_WRLOCK(&databases); + while ((cur = AST_RWLIST_REMOVE_HEAD(&databases, list))) { + mysql_close(&cur->handle); + ast_mutex_destroy(&cur->lock); + ast_free(cur); + } + AST_RWLIST_UNLOCK(&databases); + + /* Destroy cached table info */ + AST_LIST_LOCK(&mysql_tables); + while ((table = AST_LIST_REMOVE_HEAD(&mysql_tables, list))) { + destroy_table(table); + } + AST_LIST_UNLOCK(&mysql_tables); + + return 0; +} + +static int reload(void) +{ + parse_config(1); + + if (option_verbose > 1) { + ast_verb(2, "MySQL RealTime reloaded.\n"); + } + + return 0; +} + +static int parse_config(int reload) +{ + struct ast_config *config = NULL; + struct ast_flags config_flags = { reload ? CONFIG_FLAG_FILEUNCHANGED : 0 }; + const char *catg; + struct mysql_conn *cur; + + if ((config = ast_config_load(RES_CONFIG_MYSQL_CONF, config_flags)) == CONFIG_STATUS_FILEMISSING) { + return 0; + } else if (config == CONFIG_STATUS_FILEUNCHANGED) { + return 0; + } else if (config == CONFIG_STATUS_FILEINVALID) { + ast_log(LOG_ERROR, "Not %sloading " RES_CONFIG_MYSQL_CONF "\n", reload ? "re" : ""); + } + + AST_RWLIST_WRLOCK(&databases); + for (catg = ast_category_browse(config, NULL); catg; catg = ast_category_browse(config, catg)) { + /* Does this category already exist? */ + AST_RWLIST_TRAVERSE(&databases, cur, list) { + if (!strcmp(cur->unique_name, catg)) { + break; + } + } + + if (!cur) { + if (!(cur = ast_calloc(1, sizeof(*cur) + strlen(catg) + 1))) { + ast_log(LOG_WARNING, "Could not allocate space for MySQL database '%s'\n", catg); + continue; + } + + strcpy(cur->unique_name, catg); /* SAFE */ + ast_mutex_init(&cur->lock); + AST_RWLIST_INSERT_TAIL(&databases, cur, list); + } + + load_mysql_config(config, catg, cur); + } + AST_RWLIST_UNLOCK(&databases); + + ast_config_destroy(config); + + return 0; +} + +static int load_mysql_config(struct ast_config *config, const char *category, struct mysql_conn *conn) +{ + const char *s; + + if (!(s = ast_variable_retrieve(config, category, "dbuser"))) { + ast_log(LOG_WARNING, "MySQL RealTime: No database user found, using 'asterisk' as default.\n"); + s = "asterisk"; + } + ast_copy_string(conn->user, s, sizeof(conn->user)); + + if (!(s = ast_variable_retrieve(config, category, "dbpass"))) { + ast_log(LOG_WARNING, "MySQL RealTime: No database password found, using 'asterisk' as default.\n"); + s = "asterisk"; + } + ast_copy_string(conn->pass, s, sizeof(conn->pass)); + + if (!(s = ast_variable_retrieve(config, category, "dbhost"))) { + ast_log(LOG_WARNING, "MySQL RealTime: No database host found, using localhost via socket.\n"); + s = ""; + } + ast_copy_string(conn->host, s, sizeof(conn->host)); + + if (!(s = ast_variable_retrieve(config, category, "dbname"))) { + ast_log(LOG_WARNING, "MySQL RealTime: No database name found, using 'asterisk' as default.\n"); + s = "asterisk"; + } + ast_copy_string(conn->name, s, sizeof(conn->name)); + + if (!(s = ast_variable_retrieve(config, category, "dbport"))) { + ast_log(LOG_WARNING, "MySQL RealTime: No database port found, using 3306 as default.\n"); + conn->port = 3306; + } else + conn->port = atoi(s); + + if (!(s = ast_variable_retrieve(config, category, "dbsock"))) { + if (ast_strlen_zero(conn->host)) { + char *paths[3] = { "/tmp/mysql.sock", "/var/lib/mysql/mysql.sock", "/var/run/mysqld/mysqld.sock" }; + struct stat st; + int i; + for (i = 0; i < 3; i++) { + if (!stat(paths[i], &st)) { + ast_log(LOG_WARNING, "MySQL RealTime: No database socket found, using '%s' as default.\n", paths[i]); + ast_copy_string(conn->sock, paths[i], sizeof(conn->sock)); + } + } + if (i == 3) { + ast_log(LOG_WARNING, "MySQL RealTime: No database socket found (and unable to detect a suitable path).\n"); + return 0; + } + } + } else + ast_copy_string(conn->sock, s, sizeof(conn->sock)); + + if (!(s = ast_variable_retrieve(config, category, "requirements"))) { + ast_log(LOG_WARNING, "MySQL realtime: no requirements setting found, using 'warn' as default.\n"); + conn->requirements = RQ_WARN; + } else if (!strcasecmp(s, "createclose")) { + conn->requirements = RQ_CREATECLOSE; + } else if (!strcasecmp(s, "createchar")) { + conn->requirements = RQ_CREATECHAR; + } else if (!strcasecmp(s, "warn")) { + conn->requirements = RQ_WARN; + } else { + ast_log(LOG_WARNING, "MySQL realtime: unrecognized requirements setting '%s', using 'warn'\n", s); + conn->requirements = RQ_WARN; + } + + if (!ast_strlen_zero(conn->host)) { + ast_debug(1, "MySQL RealTime host: %s\n", conn->host); + ast_debug(1, "MySQL RealTime port: %i\n", conn->port); + } else + ast_debug(1, "MySQL RealTime socket: %s\n", conn->sock); + ast_debug(1, "MySQL RealTime database name: %s\n", conn->name); + ast_debug(1, "MySQL RealTime user: %s\n", conn->user); + ast_debug(1, "MySQL RealTime password: %s\n", conn->pass); + + return 1; +} + +static int mysql_reconnect(struct mysql_conn *conn) +{ +#ifdef MYSQL_OPT_RECONNECT + my_bool trueval = 1; +#endif + + /* mutex lock should have been locked before calling this function. */ + +reconnect_tryagain: + if ((!conn->connected) && (!ast_strlen_zero(conn->host) || conn->sock) && !ast_strlen_zero(conn->user) && !ast_strlen_zero(conn->name)) { + if (!mysql_init(&conn->handle)) { + ast_log(LOG_WARNING, "MySQL RealTime: Insufficient memory to allocate MySQL resource.\n"); + conn->connected = 0; + return 0; + } + if (mysql_real_connect(&conn->handle, conn->host, conn->user, conn->pass, conn->name, conn->port, conn->sock, 0)) { +#ifdef MYSQL_OPT_RECONNECT + /* The default is no longer to automatically reconnect on failure, + * (as of 5.0.3) so we have to set that option here. */ + mysql_options(&conn->handle, MYSQL_OPT_RECONNECT, &trueval); +#endif + ast_debug(1, "MySQL RealTime: Successfully connected to database.\n"); + conn->connected = 1; + conn->connect_time = time(NULL); + return 1; + } else { + ast_log(LOG_ERROR, "MySQL RealTime: Failed to connect database server %s on %s (err %d). Check debug for more info.\n", conn->name, !ast_strlen_zero(conn->host) ? conn->host : conn->sock, mysql_errno(&conn->handle)); + ast_debug(1, "MySQL RealTime: Cannot Connect (%d): %s\n", mysql_errno(&conn->handle), mysql_error(&conn->handle)); + conn->connected = 0; + return 0; + } + } else { + /* MySQL likes to return an error, even if it reconnects successfully. + * So the postman pings twice. */ + if (mysql_ping(&conn->handle) != 0 && (usleep(1) + 2 > 0) && mysql_ping(&conn->handle) != 0) { + conn->connected = 0; + ast_log(LOG_ERROR, "MySQL RealTime: Ping failed (%d). Trying an explicit reconnect.\n", mysql_errno(&conn->handle)); + ast_debug(1, "MySQL RealTime: Server Error (%d): %s\n", mysql_errno(&conn->handle), mysql_error(&conn->handle)); + goto reconnect_tryagain; + } + + conn->connected = 1; + conn->connect_time = time(NULL); + + if (mysql_select_db(&conn->handle, conn->name) != 0) { + ast_log(LOG_WARNING, "MySQL RealTime: Unable to select database: %s. Still Connected (%u) - %s.\n", conn->name, mysql_errno(&conn->handle), mysql_error(&conn->handle)); + return 0; + } + + ast_debug(1, "MySQL RealTime: Connection okay.\n"); + return 1; + } +} + +static char *handle_cli_realtime_mysql_cache(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + struct tables *cur; + int l, which; + char *ret = NULL; + + switch (cmd) { + case CLI_INIT: + e->command = "realtime mysql cache"; + e->usage = + "Usage: realtime mysql cache [ ]\n" + " Shows table cache for the MySQL RealTime driver\n"; + return NULL; + case CLI_GENERATE: + if (a->argc < 4 || a->argc > 5) { + return NULL; + } + l = strlen(a->word); + which = 0; + if (a->argc == 5) { + AST_LIST_LOCK(&mysql_tables); + AST_LIST_TRAVERSE(&mysql_tables, cur, list) { + if (!strcasecmp(a->argv[3], cur->database->unique_name) && !strncasecmp(a->word, cur->name, l) && ++which > a->n) { + ret = ast_strdup(cur->name); + break; + } + } + AST_LIST_UNLOCK(&mysql_tables); + } else { + struct mysql_conn *cur; + AST_RWLIST_RDLOCK(&databases); + AST_RWLIST_TRAVERSE(&databases, cur, list) { + if (!strncasecmp(a->word, cur->unique_name, l) && ++which > a->n) { + ret = ast_strdup(cur->unique_name); + break; + } + } + AST_RWLIST_UNLOCK(&databases); + } + return ret; + } + + if (a->argc == 3) { + /* List of tables */ + AST_LIST_LOCK(&mysql_tables); + AST_LIST_TRAVERSE(&mysql_tables, cur, list) { + ast_cli(a->fd, "%20.20s %s\n", cur->database->unique_name, cur->name); + } + AST_LIST_UNLOCK(&mysql_tables); + } else if (a->argc == 4) { + int found = 0; + /* List of tables */ + AST_LIST_LOCK(&mysql_tables); + AST_LIST_TRAVERSE(&mysql_tables, cur, list) { + if (!strcasecmp(cur->database->unique_name, a->argv[3])) { + ast_cli(a->fd, "%s\n", cur->name); + found = 1; + } + } + AST_LIST_UNLOCK(&mysql_tables); + if (!found) { + ast_cli(a->fd, "No tables cached within %s database\n", a->argv[3]); + } + } else if (a->argc == 5) { + /* List of columns */ + if ((cur = find_table(a->argv[3], a->argv[4]))) { + struct columns *col; + ast_cli(a->fd, "Columns for Table Cache '%s':\n", a->argv[3]); + ast_cli(a->fd, "%-20.20s %-20.20s %-3.3s\n", "Name", "Type", "Len"); + AST_LIST_TRAVERSE(&cur->columns, col, list) { + ast_cli(a->fd, "%-20.20s %-20.20s %3d\n", col->name, col->type, col->len); + } + ast_mutex_unlock(&cur->lock); + } else { + ast_cli(a->fd, "No such table '%s'\n", a->argv[3]); + } + } + return CLI_SUCCESS; +} + +static char *handle_cli_realtime_mysql_status(struct ast_cli_entry *e, int cmd, struct ast_cli_args *a) +{ + char status[256], status2[100] = "", type[20]; + char *ret = NULL; + int ctime = 0, found = 0; + struct mysql_conn *cur; + int l = 0, which = 0; + + switch (cmd) { + case CLI_INIT: + e->command = "realtime mysql status"; + e->usage = + "Usage: realtime mysql status []\n" + " Shows connection information for the MySQL RealTime driver\n"; + return NULL; + case CLI_GENERATE: + if (a->argc == 4) { + AST_RWLIST_RDLOCK(&databases); + AST_RWLIST_TRAVERSE(&databases, cur, list) { + if (!strncasecmp(a->word, cur->unique_name, l) && ++which > a->n) { + ret = ast_strdup(cur->unique_name); + break; + } + } + AST_RWLIST_UNLOCK(&databases); + } + return ret; + } + + if (a->argc != 3) + return CLI_SHOWUSAGE; + + AST_RWLIST_RDLOCK(&databases); + AST_RWLIST_TRAVERSE(&databases, cur, list) { + if (a->argc == 3 || (a->argc == 4 && !strcasecmp(a->argv[3], cur->unique_name))) { + found = 1; + + if (mysql_reconnect(cur)) { + snprintf(type, sizeof(type), "connected to"); + ctime = time(NULL) - cur->connect_time; + } else { + snprintf(type, sizeof(type), "configured for"); + ctime = -1; + } + + if (!ast_strlen_zero(cur->host)) { + snprintf(status, sizeof(status), "%s %s %s@%s, port %d", cur->unique_name, type, cur->name, cur->host, cur->port); + } else { + snprintf(status, sizeof(status), "%s %s %s on socket file %s", cur->unique_name, type, cur->name, cur->sock); + } + + if (!ast_strlen_zero(cur->user)) { + snprintf(status2, sizeof(status2), " with username %s", cur->user); + } else { + status2[0] = '\0'; + } + + if (ctime > 31536000) { + ast_cli(a->fd, "%s%s for %.1f years.\n", status, status2, (double)ctime / 31536000.0); + } else if (ctime > 86400 * 30) { + ast_cli(a->fd, "%s%s for %d days.\n", status, status2, ctime / 86400); + } else if (ctime > 86400) { + ast_cli(a->fd, "%s%s for %d days, %d hours.\n", status, status2, ctime / 86400, (ctime % 86400) / 3600); + } else if (ctime > 3600) { + ast_cli(a->fd, "%s%s for %d hours, %d minutes.\n", status, status2, ctime / 3600, (ctime % 3600) / 60); + } else if (ctime > 60) { + ast_cli(a->fd, "%s%s for %d minutes.\n", status, status2, ctime / 60); + } else if (ctime > -1) { + ast_cli(a->fd, "%s%s for %d seconds.\n", status, status2, ctime); + } else { + ast_cli(a->fd, "%s%s.\n", status, status2); + } + } + } + AST_RWLIST_UNLOCK(&databases); + + if (!found) { + ast_cli(a->fd, "No connections configured.\n"); + } + return CLI_SUCCESS; +} + +AST_MODULE_INFO(ASTERISK_GPL_KEY, AST_MODFLAG_DEFAULT, "MySQL RealTime Configuration Driver", + .load = load_module, + .unload = unload_module, + .reload = reload, + ); + diff --git a/autoconf/ast_ext_tool_check.m4 b/autoconf/ast_ext_tool_check.m4 index 22ea17b90..8cd30407f 100644 --- a/autoconf/ast_ext_tool_check.m4 +++ b/autoconf/ast_ext_tool_check.m4 @@ -7,7 +7,7 @@ AC_DEFUN([AST_EXT_TOOL_CHECK], [ if test "x${PBX_$1}" != "x1" -a "${USE_$1}" != "no"; then PBX_$1=0 - AC_CHECK_TOOL(CONFIG_$1, $2-config, No) + AC_CHECK_TOOL(CONFIG_$1, $2, No) if test ! "x${CONFIG_$1}" = xNo; then if test x"$3" = x ; then A=--cflags ; else A="$3" ; fi $1_INCLUDE=$(${CONFIG_$1} $A) diff --git a/build_tools/menuselect-deps.in b/build_tools/menuselect-deps.in index 2c0b2f9a3..d0d8655fe 100644 --- a/build_tools/menuselect-deps.in +++ b/build_tools/menuselect-deps.in @@ -1,4 +1,5 @@ ALSA=@PBX_ALSA@ +BLUETOOTH=@PBX_BLUETOOTH@ CRYPTO=@PBX_CRYPTO@ CURL=@PBX_CURL@ DAHDI=@PBX_DAHDI@ @@ -24,6 +25,7 @@ LIBXML2=@PBX_LIBXML2@ LTDL=@PBX_LTDL@ LUA=@PBX_LUA@ MISDN=@PBX_MISDN@ +MYSQLCLIENT=@PBX_MYSQLCLIENT@ NBS=@PBX_NBS@ NETSNMP=@PBX_NETSNMP@ NEWT=@PBX_NEWT@ diff --git a/configs/cdr_mysql.conf.sample b/configs/cdr_mysql.conf.sample new file mode 100644 index 000000000..c0c4a5fc4 --- /dev/null +++ b/configs/cdr_mysql.conf.sample @@ -0,0 +1,58 @@ +; +; Note - if the database server is hosted on the same machine as the +; asterisk server, you can achieve a local Unix socket connection by +; setting hostname=localhost +; +; port and sock are both optional parameters. If hostname is specified +; and is not "localhost" (you can use address 127.0.0.1 instead), then +; cdr_mysql will attempt to connect to the port specified or use the +; default port. If hostname is not specified or if hostname is +; "localhost", then cdr_mysql will attempt to connect to the socket file +; specified by sock or otherwise use the default socket file. +; +;[global] +;hostname=database.host.name +;dbname=asteriskcdrdb +;table=cdr +;password=password +;user=asteriskcdruser +;port=3306 +;sock=/tmp/mysql.sock +; +; If your system's locale differs from mysql database character set, +; cdr_mysql can damage non-latin characters in CDR variables. Use this +; option to protect your data. +;charset=koi8r +; +; Older versions of cdr_mysql set the calldate field to whenever the +; record was posted, rather than the start date of the call. This flag +; reverts to the old (incorrect) behavior. Note that you'll also need +; to comment out the "start=calldate" alias, below, to use this. +;compat=no +; +; ssl connections (optional) +;ssl_ca= +;ssl_cert= +;ssl_key= +; +; You may also configure the field names used in the CDR table. +; +[columns] +;static "" => +;alias => +alias start => calldate +alias callerid => clid +;alias src => src +;alias dst => dst +;alias dcontext => dcontext +;alias channel => channel +;alias dstchannel => dstchannel +;alias lastapp => lastapp +;alias lastdata => lastdata +;alias duration => duration +;alias billsec => billsec +;alias disposition => disposition +;alias amaflags => amaflags +;alias accountcode => accountcode +;alias userfield => userfield +;alias uniqueid => uniqueid diff --git a/configs/mobile.conf.sample b/configs/mobile.conf.sample new file mode 100644 index 000000000..7555a17e5 --- /dev/null +++ b/configs/mobile.conf.sample @@ -0,0 +1,68 @@ +; +; mobile.conf +; configuration file for chan_mobile +; + +[general] +interval=30 ; Number of seconds between trying to connect to devices. + +; The following is a list of adapters we use. +; id must be unique and address is the bdaddr of the adapter from hciconfig. +; Each adapter may only have one device (headset or phone) connected at a time. +; Add an [adapter] entry for each adapter you have. + +[adapter] +id=blue +address=00:09:DD:60:01:A3 +;forcemaster=yes ; attempt to force adapter into master mode. default is no. +;alignmentdetection=yes ; enable this if you sometimes get 'white noise' on asterisk side of the call + ; its a bug in the bluetooth adapter firmware, enabling this will compensate for it. + ; default is no. + +[adapter] +id=dlink +address=00:80:C8:35:52:78 + +; The following is a list of the devices we deal with. +; Every device listed below will be available for calls in and out of Asterisk. +; Each device needs an adapter=xxxx entry which determines which bluetooth adapter is used. +; Use the CLI command 'mobile search' to discover devices. +; Use the CLI command 'mobile show devices' to see device status. +; +; To place a call out through a mobile phone use Dial(Mobile/[device]/NNN.....) or Dial(Mobile/gn/NNN......) in your dialplan. +; To call a headset use Dial(Mobile/[device]). + +[LGTU550] +address=00:E0:91:7F:46:44 ; the address of the phone +port=4 ; the rfcomm port number (from mobile search) +context=incoming-mobile ; dialplan context for incoming calls +adapter=dlink ; adapter to use +group=1 ; this phone is in channel group 1 +;nocallsetup=yes ; set this only if your phone reports that it supports call progress notification, but does not do it. Motorola L6 for example. + +[blackberry] +address=00:60:57:32:7E:B2 +port=2 +context=incoming-mobile +adapter=dlink +group=1 +;blackberry=yes ; set this if you are using a blackberry device + +[6310i] +address=00:60:57:32:7E:B1 +port=13 +context=incoming-mobile +adapter=dlink +group=1 ; this phone is in channel group 1 also. + +[headset] +address=00:0B:9E:11:AE:C6 +port=1 +type=headset ; This is a headset, not a Phone ! +adapter=blue + +[headset1] +address=00:0B:9E:11:74:A5 +port=1 +type=headset +adapter=dlink diff --git a/configs/mysql.conf.sample b/configs/mysql.conf.sample new file mode 100644 index 000000000..fafd4f7a2 --- /dev/null +++ b/configs/mysql.conf.sample @@ -0,0 +1,24 @@ +; Configuration file for the MYSQL app addon + +[general] +; +; Nullvalue governs how NULL values are returned from the database. In +; previous versions, the special NULL value was returned as the "NULL" +; string. We now provide an option for the behavior, configured globally. +; nullstring - the string "NULL" +; emptystring - the string "" +; null - unset the variable +; +; WARNING: setting nullvalue=null may have undesireable consequences, in +; particular if you use subroutines in AEL or the LOCAL() variable construct. +; You have been warned. Don't complain if you use that setting in combination +; with Gosub or AEL and get buggy behavior. +; +nullvalue = nullstring + +; If set, autoclear will destroy allocated statement and connection resources +; when the channel ends. For most usage of the MYSQL app, this is what you +; want, but it's conceivable that somebody is sharing MYSQL connections across +; multiple channels, in which case, this should be set to 'no'. Defaults to +; 'no', as this was the original behavior. +autoclear=yes diff --git a/configs/ooh323.conf.sample b/configs/ooh323.conf.sample new file mode 100644 index 000000000..6d14bcbc5 --- /dev/null +++ b/configs/ooh323.conf.sample @@ -0,0 +1,173 @@ +; --------------------------------------------------------------------------------- +; --- ******* IMPORTANT NOTE *********** +; --- +; --- This module is currently unsupported. Use it at your own risk. +; --- +; --------------------------------------------------------------------------------- + +; Objective System's H323 Configuration example for Asterisk +; ooh323c driver configuration +; +; [general] section defines global parameters +; +; This is followed by profiles which can be of three types - user/peer/friend +; Name of the user profile should match with the h323id of the user device. +; For peer/friend profiles, host ip address must be provided as "dynamic" is +; not supported as of now. +; +; Syntax for specifying a H323 device in extensions.conf is +; For Registered peers/friends profiles: +; OOH323/name where name is the name of the peer/friend profile. +; +; For unregistered H.323 phones: +; OOH323/ip[:port] OR if gk is used OOH323/alias where alias can be any H323 +; alias +; +; For dialing into another asterisk peer at a specific exten +; OOH323/exten/peer OR OOH323/exten@ip +; +; Domain name resolution is not yet supported. +; +; When a H.323 user calls into asterisk, his H323ID is matched with the profile +; name and context is determined to route the call +; +; The channel driver will register all global aliases and aliases defined in +; peer profiles with the gatekeeper, if one exists. So, that when someone +; outside our pbx (non-user) calls an extension, gatekeeper will route that +; call to our asterisk box, from where it will be routed as per dial plan. + + +[general] +;Define the asetrisk server h323 endpoint + +;The port asterisk should listen for incoming H323 connections. +;Default - 1720 +;port=1720 + +;The dotted IP address asterisk should listen on for incoming H323 +;connections +;Default - tries to find out local ip address on it's own +bindaddr=0.0.0.0 + +;This parameter indicates whether channel driver should register with +;gatekeeper as a gateway or an endpoint. +;Default - no +;gateway=no + +;Whether asterisk should use fast-start and tunneling for H323 connections. +;Default - yes +;faststart=no +;h245tunneling=no + +;Whether media wait for connect +;Default - No +;mediawaitforconnect=yes + +;H323-ID to be used for asterisk server +;Default - Asterisk PBX +h323id=ObjSysAsterisk +e164=100 + +;CallerID to use for calls +;Default - Same as h323id +callerid=asterisk + +;Whether this asterisk server will use gatekeeper. +;Default - DISABLE +;gatekeeper = DISCOVER +;gatekeeper = a.b.c.d +gatekeeper = DISABLE + +;Location for H323 log file +;Default - /var/log/asterisk/h323_log +;logfile=/var/log/asterisk/h323_log + + +;Following values apply to all users/peers/friends defined below, unless +;overridden within their client definition + +;Sets default context all clients will be placed in. +;Default - default +context=default + +;Sets rtptimeout for all clients, unless overridden +;Default - 60 seconds +;rtptimeout=60 ; Terminate call if 60 seconds of no RTP activity + ; when we're not on hold + +;Type of Service +;Default - none (lowdelay, thoughput, reliability, mincost, none) +;tos=lowdelay + +;amaflags = default + +;The account code used by default for all clients. +;accountcode=h3230101 + +;The codecs to be used for all clients.Only ulaw and gsm supported as of now. +;Default - ulaw +; ONLY ulaw, gsm, g729 and g7231 supported as of now +disallow=all ;Note order of disallow/allow is important. +allow=gsm +allow=ulaw + + +; dtmf mode to be used by default for all clients. Supports rfc2833, q931keypad +; h245alphanumeric, h245signal. +;Default - rfc 2833 +dtmfmode=rfc2833 + +; User/peer/friend definitions: +; User config options Peer config options +; ------------------ ------------------- +; context +; disallow disallow +; allow allow +; accountcode accountcode +; amaflags amaflags +; dtmfmode dtmfmode +; rtptimeout ip +; port +; h323id +; email +; url +; e164 +; rtptimeout + +; + +;Define users here +;Section header is extension +[myuser1] +type=user +context=context1 +disallow=all +allow=gsm +allow=ulaw + + + +[mypeer1] +type=peer +context=context2 +ip=a.b.c.d ; UPDATE with appropriate ip address +port=1720 ; UPDATE with appropriate port +e164=101 + + + +[myfriend1] +type=friend +context=default +ip=10.0.0.82 ; UPDATE with appropriate ip address +port=1820 ; UPDATE with appropriate port +disallow=all +allow=ulaw +e164=12345 +rtptimeout=60 +dtmfmode=rfc2833 + + + + + diff --git a/configs/res_mysql.conf.sample b/configs/res_mysql.conf.sample new file mode 100644 index 000000000..dfbbf49a8 --- /dev/null +++ b/configs/res_mysql.conf.sample @@ -0,0 +1,40 @@ +; +; Sample configuration for res_config_mysql.c +; +; The value of dbhost may be either a hostname or an IP address. +; If dbhost is commented out or the string "localhost", a connection +; to the local host is assumed and dbsock is used instead of TCP/IP +; to connect to the server. +; +; Multiple database contexts may be configured, with the caveat that +; all context names should be unique and must not contain the slash ('/') +; character. If you wish to separate reads from writes in your database +; configuration, you specify the database (NOT HERE, in other files) +; separated by a slash, read database first. If your database +; specification does not contain a slash, the implication is that reads +; and writes should be performed to the same database. +; +; For example, in extconfig.conf, you could specify a line like: +; sippeers => mysql,readhost.asterisk/writehost.asterisk,sipfriends +; and then define the contexts [readhost.asterisk] and [writehost.asterisk] +; below. +; +; The requirements parameter is available only in Asterisk 1.6.1 and +; later and must be present in all contexts. It specifies the behavior +; when a column name is required by the system. The default behavior is +; "warn" and simply sends a warning to the logger that the column does +; not exist (or is of the wrong type or precision). The other two +; possibilities are "createclose", which adds the column with the right +; type and length, and "createchar", which adds the column as a char +; type, with the appropriate length to accept the data. Note that with +; the MySQL driver, both "createclose" and "createchar" will, on occasion, +; widen a table column width to meet the requirements specified. +; +[general] +;dbhost = 127.0.0.1 +;dbname = asterisk +;dbuser = myuser +;dbpass = mypass +;dbport = 3306 +;dbsock = /tmp/mysql.sock +;requirements=warn ; or createclose or createchar diff --git a/configure b/configure index 37be13d34..0a6824649 100755 --- a/configure +++ b/configure @@ -1,5 +1,5 @@ #! /bin/sh -# From configure.ac Revision: 203569 . +# From configure.ac Revision: 204392 . # Guess values for system-dependent variables and create Makefiles. # Generated by GNU Autoconf 2.61 for asterisk 1.6. # @@ -731,6 +731,10 @@ BKTR_LIB BKTR_INCLUDE BKTR_DIR PBX_BKTR +BLUETOOTH_LIB +BLUETOOTH_INCLUDE +BLUETOOTH_DIR +PBX_BLUETOOTH CAP_LIB CAP_INCLUDE CAP_DIR @@ -827,6 +831,10 @@ MISDN_LIB MISDN_INCLUDE MISDN_DIR PBX_MISDN +MYSQLCLIENT_LIB +MYSQLCLIENT_INCLUDE +MYSQLCLIENT_DIR +PBX_MYSQLCLIENT NBS_LIB NBS_INCLUDE NBS_DIR @@ -1008,6 +1016,7 @@ GSM_INTERNAL CONFIG_LIBXML2 PBX_MISDN_FAC_RESULT PBX_MISDN_FAC_ERROR +CONFIG_MYSQLCLIENT CONFIG_NEON CONFIG_NETSNMP PG_CONFIG @@ -1647,6 +1656,7 @@ Optional Packages: --with-gnu-ld assume the C compiler uses GNU ld [default=no] --with-asound=PATH use Advanced Linux Sound Architecture files in PATH --with-execinfo=PATH use Stack Backtrace support files in PATH + --with-bluetooth=PATH use Bluetooth Support files in PATH --with-cap=PATH use POSIX 1.e capabilities files in PATH --with-curl=PATH use cURL files in PATH --with-curses=PATH use curses files in PATH @@ -1672,6 +1682,7 @@ Optional Packages: --with-ltdl=PATH use libtool files in PATH --with-lua=PATH use Lua files in PATH --with-misdn=PATH use mISDN User Library files in PATH + --with-mysqlclient=PATH use mysqlclient files in PATH --with-nbs=PATH use Network Broadcast Sound files in PATH --with-ncurses=PATH use ncurses files in PATH --with-neon=PATH use neon files in PATH @@ -8187,6 +8198,37 @@ fi + BLUETOOTH_DESCRIP="Bluetooth Support" + BLUETOOTH_OPTION="bluetooth" + PBX_BLUETOOTH=0 + +# Check whether --with-bluetooth was given. +if test "${with_bluetooth+set}" = set; then + withval=$with_bluetooth; + case ${withval} in + n|no) + USE_BLUETOOTH=no + # -1 is a magic value used by menuselect to know that the package + # was disabled, other than 'not found' + PBX_BLUETOOTH=-1 + ;; + y|ye|yes) + ac_mandatory_list="${ac_mandatory_list} BLUETOOTH" + ;; + *) + BLUETOOTH_DIR="${withval}" + ac_mandatory_list="${ac_mandatory_list} BLUETOOTH" + ;; + esac + +fi + + + + + + + CAP_DESCRIP="POSIX 1.e capabilities" CAP_OPTION="cap" PBX_CAP=0 @@ -8931,6 +8973,37 @@ fi + MYSQLCLIENT_DESCRIP="mysqlclient" + MYSQLCLIENT_OPTION="mysqlclient" + PBX_MYSQLCLIENT=0 + +# Check whether --with-mysqlclient was given. +if test "${with_mysqlclient+set}" = set; then + withval=$with_mysqlclient; + case ${withval} in + n|no) + USE_MYSQLCLIENT=no + # -1 is a magic value used by menuselect to know that the package + # was disabled, other than 'not found' + PBX_MYSQLCLIENT=-1 + ;; + y|ye|yes) + ac_mandatory_list="${ac_mandatory_list} MYSQLCLIENT" + ;; + *) + MYSQLCLIENT_DIR="${withval}" + ac_mandatory_list="${ac_mandatory_list} MYSQLCLIENT" + ;; + esac + +fi + + + + + + + NBS_DESCRIP="Network Broadcast Sound" NBS_OPTION="nbs" PBX_NBS=0 @@ -38129,6 +38202,185 @@ fi fi + if test "x${PBX_MYSQLCLIENT}" != "x1" -a "${USE_MYSQLCLIENT}" != "no"; then + PBX_MYSQLCLIENT=0 + if test -n "$ac_tool_prefix"; then + # Extract the first word of "${ac_tool_prefix}mysql_config", so it can be a program name with args. +set dummy ${ac_tool_prefix}mysql_config; ac_word=$2 +{ echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } +if test "${ac_cv_prog_CONFIG_MYSQLCLIENT+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$CONFIG_MYSQLCLIENT"; then + ac_cv_prog_CONFIG_MYSQLCLIENT="$CONFIG_MYSQLCLIENT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_CONFIG_MYSQLCLIENT="${ac_tool_prefix}mysql_config" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done +IFS=$as_save_IFS + +fi +fi +CONFIG_MYSQLCLIENT=$ac_cv_prog_CONFIG_MYSQLCLIENT +if test -n "$CONFIG_MYSQLCLIENT"; then + { echo "$as_me:$LINENO: result: $CONFIG_MYSQLCLIENT" >&5 +echo "${ECHO_T}$CONFIG_MYSQLCLIENT" >&6; } +else + { echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6; } +fi + + +fi +if test -z "$ac_cv_prog_CONFIG_MYSQLCLIENT"; then + ac_ct_CONFIG_MYSQLCLIENT=$CONFIG_MYSQLCLIENT + # Extract the first word of "mysql_config", so it can be a program name with args. +set dummy mysql_config; ac_word=$2 +{ echo "$as_me:$LINENO: checking for $ac_word" >&5 +echo $ECHO_N "checking for $ac_word... $ECHO_C" >&6; } +if test "${ac_cv_prog_ac_ct_CONFIG_MYSQLCLIENT+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + if test -n "$ac_ct_CONFIG_MYSQLCLIENT"; then + ac_cv_prog_ac_ct_CONFIG_MYSQLCLIENT="$ac_ct_CONFIG_MYSQLCLIENT" # Let the user override the test. +else +as_save_IFS=$IFS; IFS=$PATH_SEPARATOR +for as_dir in $PATH +do + IFS=$as_save_IFS + test -z "$as_dir" && as_dir=. + for ac_exec_ext in '' $ac_executable_extensions; do + if { test -f "$as_dir/$ac_word$ac_exec_ext" && $as_test_x "$as_dir/$ac_word$ac_exec_ext"; }; then + ac_cv_prog_ac_ct_CONFIG_MYSQLCLIENT="mysql_config" + echo "$as_me:$LINENO: found $as_dir/$ac_word$ac_exec_ext" >&5 + break 2 + fi +done +done +IFS=$as_save_IFS + +fi +fi +ac_ct_CONFIG_MYSQLCLIENT=$ac_cv_prog_ac_ct_CONFIG_MYSQLCLIENT +if test -n "$ac_ct_CONFIG_MYSQLCLIENT"; then + { echo "$as_me:$LINENO: result: $ac_ct_CONFIG_MYSQLCLIENT" >&5 +echo "${ECHO_T}$ac_ct_CONFIG_MYSQLCLIENT" >&6; } +else + { echo "$as_me:$LINENO: result: no" >&5 +echo "${ECHO_T}no" >&6; } +fi + + if test "x$ac_ct_CONFIG_MYSQLCLIENT" = x; then + CONFIG_MYSQLCLIENT="No" + else + case $cross_compiling:$ac_tool_warned in +yes:) +{ echo "$as_me:$LINENO: WARNING: In the future, Autoconf will not detect cross-tools +whose name does not start with the host triplet. If you think this +configuration is useful to you, please write to autoconf@gnu.org." >&5 +echo "$as_me: WARNING: In the future, Autoconf will not detect cross-tools +whose name does not start with the host triplet. If you think this +configuration is useful to you, please write to autoconf@gnu.org." >&2;} +ac_tool_warned=yes ;; +esac + CONFIG_MYSQLCLIENT=$ac_ct_CONFIG_MYSQLCLIENT + fi +else + CONFIG_MYSQLCLIENT="$ac_cv_prog_CONFIG_MYSQLCLIENT" +fi + + if test ! "x${CONFIG_MYSQLCLIENT}" = xNo; then + if test x"" = x ; then A=--cflags ; else A="" ; fi + MYSQLCLIENT_INCLUDE=$(${CONFIG_MYSQLCLIENT} $A) + if test x"" = x ; then A=--libs ; else A="" ; fi + MYSQLCLIENT_LIB=$(${CONFIG_MYSQLCLIENT} $A) + if test x"" != x ; then + saved_cppflags="${CPPFLAGS}" + if test "x${MYSQLCLIENT_DIR}" != "x"; then + MYSQLCLIENT_INCLUDE="-I${MYSQLCLIENT_DIR}/include" + fi + CPPFLAGS="${CPPFLAGS} ${MYSQLCLIENT_INCLUDE}" + + saved_libs="${LIBS}" + LIBS="${MYSQLCLIENT_LIB}" + + cat >conftest.$ac_ext <<_ACEOF + /* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +int +main () +{ + ; + + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_link") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && + $as_test_x conftest$ac_exeext; then + PBX_MYSQLCLIENT=1 + +cat >>confdefs.h <<\_ACEOF +#define HAVE_MYSQLCLIENT 1 +_ACEOF + + +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + + +fi + +rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ + conftest$ac_exeext conftest.$ac_ext + CPPFLAGS="${saved_cppflags}" + LIBS="${saved_libs}" + else + PBX_MYSQLCLIENT=1 + +cat >>confdefs.h <<\_ACEOF +#define HAVE_MYSQLCLIENT 1 +_ACEOF + + fi + fi + fi + + + if test "x${PBX_NBS}" != "x1" -a "${USE_NBS}" != "no"; then pbxlibdir="" # if --with-NBS=DIR has been specified, use it. @@ -40325,6 +40577,268 @@ _ACEOF fi + +if test "x${PBX_BLUETOOTH}" != "x1" -a "${USE_BLUETOOTH}" != "no"; then + pbxlibdir="" + # if --with-BLUETOOTH=DIR has been specified, use it. + if test "x${BLUETOOTH_DIR}" != "x"; then + if test -d ${BLUETOOTH_DIR}/lib; then + pbxlibdir="-L${BLUETOOTH_DIR}/lib" + else + pbxlibdir="-L${BLUETOOTH_DIR}" + fi + fi + pbxfuncname="ba2str" + if test "x${pbxfuncname}" = "x" ; then # empty lib, assume only headers + AST_BLUETOOTH_FOUND=yes + else + as_ac_Lib=`echo "ac_cv_lib_bluetooth_${pbxfuncname}" | $as_tr_sh` +{ echo "$as_me:$LINENO: checking for ${pbxfuncname} in -lbluetooth" >&5 +echo $ECHO_N "checking for ${pbxfuncname} in -lbluetooth... $ECHO_C" >&6; } +if { as_var=$as_ac_Lib; eval "test \"\${$as_var+set}\" = set"; }; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_check_lib_save_LIBS=$LIBS +LIBS="-lbluetooth ${pbxlibdir} $LIBS" +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ + +/* Override any GCC internal prototype to avoid an error. + Use char because int might match the return type of a GCC + builtin and then its argument prototype would still apply. */ +#ifdef __cplusplus +extern "C" +#endif +char ${pbxfuncname} (); +int +main () +{ +return ${pbxfuncname} (); + ; + return 0; +} +_ACEOF +rm -f conftest.$ac_objext conftest$ac_exeext +if { (ac_try="$ac_link" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_link") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest$ac_exeext && + $as_test_x conftest$ac_exeext; then + eval "$as_ac_Lib=yes" +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + eval "$as_ac_Lib=no" +fi + +rm -f core conftest.err conftest.$ac_objext conftest_ipa8_conftest.oo \ + conftest$ac_exeext conftest.$ac_ext +LIBS=$ac_check_lib_save_LIBS +fi +ac_res=`eval echo '${'$as_ac_Lib'}'` + { echo "$as_me:$LINENO: result: $ac_res" >&5 +echo "${ECHO_T}$ac_res" >&6; } +if test `eval echo '${'$as_ac_Lib'}'` = yes; then + AST_BLUETOOTH_FOUND=yes +else + AST_BLUETOOTH_FOUND=no +fi + + fi + + # now check for the header. + if test "${AST_BLUETOOTH_FOUND}" = "yes"; then + BLUETOOTH_LIB="${pbxlibdir} -lbluetooth " + # if --with-BLUETOOTH=DIR has been specified, use it. + if test "x${BLUETOOTH_DIR}" != "x"; then + BLUETOOTH_INCLUDE="-I${BLUETOOTH_DIR}/include" + fi + BLUETOOTH_INCLUDE="${BLUETOOTH_INCLUDE} " + if test "xbluetooth/bluetooth.h" = "x" ; then # no header, assume found + BLUETOOTH_HEADER_FOUND="1" + else # check for the header + saved_cppflags="${CPPFLAGS}" + CPPFLAGS="${CPPFLAGS} ${BLUETOOTH_INCLUDE}" + if test "${ac_cv_header_bluetooth_bluetooth_h+set}" = set; then + { echo "$as_me:$LINENO: checking for bluetooth/bluetooth.h" >&5 +echo $ECHO_N "checking for bluetooth/bluetooth.h... $ECHO_C" >&6; } +if test "${ac_cv_header_bluetooth_bluetooth_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +fi +{ echo "$as_me:$LINENO: result: $ac_cv_header_bluetooth_bluetooth_h" >&5 +echo "${ECHO_T}$ac_cv_header_bluetooth_bluetooth_h" >&6; } +else + # Is the header compilable? +{ echo "$as_me:$LINENO: checking bluetooth/bluetooth.h usability" >&5 +echo $ECHO_N "checking bluetooth/bluetooth.h usability... $ECHO_C" >&6; } +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +$ac_includes_default +#include +_ACEOF +rm -f conftest.$ac_objext +if { (ac_try="$ac_compile" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_compile") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } && { + test -z "$ac_c_werror_flag" || + test ! -s conftest.err + } && test -s conftest.$ac_objext; then + ac_header_compiler=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_compiler=no +fi + +rm -f core conftest.err conftest.$ac_objext conftest.$ac_ext +{ echo "$as_me:$LINENO: result: $ac_header_compiler" >&5 +echo "${ECHO_T}$ac_header_compiler" >&6; } + +# Is the header present? +{ echo "$as_me:$LINENO: checking bluetooth/bluetooth.h presence" >&5 +echo $ECHO_N "checking bluetooth/bluetooth.h presence... $ECHO_C" >&6; } +cat >conftest.$ac_ext <<_ACEOF +/* confdefs.h. */ +_ACEOF +cat confdefs.h >>conftest.$ac_ext +cat >>conftest.$ac_ext <<_ACEOF +/* end confdefs.h. */ +#include +_ACEOF +if { (ac_try="$ac_cpp conftest.$ac_ext" +case "(($ac_try" in + *\"* | *\`* | *\\*) ac_try_echo=\$ac_try;; + *) ac_try_echo=$ac_try;; +esac +eval "echo \"\$as_me:$LINENO: $ac_try_echo\"") >&5 + (eval "$ac_cpp conftest.$ac_ext") 2>conftest.er1 + ac_status=$? + grep -v '^ *+' conftest.er1 >conftest.err + rm -f conftest.er1 + cat conftest.err >&5 + echo "$as_me:$LINENO: \$? = $ac_status" >&5 + (exit $ac_status); } >/dev/null && { + test -z "$ac_c_preproc_warn_flag$ac_c_werror_flag" || + test ! -s conftest.err + }; then + ac_header_preproc=yes +else + echo "$as_me: failed program was:" >&5 +sed 's/^/| /' conftest.$ac_ext >&5 + + ac_header_preproc=no +fi + +rm -f conftest.err conftest.$ac_ext +{ echo "$as_me:$LINENO: result: $ac_header_preproc" >&5 +echo "${ECHO_T}$ac_header_preproc" >&6; } + +# So? What about this header? +case $ac_header_compiler:$ac_header_preproc:$ac_c_preproc_warn_flag in + yes:no: ) + { echo "$as_me:$LINENO: WARNING: bluetooth/bluetooth.h: accepted by the compiler, rejected by the preprocessor!" >&5 +echo "$as_me: WARNING: bluetooth/bluetooth.h: accepted by the compiler, rejected by the preprocessor!" >&2;} + { echo "$as_me:$LINENO: WARNING: bluetooth/bluetooth.h: proceeding with the compiler's result" >&5 +echo "$as_me: WARNING: bluetooth/bluetooth.h: proceeding with the compiler's result" >&2;} + ac_header_preproc=yes + ;; + no:yes:* ) + { echo "$as_me:$LINENO: WARNING: bluetooth/bluetooth.h: present but cannot be compiled" >&5 +echo "$as_me: WARNING: bluetooth/bluetooth.h: present but cannot be compiled" >&2;} + { echo "$as_me:$LINENO: WARNING: bluetooth/bluetooth.h: check for missing prerequisite headers?" >&5 +echo "$as_me: WARNING: bluetooth/bluetooth.h: check for missing prerequisite headers?" >&2;} + { echo "$as_me:$LINENO: WARNING: bluetooth/bluetooth.h: see the Autoconf documentation" >&5 +echo "$as_me: WARNING: bluetooth/bluetooth.h: see the Autoconf documentation" >&2;} + { echo "$as_me:$LINENO: WARNING: bluetooth/bluetooth.h: section \"Present But Cannot Be Compiled\"" >&5 +echo "$as_me: WARNING: bluetooth/bluetooth.h: section \"Present But Cannot Be Compiled\"" >&2;} + { echo "$as_me:$LINENO: WARNING: bluetooth/bluetooth.h: proceeding with the preprocessor's result" >&5 +echo "$as_me: WARNING: bluetooth/bluetooth.h: proceeding with the preprocessor's result" >&2;} + { echo "$as_me:$LINENO: WARNING: bluetooth/bluetooth.h: in the future, the compiler will take precedence" >&5 +echo "$as_me: WARNING: bluetooth/bluetooth.h: in the future, the compiler will take precedence" >&2;} + ( cat <<\_ASBOX +## ------------------------------- ## +## Report this to www.asterisk.org ## +## ------------------------------- ## +_ASBOX + ) | sed "s/^/$as_me: WARNING: /" >&2 + ;; +esac +{ echo "$as_me:$LINENO: checking for bluetooth/bluetooth.h" >&5 +echo $ECHO_N "checking for bluetooth/bluetooth.h... $ECHO_C" >&6; } +if test "${ac_cv_header_bluetooth_bluetooth_h+set}" = set; then + echo $ECHO_N "(cached) $ECHO_C" >&6 +else + ac_cv_header_bluetooth_bluetooth_h=$ac_header_preproc +fi +{ echo "$as_me:$LINENO: result: $ac_cv_header_bluetooth_bluetooth_h" >&5 +echo "${ECHO_T}$ac_cv_header_bluetooth_bluetooth_h" >&6; } + +fi +if test $ac_cv_header_bluetooth_bluetooth_h = yes; then + BLUETOOTH_HEADER_FOUND=1 +else + BLUETOOTH_HEADER_FOUND=0 +fi + + + CPPFLAGS="${saved_cppflags}" + fi + if test "x${BLUETOOTH_HEADER_FOUND}" = "x0" ; then + BLUETOOTH_LIB="" + BLUETOOTH_INCLUDE="" + else + if test "x${pbxfuncname}" = "x" ; then # only checking headers -> no library + BLUETOOTH_LIB="" + fi + PBX_BLUETOOTH=1 + # XXX don't know how to evaluate the description (third argument) in AC_DEFINE_UNQUOTED + +cat >>confdefs.h <<_ACEOF +#define HAVE_BLUETOOTH 1 +_ACEOF + + +cat >>confdefs.h <<_ACEOF +#define HAVE_BLUETOOTH_VERSION +_ACEOF + + fi + fi +fi + + # possible places for oss definitions if test "x${PBX_OSS}" != "x1" -a "${USE_OSS}" != "no"; then @@ -56160,6 +56674,10 @@ BKTR_LIB!$BKTR_LIB$ac_delim BKTR_INCLUDE!$BKTR_INCLUDE$ac_delim BKTR_DIR!$BKTR_DIR$ac_delim PBX_BKTR!$PBX_BKTR$ac_delim +BLUETOOTH_LIB!$BLUETOOTH_LIB$ac_delim +BLUETOOTH_INCLUDE!$BLUETOOTH_INCLUDE$ac_delim +BLUETOOTH_DIR!$BLUETOOTH_DIR$ac_delim +PBX_BLUETOOTH!$PBX_BLUETOOTH$ac_delim CAP_LIB!$CAP_LIB$ac_delim CAP_INCLUDE!$CAP_INCLUDE$ac_delim CAP_DIR!$CAP_DIR$ac_delim @@ -56238,10 +56756,6 @@ JACK_DIR!$JACK_DIR$ac_delim PBX_JACK!$PBX_JACK$ac_delim LDAP_LIB!$LDAP_LIB$ac_delim LDAP_INCLUDE!$LDAP_INCLUDE$ac_delim -LDAP_DIR!$LDAP_DIR$ac_delim -PBX_LDAP!$PBX_LDAP$ac_delim -LIBXML2_LIB!$LIBXML2_LIB$ac_delim -LIBXML2_INCLUDE!$LIBXML2_INCLUDE$ac_delim _ACEOF if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then @@ -56283,6 +56797,10 @@ _ACEOF ac_delim='%!_!# ' for ac_last_try in false false false false false :; do cat >conf$$subs.sed <<_ACEOF +LDAP_DIR!$LDAP_DIR$ac_delim +PBX_LDAP!$PBX_LDAP$ac_delim +LIBXML2_LIB!$LIBXML2_LIB$ac_delim +LIBXML2_INCLUDE!$LIBXML2_INCLUDE$ac_delim LIBXML2_DIR!$LIBXML2_DIR$ac_delim PBX_LIBXML2!$PBX_LIBXML2$ac_delim LTDL_LIB!$LTDL_LIB$ac_delim @@ -56297,6 +56815,10 @@ MISDN_LIB!$MISDN_LIB$ac_delim MISDN_INCLUDE!$MISDN_INCLUDE$ac_delim MISDN_DIR!$MISDN_DIR$ac_delim PBX_MISDN!$PBX_MISDN$ac_delim +MYSQLCLIENT_LIB!$MYSQLCLIENT_LIB$ac_delim +MYSQLCLIENT_INCLUDE!$MYSQLCLIENT_INCLUDE$ac_delim +MYSQLCLIENT_DIR!$MYSQLCLIENT_DIR$ac_delim +PBX_MYSQLCLIENT!$PBX_MYSQLCLIENT$ac_delim NBS_LIB!$NBS_LIB$ac_delim NBS_INCLUDE!$NBS_INCLUDE$ac_delim NBS_DIR!$NBS_DIR$ac_delim @@ -56372,14 +56894,6 @@ PBX_OPENH323!$PBX_OPENH323$ac_delim RADIUS_LIB!$RADIUS_LIB$ac_delim RADIUS_INCLUDE!$RADIUS_INCLUDE$ac_delim RADIUS_DIR!$RADIUS_DIR$ac_delim -PBX_RADIUS!$PBX_RADIUS$ac_delim -SDL_LIB!$SDL_LIB$ac_delim -SDL_INCLUDE!$SDL_INCLUDE$ac_delim -SDL_DIR!$SDL_DIR$ac_delim -PBX_SDL!$PBX_SDL$ac_delim -SDL_IMAGE_LIB!$SDL_IMAGE_LIB$ac_delim -SDL_IMAGE_INCLUDE!$SDL_IMAGE_INCLUDE$ac_delim -SDL_IMAGE_DIR!$SDL_IMAGE_DIR$ac_delim _ACEOF if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then @@ -56421,6 +56935,14 @@ _ACEOF ac_delim='%!_!# ' for ac_last_try in false false false false false :; do cat >conf$$subs.sed <<_ACEOF +PBX_RADIUS!$PBX_RADIUS$ac_delim +SDL_LIB!$SDL_LIB$ac_delim +SDL_INCLUDE!$SDL_INCLUDE$ac_delim +SDL_DIR!$SDL_DIR$ac_delim +PBX_SDL!$PBX_SDL$ac_delim +SDL_IMAGE_LIB!$SDL_IMAGE_LIB$ac_delim +SDL_IMAGE_INCLUDE!$SDL_IMAGE_INCLUDE$ac_delim +SDL_IMAGE_DIR!$SDL_IMAGE_DIR$ac_delim PBX_SDL_IMAGE!$PBX_SDL_IMAGE$ac_delim OPENAIS_LIB!$OPENAIS_LIB$ac_delim OPENAIS_INCLUDE!$OPENAIS_INCLUDE$ac_delim @@ -56510,14 +57032,6 @@ GC_LDFLAGS!$GC_LDFLAGS$ac_delim AST_DECLARATION_AFTER_STATEMENT!$AST_DECLARATION_AFTER_STATEMENT$ac_delim AST_FORTIFY_SOURCE!$AST_FORTIFY_SOURCE$ac_delim AST_NO_STRICT_OVERFLOW!$AST_NO_STRICT_OVERFLOW$ac_delim -AST_SHADOW_WARNINGS!$AST_SHADOW_WARNINGS$ac_delim -PBX_GLOB_NOMAGIC!$PBX_GLOB_NOMAGIC$ac_delim -PBX_GLOB_BRACE!$PBX_GLOB_BRACE$ac_delim -PBX_IP_MTU_DISCOVER!$PBX_IP_MTU_DISCOVER$ac_delim -PBX_DAHDI_HALF_FULL!$PBX_DAHDI_HALF_FULL$ac_delim -GSM_INTERNAL!$GSM_INTERNAL$ac_delim -CONFIG_LIBXML2!$CONFIG_LIBXML2$ac_delim -PBX_MISDN_FAC_RESULT!$PBX_MISDN_FAC_RESULT$ac_delim _ACEOF if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 97; then @@ -56559,7 +57073,16 @@ _ACEOF ac_delim='%!_!# ' for ac_last_try in false false false false false :; do cat >conf$$subs.sed <<_ACEOF +AST_SHADOW_WARNINGS!$AST_SHADOW_WARNINGS$ac_delim +PBX_GLOB_NOMAGIC!$PBX_GLOB_NOMAGIC$ac_delim +PBX_GLOB_BRACE!$PBX_GLOB_BRACE$ac_delim +PBX_IP_MTU_DISCOVER!$PBX_IP_MTU_DISCOVER$ac_delim +PBX_DAHDI_HALF_FULL!$PBX_DAHDI_HALF_FULL$ac_delim +GSM_INTERNAL!$GSM_INTERNAL$ac_delim +CONFIG_LIBXML2!$CONFIG_LIBXML2$ac_delim +PBX_MISDN_FAC_RESULT!$PBX_MISDN_FAC_RESULT$ac_delim PBX_MISDN_FAC_ERROR!$PBX_MISDN_FAC_ERROR$ac_delim +CONFIG_MYSQLCLIENT!$CONFIG_MYSQLCLIENT$ac_delim CONFIG_NEON!$CONFIG_NEON$ac_delim CONFIG_NETSNMP!$CONFIG_NETSNMP$ac_delim PG_CONFIG!$PG_CONFIG$ac_delim @@ -56602,7 +57125,7 @@ PBX_SYSLOG!$PBX_SYSLOG$ac_delim LTLIBOBJS!$LTLIBOBJS$ac_delim _ACEOF - if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 41; then + if test `sed -n "s/.*$ac_delim\$/X/p" conf$$subs.sed | grep -c X` = 50; then break elif $ac_last_try; then { { echo "$as_me:$LINENO: error: could not make $CONFIG_STATUS" >&5 diff --git a/configure.ac b/configure.ac index 4ea4236a5..afc950431 100644 --- a/configure.ac +++ b/configure.ac @@ -233,6 +233,7 @@ AST_EXT_LIB_SETUP([ALSA], [Advanced Linux Sound Architecture], [asound]) # BKTR is used for backtrace support on platforms that do not # have it natively. AST_EXT_LIB_SETUP([BKTR], [Stack Backtrace support], [execinfo]) +AST_EXT_LIB_SETUP([BLUETOOTH], [Bluetooth Support], [bluetooth]) AST_EXT_LIB_SETUP([CAP], [POSIX 1.e capabilities], [cap]) AST_EXT_LIB_SETUP([CURL], [cURL], [curl]) AST_EXT_LIB_SETUP([CURSES], [curses], [curses]) @@ -257,6 +258,7 @@ AST_EXT_LIB_SETUP([LIBXML2], [LibXML2], [libxml2]) AST_EXT_LIB_SETUP([LTDL], [libtool], [ltdl]) AST_EXT_LIB_SETUP([LUA], [Lua], [lua]) AST_EXT_LIB_SETUP([MISDN], [mISDN User Library], [misdn]) +AST_EXT_LIB_SETUP([MYSQLCLIENT], [mysqlclient], [mysqlclient]) AST_EXT_LIB_SETUP([NBS], [Network Broadcast Sound], [nbs]) AST_EXT_LIB_SETUP([NCURSES], [ncurses], [ncurses]) AST_EXT_LIB_SETUP([NEON], [neon], [neon]) @@ -1327,7 +1329,7 @@ AC_ARG_ENABLE([xmldoc], esac], [disable_xmldoc=no]) if test "${disable_xmldoc}" != "yes"; then - AST_EXT_TOOL_CHECK([LIBXML2], [xml2], , , + AST_EXT_TOOL_CHECK([LIBXML2], [xml2-config], , , [#include #include ], [LIBXML_TEST_VERSION]) @@ -1349,13 +1351,15 @@ if test "${PBX_MISDN}" = 1; then AC_CHECK_HEADER([linux/mISDNdsp.h], [AC_DEFINE_UNQUOTED([MISDN_1_2], 1, [Build chan_misdn for mISDN 1.2 or later.])]) fi +AST_EXT_TOOL_CHECK([MYSQLCLIENT], [mysql_config]) + AST_EXT_LIB_CHECK([NBS], [nbs], [nbs_connect], [nbs.h]) AST_EXT_LIB_CHECK([NCURSES], [ncurses], [initscr], [curses.h]) -AST_EXT_TOOL_CHECK([NEON], [neon]) +AST_EXT_TOOL_CHECK([NEON], [neon-config]) -AST_EXT_TOOL_CHECK([NETSNMP], [net-snmp], , [--agent-libs], +AST_EXT_TOOL_CHECK([NETSNMP], [net-snmp-config], , [--agent-libs], [#include #include #include ], @@ -1372,6 +1376,8 @@ AST_EXT_LIB_CHECK([BKTR], [execinfo], [backtrace], [execinfo.h]) # Linux, however, has backtrace directly in glibc AST_EXT_LIB_CHECK([BKTR], [c], [backtrace], [execinfo.h]) +AST_EXT_LIB_CHECK([BLUETOOTH], [bluetooth], [ba2str], [bluetooth/bluetooth.h]) + # possible places for oss definitions AST_EXT_LIB_CHECK([OSS], [ossaudio], [], [linux/soundcard.h]) AST_EXT_LIB_CHECK([OSS], [ossaudio], [], [sys/soundcard.h]) @@ -1563,7 +1569,7 @@ then AST_CHECK_OSPTK([3], [5], [0]) fi -AST_EXT_TOOL_CHECK([GMIME], [gmime], [], [], [#include ], [gboolean q = g_mime_check_version(0,0,0);]) +AST_EXT_TOOL_CHECK([GMIME], [gmime-config], [], [], [#include ], [gboolean q = g_mime_check_version(0,0,0);]) AST_EXT_LIB_CHECK([HOARD], [hoard], [malloc], []) @@ -1664,7 +1670,7 @@ AC_CHECK_HEADER([linux/ixjuser.h], [PBX_IXJUSER=1], [PBX_IXJUSER=0], [ ]) AC_SUBST(PBX_IXJUSER) -AST_EXT_TOOL_CHECK([SDL], [sdl]) +AST_EXT_TOOL_CHECK([SDL], [sdl-config]) AST_EXT_LIB_CHECK([SDL_IMAGE], [SDL_image], [IMG_Load], [SDL_image.h], [${SDL_LIB}], [${SDL_INCLUDE}]) AST_EXT_LIB_CHECK([FFMPEG], [avcodec], [sws_getContext], [ffmpeg/avcodec.h], [-lpthread -lz -lm]) @@ -1682,7 +1688,7 @@ then fi PBX_GTK=0 -AST_EXT_TOOL_CHECK([GTK], [gtk], [--cflags gthread], [--libs gthread]) +AST_EXT_TOOL_CHECK([GTK], [gtk-config], [--cflags gthread], [--libs gthread]) PBX_GTK2=0 AC_CHECK_TOOL(PKGCONFIG, pkg-config, No) diff --git a/doc/tex/Makefile b/doc/tex/Makefile index cce8612fd..57edd8d17 100644 --- a/doc/tex/Makefile +++ b/doc/tex/Makefile @@ -26,7 +26,7 @@ endif @cp asterisk.tex asterisk.tex.orig @sed -e 's/ASTERISKVERSION/$(shell echo $(ASTERISKVERSION) | sed -e 's/\//\\\//g' | sed -e 's/_/\\\\_/g')/' asterisk.tex > asterisk_local.tex @mv asterisk_local.tex asterisk.tex - @$(RUBBER) --pdf asterisk.tex + -@$(RUBBER) --pdf asterisk.tex @mv asterisk.tex.orig asterisk.tex endif diff --git a/doc/tex/asterisk.tex b/doc/tex/asterisk.tex index e9c9b3275..3900f4cb6 100644 --- a/doc/tex/asterisk.tex +++ b/doc/tex/asterisk.tex @@ -32,7 +32,7 @@ \author{Asterisk Development Team \\ Asterisk.org} -\title{Asterisk Reference Information \\ Version ASTERISKVERSION} +\title{Asterisk Reference Information \\ ASTERISKVERSION} \begin{document} \maketitle @@ -99,6 +99,8 @@ reference purposes. \input{misdn.tex} \section{Local} \input{localchannel.tex} + \section{Mobile} + \input{chan_mobile.tex} \chapter{Distributed Universal Number Discovery (DUNDi)} \section{Introduction} diff --git a/doc/tex/cdrdriver.tex b/doc/tex/cdrdriver.tex index 3fe7e148b..9a9337d5f 100644 --- a/doc/tex/cdrdriver.tex +++ b/doc/tex/cdrdriver.tex @@ -197,8 +197,40 @@ \subsection{MySQL} +\subsubsection{ODBC} + Using MySQL for CDR records is supported by using ODBC and the cdr\_odbc module. +\subsubsection{Native} + +Alternatively, there is a native MySQL CDR module. + +To use it, configure the module in cdr\_mysql.conf. Create a table called cdr under the database name you will be using the following schema. + +\begin{astlisting} +\begin{verbatim} +CREATE TABLE cdr ( + calldate datetime NOT NULL default '0000-00-00 00:00:00', + clid varchar(80) NOT NULL default '', + src varchar(80) NOT NULL default '', + dst varchar(80) NOT NULL default '', + dcontext varchar(80) NOT NULL default '', + channel varchar(80) NOT NULL default '', + dstchannel varchar(80) NOT NULL default '', + lastapp varchar(80) NOT NULL default '', + lastdata varchar(80) NOT NULL default '', + duration int(11) NOT NULL default '0', + billsec int(11) NOT NULL default '0', + disposition varchar(45) NOT NULL default '', + amaflags int(11) NOT NULL default '0', + accountcode varchar(20) NOT NULL default '', + uniqueid varchar(32) NOT NULL default '', + userfield varchar(255) NOT NULL default '' +); +\end{verbatim} +\end{astlisting} + + \subsection{PostgreSQL} If you want to go directly to postgresql database, and have the cdr\_pgsql.so compiled you can use the following sample setup. diff --git a/doc/tex/chan_mobile.tex b/doc/tex/chan_mobile.tex new file mode 100644 index 000000000..09a95c75d --- /dev/null +++ b/doc/tex/chan_mobile.tex @@ -0,0 +1,262 @@ +\subsection{Introduction} + +Asterisk Channel Driver to allow Bluetooth Cell/Mobile Phones to be used as FXO devices, and Headsets as FXS devices. + + +\subsection{Features} + +\begin{itemize} +\item Multiple Bluetooth Adapters supported. +\item Multiple phones can be connected. +\item Multiple headsets can be connected. +\item Asterisk automatically connects to each configured mobile phone / headset when it comes in range. +\item CLI command to discover bluetooth devices. +\item Inbound calls on the mobile network to the mobile phones are handled by Asterisk, just like inbound calls on a Zap channel. +\item CLI passed through on inbound calls. +\item Dial outbound on a mobile phone using Dial(Mobile/device/nnnnnnn) in the dialplan. +\item Dial a headset using Dial(Mobile/device) in the dialplan. +\item Application MobileStatus can be used in the dialplan to see if a mobile phone / headset is connected. +\item Supports devicestate for dialplan hinting. +\item Supports Inbound and Outbound SMS. +\item Supports 'channel' groups for implementing 'GSM Gateways' +\end{itemize} + + +\subsection{Requirements} + +In order to use chan\_mobile, you must have a working bluetooth subsystem on your Asterisk box. +This means one or more working bluetooth adapters, and the BlueZ packages. + +Any bluetooth adapter supported by the Linux kernel will do, including usb bluetooth dongles. + +The BlueZ package you need is bluez-utils. If you are using a GUI then you might want to install bluez-pin also. +You also need libbluetooth, and libbluetooth-dev if you are compiling Asterisk from source. + +You need to get bluetooth working with your phone before attempting to use chan\_mobile. +This means 'pairing' your phone or headset with your Asterisk box. I dont describe how to do this here as the process +differs from distro to distro. You only need to pair once per adapter. + +See www.bluez.org for details about setting up Bluetooth under Linux. + + +\subsection{Concepts} + +chan\_mobile deals with both bluetooth adapters and bluetooth devices. This means you need to tell chan\_mobile about the +bluetooth adapters installed in your server as well as the devices (phones / headsets) you wish to use. + +chan\_mobile currently only allows one device (phone or headset) to be connected to an adapter at a time. This means you need +one adapter for each device you wish to use simultaneously. Much effort has gone into trying to make multiple devices per adapter +work, but in short it doesnt. + +Periodically chan\_mobile looks at each configured adapter, and if it is not in use (i.e. no device connected) will initiate a +search for devices configured to use this adapater that may be in range. If it finds one it will connect the device and it +will be available for Asterisk to use. When the device goes out of range, chan\_mobile will disconnect the device and the adapter +will become available for other devices. + + +\subsection{Configuring chan\_mobile} + +The configuration file for chan\_mobile is /etc/asterisk/mobile.conf. It is a normal Asterisk config file consisting of sections and key=value pairs. + +See configs/mobile.conf.sample for an example and an explanation of the configuration. + + +\subsection{Using chan\_mobile} + +chan\_mobile.so must be loaded either by loading it using the Asterisk CLI, or by adding it to /etc/asterisk/modules.conf + +Search for your bluetooth devices using the CLI command 'mobile search'. Be patient with this command as +it will take 8 - 10 seconds to do the discovery. This requires a free adapter. + +Headsets will generally have to be put into 'pairing' mode before they will show up here. + +This will return something like the following :- + +\begin{verbatim} +*CLI> mobile search +Address Name Usable Type Port +00:12:56:90:6E:00 LG TU500 Yes Phone 4 +00:80:C8:35:52:78 Toaster No Headset 0 +00:0B:9E:11:74:A5 Hello II Plus Yes Headset 1 +00:0F:86:0E:AE:42 Daves Blackberry Yes Phone 7 +\end{verbatim} + +This is a list of all bluetooth devices seen and whether or not they are usable with chan\_mobile. +The Address field contains the 'bd address' of the device. This is like an ethernet mac address. +The Name field is whatever is configured into the device as its name. +The Usable field tells you whether or not the device supports the Bluetooth Handsfree Profile or Headset profile. +The Type field tells you whether the device is usable as a Phone line (FXO) or a headset (FXS) +The Port field is the number to put in the configuration file. + +Choose which device(s) you want to use and edit /etc/asterisk/mobile.conf. There is a sample included +with the Asterisk-addons source under configs/mobile.conf.sample. + +Be sure to configure the right bd address and port number from the search. If you want inbound +calls on a device to go to a specific context, add a context= line, otherwise the default will +be used. The 'id' of the device [bitinbrackets] can be anything you like, just make it unique. + +If you are configuring a Headset be sure to include the type=headset line, if left out it defaults +to phone. + +The CLI command 'mobile show devices' can be used at any time to show the status of configured devices, +and whether or not the device is capable of sending / receiving SMS via bluetooth. + +\begin{verbatim} +*CLI> mobile show devices +ID Address Group Adapter Connected State SMS +headset 00:0B:9E:11:AE:C6 0 blue No Init No +LGTU550 00:E0:91:7F:46:44 1 dlink No Init No +\end{verbatim} + +As each phone is connected you will see a message on the Asterisk console :- + +\begin{verbatim} + Loaded chan_mobile.so => (Bluetooth Mobile Device Channel Driver) + -- Bluetooth Device blackberry has connected. + -- Bluetooth Device dave has connected. +\end{verbatim} + +To make outbound calls, add something to you Dialplan like the following :- (modify to suit) + +; Calls via LGTU5500 +\begin{verbatim} +exten => _9X.,1,Dial(Mobile/LGTU550/${EXTEN:1},45) +exten => _9X.,n,Hangup +\end{verbatim} + +To use channel groups, add an entry to each phones definition in mobile.conf like group=n +where n is a number. + +Then if you do something like Dial(Mobile/g1/123456) Asterisk will dial 123456 on the first +connected free phone in group 1. + +Phones which do not have a specific 'group=n' will be in group 0. + + +To dial out on a headset, you need to use some other mechanism, because the headset is not likely +to have all the needed buttons on it. res\_clioriginate is good for this :- + +\begin{verbatim} +*CLI> originate Mobile/headset extension NNNNN@context +\end{verbatim} + +This will call your headset, once you answer, Asterisk will call NNNNN at context context + +\subsection{Dialplan hints} + +chan\_mobile supports 'device status' so you can do somthing like + +\begin{verbatim} +exten => 1234,hint,SIP/30&Mobile/dave&Mobile/blackberry +\end{verbatim} + + +\subsection{MobileStatus Application} + +chan\_mobile also registers an application named MobileStatus. You can use this in your Dialplan +to determine the 'state' of a device. + +For example, suppose you wanted to call dave's extension, but only if he was in the office. You could +test to see if his mobile phone was attached to Asterisk, if it is dial his extension, otherwise dial his +mobile phone. + +\begin{verbatim} +exten => 40,1,MobileStatus(dave,DAVECELL) +exten => 40,2,GotoIf($["${DAVECELL}" = "1"]?3:5) +exten => 40,3,Dial(ZAP/g1/0427466412,45,tT) +exten => 40,4,Hangup +exten => 40,5,Dial(SIP/40,45,tT) +exten => 40,6,Hangup +\end{verbatim} + +MobileStatus sets the value of the given variable to :- + +\begin{verbatim} +1 = Disconnected. i.e. Device not in range of Asterisk, or turned off etc etc +2 = Connected and Not on a call. i.e. Free +3 = Connected and on a call. i.e. Busy +\end{verbatim} + + +\subsection{SMS Sending / Receiving} + +If Asterisk has detected your mobile phone is capable of SMS via bluetooth, you will be able to send and +receive SMS. + +Incoming SMS's cause Asterisk to create an inbound call to the context you defined in mobile.conf or the default +context if you did not define one. The call will start at extension 'sms'. Two channel variables will be available, +SMSSRC = the number of the originator of the SMS and SMSTXT which is the text of the SMS. +This is not a voice call, so grab the values of the variables and hang the call up. + +So, to handle incoming SMS's, do something like the following in your dialplan + +\begin{astlisting} +\begin{verbatim} +[incoming-mobile] +exten => sms,1,Verbose(Incoming SMS from ${SMSSRC} ${SMSTXT}) +exten => sms,n,Hangup() +\end{verbatim} +\end{astlisting} + +The above will just print the message on the console. + +If you use res\_jabber, you could do something like this :- + +\begin{astlisting} +\begin{verbatim} +[incoming-mobile] +exten => sms,1,JabberSend(transport,user@jabber.somewhere.com,SMS from ${SMSRC} ${SMSTXT}) +exten => sms,2,Hangup() +\end{verbatim} +\end{astlisting} + +To send an SMS, use the application MobileSendSMS like the following :- + +\begin{verbatim} +exten => 99,1,MobileSendSMS(dave,0427123456,Hello World) +\end{verbatim} + +This will send 'Hello World' via device 'dave' to '0427123456' + + +\subsection{DTMF Debouncing} + +DTMF detection varies from phone to phone. There is a configuration variable that allows you to tune +this to your needs. e.g. in mobile.conf + +\begin{verbatim} +[LGTU550] +address=00:12:56:90:6E:00 +port=4 +context=incoming-mobile +dtmfskip=50 +\end{verbatim} + +change dtmfskip to suit your phone. The default is 200. The larger the number, the more chance of missed DTMF. +The smaller the number the more chance of multiple digits being detected. + + +\subsection{Debugging} + +Different phone manufacturers have different interpretations of the Bluetooth Handsfree Profile Spec. +This means that not all phones work the same way, particularly in the connection setup / initialisation +sequence. I've tried to make chan\_mobile as general as possible, but it may need modification to +support some phone i've never tested. + +Some phones, most notably Sony Ericsson 'T' series, dont quite conform to the Bluetooth HFP spec. +chan\_mobile will detect these and adapt accordingly. The T-610 and T-630 have been tested and +work fine. + +If your phone doesnt behave has expected, turn on Asterisk debugging with 'core set debug 1'. + +This will log a bunch of debug messages indicating what the phone is doing, importantly the rfcomm +conversation between Asterisk and the phone. This can be used to sort out what your phone is doing +and make chan\_mobile support it. + +Be aware also, that just about all mobile phones behave differently. For example my LG TU500 wont dial unless +the phone is a the 'idle' screen. i.e. if the phone is showing a 'menu' on the display, when you dial via +Asterisk, the call will not work. chan\_mobile handles this, but there may be other phones that do +other things too... + +Important: Watch what your mobile phone is doing the first few times. Asterisk wont make random calls but +if chan\_mobile fails to hangup for some reason and you get a huge bill from your telco, dont blame me ;) diff --git a/include/asterisk/autoconfig.h.in b/include/asterisk/autoconfig.h.in index adaad8473..5ef18daef 100644 --- a/include/asterisk/autoconfig.h.in +++ b/include/asterisk/autoconfig.h.in @@ -132,6 +132,12 @@ /* Define to indicate the ${BKTR_DESCRIP} library version */ #undef HAVE_BKTR_VERSION +/* Define this to indicate the ${BLUETOOTH_DESCRIP} library */ +#undef HAVE_BLUETOOTH + +/* Define to indicate the ${BLUETOOTH_DESCRIP} library version */ +#undef HAVE_BLUETOOTH_VERSION + /* Define to 1 if byteswap.h macros are available. */ #undef HAVE_BYTESWAP_H @@ -581,6 +587,9 @@ /* Define to 1 if you have the `munmap' function. */ #undef HAVE_MUNMAP +/* Define if your system has the MYSQLCLIENT libraries. */ +#undef HAVE_MYSQLCLIENT + /* Define this to indicate the ${NBS_DESCRIP} library */ #undef HAVE_NBS diff --git a/include/asterisk/mod_format.h b/include/asterisk/mod_format.h index f415b2b6b..22238083d 100644 --- a/include/asterisk/mod_format.h +++ b/include/asterisk/mod_format.h @@ -102,6 +102,7 @@ struct ast_filestream { struct ast_format *fmt; /* need to write to the lock and usecnt */ int flags; mode_t mode; + char *open_filename; char *filename; char *realfilename; /*! Video file stream */ diff --git a/main/file.c b/main/file.c index c89cee97c..21ce1bbdc 100644 --- a/main/file.c +++ b/main/file.c @@ -320,6 +320,7 @@ static void filestream_destructor(void *arg) free(f->filename); if (f->realfilename) free(f->realfilename); + ast_free(f->open_filename); if (f->fmt->close) { void (*closefn)(struct ast_filestream *) = f->fmt->close; closefn(f); @@ -472,6 +473,7 @@ static int ast_filehelper(const char *filename, const void *arg2, const char *fm s->fmt = f; s->trans = NULL; s->filename = NULL; + s->open_filename = ast_strdup(fn);; if (s->fmt->format & AST_FORMAT_AUDIO_MASK) { if (chan->stream) ast_closestream(chan->stream); @@ -826,7 +828,30 @@ static int ast_fsread_video(const void *data) int ast_applystream(struct ast_channel *chan, struct ast_filestream *s) { + struct ast_party_connected_line connected; + char *fn; + + ast_channel_lock(chan); + ast_party_connected_line_set_init(&connected, &chan->connected); + if (ast_strlen_zero(chan->connected.id.number)) { + connected.id.number = ast_strdupa(chan->exten); + } + ast_channel_unlock(chan); + + fn = ast_strdupa(s->open_filename); + if ((fn = strrchr(fn, '/'))) { + char *dot; + *fn++ = '\0'; + if ((dot = strrchr(fn, '.'))) { + *dot = '\0'; + } + } + connected.id.number = connected.id.name = fn; + + ast_channel_update_connected_line(chan, &connected); + s->owner = chan; + return 0; } diff --git a/makeopts.in b/makeopts.in index 7e5c194c1..a1ba1de68 100644 --- a/makeopts.in +++ b/makeopts.in @@ -75,6 +75,9 @@ AST_FORTIFY_SOURCE=@AST_FORTIFY_SOURCE@ ALSA_INCLUDE=@ALSA_INCLUDE@ ALSA_LIB=@ALSA_LIB@ +BLUETOOTH_INCLUDE=@BLUETOOTH_INCLUDE@ +BLUETOOTH_LIB=@BLUETOOTH_LIB@ + CURL_INCLUDE=@CURL_INCLUDE@ CURL_LIB=@CURL_LIB@ @@ -129,6 +132,9 @@ LDAP_LIB=@LDAP_LIB@ LUA_INCLUDE=@LUA_INCLUDE@ LUA_LIB=@LUA_LIB@ +MYSQLCLIENT_INCLUDE=@MYSQLCLIENT_INCLUDE@ +MYSQLCLIENT_LIB=@MYSQLCLIENT_LIB@ + NBS_INCLUDE=@NBS_INCLUDE@ NBS_LIB=@NBS_LIB@