Microsoft/Windows2003-3790
Microsoft/Windows2003-3790
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
master
Windows2003-3790/enduser/netmeeting/av/callcont/api_up.c

3749 lines
135 KiB
C
Raw Permalink Normal View History

First commit
2001-01-01 00:00:00 +01:00
/******************************************************************************
*
* INTEL Corporation Proprietary Information
* Copyright (c) 1994, 1995, 1996 Intel Corporation.
*
* This listing is supplied under the terms of a license agreement
* with INTEL Corporation and may not be used, copied, nor disclosed
* except in accordance with the terms of that agreement.
*
*****************************************************************************/
/******************************************************************************
*
* $Workfile: api_up.c $
* $Revision: 1.33 $
* $Modtime: 06 Feb 1997 14:37:24 $
* $Log: S:\sturgeon\src\h245\src\vcs\api_up.c_v $
*
* Rev 1.33 06 Feb 1997 18:14:22 SBELL1
* took out ossDecoding of returnFunction in FunctionNotSupported PDU.
*
* Rev 1.32 05 Feb 1997 16:46:42 EHOWARDX
* Was allocating nLength bytes, not WCHARS, for UserInputIndication
* ASCII to Unicode conversion. Changed to allocate nLength WCHARs.
*
* Rev 1.31 06 Jan 1997 20:38:18 EHOWARDX
*
* Changed H245_CONF_CLOSE and H245_CONF_REQ_CLOSE to fill in
* AccRej with H245_REJ for any errors.
*
* Rev 1.30 19 Dec 1996 21:00:56 EHOWARDX
* Oops! H245_IND_OPEN_CONF can occur from T103 timeout (it's unique among
* indications; it's the only one that can happen in response to a timeout!)
*
* Rev 1.29 19 Dec 1996 17:18:22 EHOWARDX
* Changed to use h245asn1.h definitions instead of _setof3 and _setof8.
*
* Rev 1.28 18 Dec 1996 16:33:18 EHOWARDX
*
* Fixed bug in Master Slave Determination Kludge.
*
* Rev 1.27 17 Dec 1996 17:13:20 EHOWARDX
* Added pSeparateStack to IND_OPEN_T.
*
* Rev 1.26 12 Dec 1996 15:57:12 EHOWARDX
* Master Slave Determination kludge.
*
* Rev 1.25 21 Oct 1996 16:07:38 EHOWARDX
* Modified to make sure H245_INDETERMINATE is returned and Master/Slave
* status if determination fails.
*
* Rev 1.24 17 Oct 1996 18:17:14 EHOWARDX
* Changed general string to always be Unicode.
*
* Rev 1.23 14 Oct 1996 14:01:12 EHOWARDX
* Unicode changes.
*
* Rev 1.22 27 Aug 1996 10:54:16 unknown
* Deleted redundant lines.
*
* Rev 1.22 27 Aug 1996 10:52:28 unknown
* Deleted redundant lines.
*
* Rev 1.22 27 Aug 1996 09:54:12 unknown
* Deleted redundant lines.
*
* Rev 1.21 26 Aug 1996 14:19:18 EHOWARDX
* Added code to send FunctionNotUnderstood indication to remote peer
* if receive callback returns H245_ERROR_NOSUP.
*
* Rev 1.20 20 Aug 1996 14:44:40 EHOWARDX
* Changed H245_IND_COMM_MODE_RESPONSE and H245_IND_COMM_MODE_COMMAND
* callbacks to fill in DataType field in Cap as per Mike Andrews' request.
*
* Rev 1.19 15 Aug 1996 15:20:24 EHOWARDX
* First pass at new H245_COMM_MODE_ENTRY_T requested by Mike Andrews.
* Use at your own risk!
*
* Rev 1.18 15 Aug 1996 09:34:20 EHOWARDX
* Made TOTCAP and MUX structure in process_open_ind static since we are
* accessing pointers to them after return from the function.
*
* Rev 1.17 29 Jul 1996 19:33:00 EHOWARDX
*
* Fixed bug in flow control - missing break in restriction switch statement.
*
* Rev 1.16 19 Jul 1996 14:11:26 EHOWARDX
*
* Added indication callback structure for CommunicationModeResponse
* and CommunicationModeCommand.
*
* Rev 1.15 19 Jul 1996 12:48:00 EHOWARDX
*
* Multipoint clean-up.
*
* Rev 1.14 09 Jul 1996 17:09:28 EHOWARDX
* Fixed pointer offset bug in processing DataType from received
* OpenLogicalChannel.
*
* Rev 1.13 01 Jul 1996 22:13:04 EHOWARDX
*
* Added Conference and CommunicationMode structures and functions.
*
* Rev 1.12 18 Jun 1996 14:50:28 EHOWARDX
*
* Changed MLSE confirm handling.
*
* Rev 1.11 14 Jun 1996 18:57:52 EHOWARDX
* Geneva update.
*
* Rev 1.10 10 Jun 1996 16:55:34 EHOWARDX
* Removed #include "h245init.x"
*
* Rev 1.9 06 Jun 1996 18:45:52 EHOWARDX
* Added check for null dwTransId to Tracker routines; changed to use
* tracker routines instead of PLOCK macros.
*
* Rev 1.8 04 Jun 1996 13:56:46 EHOWARDX
* Fixed Release build warnings.
*
* Rev 1.7 30 May 1996 23:39:00 EHOWARDX
* Cleanup.
*
* Rev 1.6 29 May 1996 15:20:06 EHOWARDX
* Change to use HRESULT.
*
* Rev 1.5 28 May 1996 14:22:58 EHOWARDX
* Tel Aviv update.
*
* Rev 1.4 20 May 1996 22:17:58 EHOWARDX
* Completed NonStandard Message and H.225.0 Maximum Skew indication
* implementation. Added ASN.1 validation to H245SetLocalCap and
* H245SetCapDescriptor. Check-in from Microsoft drop on 17-May-96.
*
* Rev 1.3 16 May 1996 19:40:46 EHOWARDX
* Fixed multiplex capability bug.
*
* Rev 1.2 16 May 1996 15:59:24 EHOWARDX
* Fine-tuning H245SetLocalCap/H245DelLocalCap/H245SetCapDescriptor/
* H245DelCapDescriptor behaviour.
*
* Rev 1.1 13 May 1996 23:16:26 EHOWARDX
* Fixed remote terminal capability handling.
*
* Rev 1.0 09 May 1996 21:06:08 EHOWARDX
* Initial revision.
*
* Rev 1.23.1.11 09 May 1996 19:31:30 EHOWARDX
* Redesigned thread locking logic.
* Added new API functions.
*
* Rev 1.23.1.10 01 May 1996 19:30:32 EHOWARDX
* Added H245CopyCap(), H245FreeCap(), H245CopyMux(), H245FreeMux().
* Changed H2250_xxx definitions for H.225.0 address types to H245_xxx.
*
* Rev 1.23.1.9 29 Apr 1996 16:02:58 EHOWARDX
* Changed callback to give second parameters as pointer to specific message
* instead of pointer to general PDU structure.
*
* Rev 1.23.1.8 27 Apr 1996 21:09:40 EHOWARDX
* Changed Channel Numbers to words, added H.225.0 support.
*
* Rev 1.23.1.7 26 Apr 1996 15:54:34 EHOWARDX
* Added H.225.0 Capability support; Changed Capability indication
* to only callback once with PDU.
*
* Rev 1.23.1.6 24 Apr 1996 20:53:56 EHOWARDX
* Added new OpenLogicalChannelAck/OpenLogicalChannelReject support.
*
* Rev 1.23.1.5 23 Apr 1996 14:45:28 EHOWARDX
* Disabled Curt's "Conflict Resolution".
*
* Rev 1.23.1.4 19 Apr 1996 12:55:10 EHOWARDX
* Updated to 1.29
*
* Rev 1.23.1.3 17 Apr 1996 14:37:38 unknown
* Added load_H222_param(), load_VGMUX_param(), and load_H2250_param() and
* modified process_open_ind() to use them.
*
* Rev 1.23.1.2 15 Apr 1996 15:10:32 EHOWARDX
* Updated to match Curt's current version.
*
* Rev 1.23.1.1 03 Apr 1996 17:15:00 EHOWARDX
* No change.
*
* Rev 1.23.1.0 03 Apr 1996 15:54:04 cjutzi
* Branched for H.323.
*
* Rev 1.23 01 Apr 1996 16:46:20 cjutzi
*
* - changed tracker structure
* - Completed ENdConnection, and made asynch.. rather
* than sync.. as before
* Changed H245ShutDown to be sync rather than async..
*
* Rev 1.22 29 Mar 1996 14:54:28 cjutzi
* - added UserInput,
*
* Rev 1.21 28 Mar 1996 15:57:46 cjutzi
* - removed ASSERT line 1290.. close can occur on any channel at any time
*
* Rev 1.20 27 Mar 1996 08:36:40 cjutzi
* - removed PDU from stack.. made them dynamically allocated
*
* Rev 1.19 26 Mar 1996 13:48:30 cjutzi
*
* - dwPreserved in the callback routine was uninitialized..
*
* Rev 1.18 18 Mar 1996 15:23:30 cjutzi
*
*
*
* Rev 1.17 13 Mar 1996 14:14:02 cjutzi
*
* - clean up and added ASSERTs ..
*
* Rev 1.16 13 Mar 1996 12:06:12 cjutzi
*
* - fixed .. CONFIRM open.. for hani.. It released the tracker..
* was supposed to simply update the state to IDLE..
*
* Rev 1.15 13 Mar 1996 09:22:12 cjutzi
*
* - removed CRITICAL SECTIONS
*
* Rev 1.14 12 Mar 1996 15:52:32 cjutzi
*
* - fixed master slave (forgot a break)
* - fixed callback bug w/ cleanup on termcaps.
* - implemented End Session
* - fixed shutdown
* - Implemented Locking (big changes here.. )
*
* Rev 1.13 08 Mar 1996 14:04:18 cjutzi
*
* - implemented the upcall for mux table entries..
* - implemented capabillity descriptor callback
*
* Rev 1.12 05 Mar 1996 17:36:28 cjutzi
*
* - added MasterSlave indication message
* - remove bzero/bcopy and changed free call
* - implemented Mux Table down.. (not up)
*
* Rev 1.11 01 Mar 1996 14:16:08 cjutzi
*
* - added hani's error messages.. MasterSlave_FAILED.. oppss.. Forgot..
*
* Rev 1.10 01 Mar 1996 13:47:58 cjutzi
*
* - added hani's new fsm id's
*
* Rev 1.9 29 Feb 1996 17:26:16 cjutzi
* - bi-directional channel open working
*
* Rev 1.8 27 Feb 1996 14:56:30 cjutzi
*
* - fixed termcap_ack.. pdu was not being zero'd out..
* - cleaned up the code alittle..
*
* Rev 1.7 26 Feb 1996 17:22:40 cjutzi
*
* - Misc Command Indication added
*
* Rev 1.6 26 Feb 1996 11:05:48 cjutzi
*
* - lot's o-changes.. (sorry)
*
* Rev 1.5 16 Feb 1996 13:01:54 cjutzi
*
* - got open / close / request close working in both directions.
*
* Rev 1.4 15 Feb 1996 14:11:46 cjutzi
*
* - added muxt table to incoming open..
*
* Rev 1.3 15 Feb 1996 10:51:56 cjutzi
*
* - termcaps working
* - changed API interface for MUX_T
* - changed callback for IND_OPEN
* - changed constants IND_OPEN/IND_OPEN_NEEDSRSP
* - cleaned up the open.
* - modified H223 stuff
*
* Rev 1.2 09 Feb 1996 16:58:28 cjutzi
*
* - cleanup.. and some fixes..
* - added and or changed headers to reflect the log of changes
*
*****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
/**** *****/
/**** NOTES TO THE READER *****/
/**** *****/
/**** This program has been put together using a a screen which is *****/
/**** wider than 80 characters.. It is best if a similar screen size is *****/
/**** used.. Of course emacs is my preference but 80 col screens will *****/
/**** cause you much frustration.. *****/
/**** *****/
/**** Tabs are set to 8 *****/
/**** *****/
/****************************************************************************/
/****************************************************************************/
/****************************************************************************/
#ifndef STRICT
#define STRICT
#endif
#include "precomp.h"
/***********************/
/* H245 INCLUDES */
/***********************/
#include "h245api.h"
#include "h245com.h"
#include "h245sys.x"
#include "h245asn1.h"
#include "fsmexpor.h"
#include "api_util.x"
#include "pdu.x"
HRESULT
LoadUnicastAddress (H245_TRANSPORT_ADDRESS_T *pOut,
UnicastAddress *pIn)
{
switch (pIn->choice)
{
case UnicastAddress_iPAddress_chosen:
pOut->type = H245_IP_UNICAST;
memcpy(pOut->u.ip.network,
pIn->u.UnicastAddress_iPAddress.network.value,
4);
pOut->u.ip.tsapIdentifier = pIn->u.UnicastAddress_iPAddress.tsapIdentifier;
break;
case iPXAddress_chosen:
pOut->type = H245_IPX_UNICAST;
memcpy(pOut->u.ipx.node,
pIn->u.iPXAddress.node.value,
6);
memcpy(pOut->u.ipx.netnum,
pIn->u.iPXAddress.netnum.value,
4);
memcpy(pOut->u.ipx.tsapIdentifier,
pIn->u.iPXAddress.tsapIdentifier.value,
2);
break;
case UncstAddrss_iP6Address_chosen:
pOut->type = H245_IP6_UNICAST;
memcpy(pOut->u.ip6.network,
pIn->u.UncstAddrss_iP6Address.network.value,
16);
pOut->u.ip6.tsapIdentifier = pIn->u.UncstAddrss_iP6Address.tsapIdentifier;
break;
case netBios_chosen:
pOut->type = H245_NETBIOS_UNICAST;
memcpy(pOut->u.netBios, pIn->u.netBios.value, 16);
break;
case iPSourceRouteAddress_chosen:
switch (pIn->u.iPSourceRouteAddress.routing.choice)
{
case strict_chosen:
pOut->type = H245_IPSSR_UNICAST;
break;
case loose_chosen:
pOut->type = H245_IPLSR_UNICAST;
break;
default:
return H245_ERROR_INVALID_DATA_FORMAT;
} // switch
memcpy(pOut->u.ipSourceRoute.network,
pIn->u.iPSourceRouteAddress.network.value,
4);
pOut->u.ipSourceRoute.tsapIdentifier = pIn->u.iPSourceRouteAddress.tsapIdentifier;
// TBD - handle route
break;
default:
return H245_ERROR_INVALID_DATA_FORMAT;
} // switch
return H245_ERROR_OK;
} // LoadUnicastAddress()
HRESULT
LoadMulticastAddress(H245_TRANSPORT_ADDRESS_T *pOut,
MulticastAddress *pIn)
{
switch (pIn->choice)
{
case MltcstAddrss_iPAddress_chosen:
pOut->type = H245_IP_MULTICAST;
memcpy(pOut->u.ip.network,
pIn->u.MltcstAddrss_iPAddress.network.value,
4);
pOut->u.ip.tsapIdentifier = pIn->u.MltcstAddrss_iPAddress.tsapIdentifier;
break;
case MltcstAddrss_iP6Address_chosen:
pOut->type = H245_IP6_MULTICAST;
memcpy(pOut->u.ip6.network,
pIn->u.MltcstAddrss_iP6Address.network.value,
16);
pOut->u.ip6.tsapIdentifier = pIn->u.MltcstAddrss_iP6Address.tsapIdentifier;
break;
default:
return H245_ERROR_INVALID_DATA_FORMAT;
} // switch
return H245_ERROR_OK;
} // LoadMulticastAddress()
HRESULT
LoadTransportAddress(H245_TRANSPORT_ADDRESS_T *pOut,
H245TransportAddress *pIn)
{
switch (pIn->choice)
{
case unicastAddress_chosen:
return LoadUnicastAddress (pOut, &pIn->u.unicastAddress);
case multicastAddress_chosen:
return LoadMulticastAddress(pOut, &pIn->u.multicastAddress);
default:
return H245_ERROR_INVALID_DATA_FORMAT;
} // switch
} // LoadTransportAddress()
HRESULT
LoadCommModeEntry(H245_COMM_MODE_ENTRY_T *pOut,
CommunicationModeTableEntry *pIn)
{
HRESULT lResult;
memset(pOut, 0, sizeof(*pOut));
if (pIn->bit_mask & CMTEy_nnStndrd_present)
{
pOut->pNonStandard = pIn->CMTEy_nnStndrd;
}
pOut->sessionID = (unsigned char)pIn->sessionID;
if (pIn->bit_mask & CMTEy_assctdSssnID_present)
{
pOut->associatedSessionID = (unsigned char)pIn->CMTEy_assctdSssnID;
pOut->associatedSessionIDPresent = TRUE;
}
if (pIn->bit_mask & CommunicationModeTableEntry_terminalLabel_present)
{
pOut->terminalLabel = pIn->terminalLabel;
pOut->terminalLabelPresent = TRUE;
}
pOut->pSessionDescription = pIn->sessionDescription.value;
pOut->wSessionDescriptionLength = (WORD) pIn->sessionDescription.length;
switch (pIn->dataType.choice)
{
case dataType_videoData_chosen:
pOut->dataType.DataType = H245_DATA_VIDEO;
break;
case dataType_audioData_chosen:
pOut->dataType.DataType = H245_DATA_AUDIO;
break;
case dataType_data_chosen:
pOut->dataType.DataType = H245_DATA_DATA;
break;
default:
return H245_ERROR_INVALID_DATA_FORMAT;
} // switch
lResult = build_totcap_cap_n_client_from_capability ((struct Capability *)&pIn->dataType,
pOut->dataType.DataType,
pIn->dataType.u.dataType_videoData.choice,
&pOut->dataType);
if (lResult != H245_ERROR_OK)
return lResult;
if (pIn->bit_mask & CMTEy_mdChnnl_present)
{
lResult = LoadTransportAddress(&pOut->mediaChannel, &pIn->CMTEy_mdChnnl);
if (lResult != H245_ERROR_OK)
return lResult;
pOut->mediaChannelPresent = TRUE;
}
if (pIn->bit_mask & CMTEy_mdGrntdDlvry_present)
{
pOut->mediaGuaranteed = pIn->CMTEy_mdGrntdDlvry;
pOut->mediaGuaranteedPresent = TRUE;
}
if (pIn->bit_mask & CMTEy_mdCntrlChnnl_present)
{
lResult = LoadTransportAddress(&pOut->mediaControlChannel, &pIn->CMTEy_mdCntrlChnnl);
if (lResult != H245_ERROR_OK)
return lResult;
pOut->mediaControlChannelPresent = TRUE;
}
if (pIn->bit_mask & CMTEy_mdCntrlGrntdDlvry_present)
{
pOut->mediaControlGuaranteed = pIn->CMTEy_mdCntrlGrntdDlvry;
pOut->mediaControlGuaranteedPresent = TRUE;
}
return H245_ERROR_OK;
} // LoadCommModeEntry()
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: load_H222_param
* load_H223_param
* load_VGMUX_param
* load_H2250_param
* load_H2250ACK_param
*
* DESCRIPTION
*
* This routine builds local API-style Logical Parameters out of ASN.1
* structure passed to it
*
*
* RETURN:
*
*****************************************************************************/
static HRESULT
load_H222_param (H245_H222_LOGICAL_PARAM_T * pOut, /* output */
H222LogicalChannelParameters * pIn) /* input */
{
/* See setup_H220_mux() for inverse function */
memset(pOut, 0, sizeof(*pOut));
pOut->resourceID = pIn->resourceID;
pOut->subChannelID = pIn->subChannelID;
if (pIn->bit_mask & pcr_pid_present)
{
pOut->pcr_pidPresent = TRUE;
pOut->pcr_pid = pIn->pcr_pid;
}
if (pIn->bit_mask & programDescriptors_present)
{
pOut->programDescriptors.length = pIn->programDescriptors.length;
pOut->programDescriptors.value = pIn->programDescriptors.value;
}
if (pIn->bit_mask & streamDescriptors_present)
{
pOut->streamDescriptors.length = pIn->streamDescriptors.length;
pOut->streamDescriptors.value = pIn->streamDescriptors.value;
}
return H245_ERROR_OK;
} // load_H222_param()
static HRESULT
load_H223_param (H245_H223_LOGICAL_PARAM_T * pOut, /* output */
H223LogicalChannelParameters * pIn) /* input */
{
HRESULT lError = H245_ERROR_OK;
/* See setup_H223_mux() for inverse function */
memset(pOut, 0, sizeof(*pOut));
pOut->SegmentFlag = pIn->segmentableFlag;
switch (pIn->adaptationLayerType.choice)
{
case H223LCPs_aLTp_nnStndrd_chosen:
lError = CopyNonStandardParameter(&pOut->H223_NONSTD,
&pIn->adaptationLayerType.u.H223LCPs_aLTp_nnStndrd);
pOut->AlType = H245_H223_AL_NONSTD;
break;
case H223LCPs_aLTp_al1Frmd_chosen:
pOut->AlType = H245_H223_AL_AL1FRAMED;
break;
case H223LCPs_aLTp_al1NtFrmd_chosen:
pOut->AlType = H245_H223_AL_AL1NOTFRAMED;
break;
case H223LCPs_aLTp_a2WSNs_1_chosen:
pOut->AlType = H245_H223_AL_AL2NOSEQ;
break;
case H223LCPs_aLTp_a2WSNs_2_chosen:
pOut->AlType = H245_H223_AL_AL2SEQ;
break;
case H223LCPs_aLTp_al3_chosen:
pOut->AlType = H245_H223_AL_AL3;
pOut->CtlFldOctet = (unsigned char)pIn->adaptationLayerType.u.H223LCPs_aLTp_al3.controlFieldOctets;
pOut->SndBufSize = pIn->adaptationLayerType.u.H223LCPs_aLTp_al3.sendBufferSize;
break;
} /* switch */
return lError;
} // load_H223_param()
static HRESULT
load_VGMUX_param(H245_VGMUX_LOGICAL_PARAM_T *pOut, /* output */
V76LogicalChannelParameters *pIn) /* input */
{
/* See setup_VGMUX_mux() for inverse function */
memset(pOut, 0, sizeof(*pOut));
pOut->crcLength = pIn->hdlcParameters.crcLength.choice;
pOut->n401 = pIn->hdlcParameters.n401;
pOut->loopbackTestProcedure = pIn->hdlcParameters.loopbackTestProcedure;
pOut->suspendResume = pIn->suspendResume.choice;
pOut->uIH = pIn->uIH;
pOut->mode = pIn->mode.choice;
switch (pIn->mode.choice)
{
case eRM_chosen:
pOut->windowSize = pIn->mode.u.eRM.windowSize;
pOut->recovery = pIn->mode.u.eRM.recovery.choice;
break;
} // switch
pOut->audioHeaderPresent = pIn->v75Parameters.audioHeaderPresent;
return H245_ERROR_OK;
} // load_VGMUX_param()
static HRESULT
load_H2250_param(H245_H2250_LOGICAL_PARAM_T * pOut, /* output */
H2250LogicalChannelParameters *pIn) /* input */
{
HRESULT lError = H245_ERROR_OK;
/* See setup_H2250_mux() for inverse function */
memset(pOut, 0, sizeof(*pOut));
if (pIn->bit_mask & H2250LCPs_nnStndrd_present)
{
pOut->nonStandardList = pIn->H2250LCPs_nnStndrd;
}
pOut->sessionID = (unsigned char) pIn->sessionID;
if (pIn->bit_mask & H2250LCPs_assctdSssnID_present)
{
pOut->associatedSessionID = (unsigned char)pIn->H2250LCPs_assctdSssnID;
pOut->associatedSessionIDPresent = TRUE;
}
if (pIn->bit_mask & H2250LCPs_mdChnnl_present)
{
if (lError == H245_ERROR_OK)
{
lError = LoadTransportAddress(&pOut->mediaChannel,
&pIn->H2250LCPs_mdChnnl);
if (lError == H245_ERROR_OK)
{
pOut->mediaChannelPresent = TRUE;
}
}
}
if (pIn->bit_mask & H2250LCPs_mdGrntdDlvry_present)
{
pOut->mediaGuaranteed = pIn->H2250LCPs_mdGrntdDlvry;
pOut->mediaGuaranteedPresent = TRUE;
}
if (pIn->bit_mask & H2250LCPs_mdCntrlChnnl_present)
{
if (lError == H245_ERROR_OK)
{
lError = LoadTransportAddress(&pOut->mediaControlChannel,
&pIn->H2250LCPs_mdCntrlChnnl);
if (lError == H245_ERROR_OK)
{
pOut->mediaControlChannelPresent = TRUE;
}
}
}
if (pIn->bit_mask & H2250LCPs_mCGDy_present)
{
pOut->mediaControlGuaranteed = pIn->H2250LCPs_mCGDy;
pOut->mediaControlGuaranteedPresent = TRUE;
}
if (pIn->bit_mask & silenceSuppression_present)
{
pOut->silenceSuppression = pIn->silenceSuppression;
pOut->silenceSuppressionPresent = TRUE;
}
if (pIn->bit_mask & H2250LogicalChannelParameters_destination_present)
{
pOut->destination = pIn->destination;
pOut->destinationPresent = TRUE;
}
if (pIn->bit_mask & H2250LCPs_dRTPPTp_present)
{
pOut->dynamicRTPPayloadType = (unsigned char)pIn->H2250LCPs_dRTPPTp;
pOut->dynamicRTPPayloadTypePresent = TRUE;
}
if (pIn->bit_mask & mediaPacketization_present)
{
switch (pIn->mediaPacketization.choice)
{
case h261aVideoPacketization_chosen:
pOut->h261aVideoPacketization = TRUE;
break;
default:
return H245_ERROR_INVALID_DATA_FORMAT;
} // switch
}
return lError;
} // load_H2250_param()
static HRESULT
load_H2250ACK_param(H245_H2250ACK_LOGICAL_PARAM_T * pOut,
H2250LgclChnnlAckPrmtrs * pIn)
{
HRESULT lError = H245_ERROR_OK;
/* See setup_H2250ACK_mux() for inverse function */
memset(pOut, 0, sizeof(*pOut));
if (pIn->bit_mask & H2250LCAPs_nnStndrd_present)
{
pOut->nonStandardList = pIn->H2250LCAPs_nnStndrd;
}
if (pIn->bit_mask & sessionID_present)
{
pOut->sessionID = (unsigned char) pIn->sessionID;
pOut->sessionIDPresent = TRUE;
}
if (pIn->bit_mask & H2250LCAPs_mdChnnl_present)
{
if (lError == H245_ERROR_OK)
{
lError = LoadTransportAddress(&pOut->mediaChannel,
&pIn->H2250LCAPs_mdChnnl);
if (lError == H245_ERROR_OK)
{
pOut->mediaChannelPresent = TRUE;
}
}
}
if (pIn->bit_mask & H2250LCAPs_mdCntrlChnnl_present)
{
if (lError == H245_ERROR_OK)
{
lError = LoadTransportAddress(&pOut->mediaControlChannel,
&pIn->H2250LCAPs_mdCntrlChnnl);
if (lError == H245_ERROR_OK)
{
pOut->mediaControlChannelPresent = TRUE;
}
}
}
if (pIn->bit_mask & H2250LCAPs_dRTPPTp_present)
{
pOut->dynamicRTPPayloadType = (unsigned char)pIn->H2250LCAPs_dRTPPTp;
pOut->dynamicRTPPayloadTypePresent = TRUE;
}
return lError;
} // load_H2250ACK_param()
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: build_element_list_from_mux -
*
* DESCRIPTION
* recursively build H245_MUX_ENTRY_ELEMENT_T list from
* ASN1 mux table descriptor entrys.
*
* RETURN:
*
*****************************************************************************/
static H245_MUX_ENTRY_ELEMENT_T *
build_element_list_from_mux (MultiplexElement *p_ASN_mux_el,
H245_ACC_REJ_T *p_acc_rej)
{
DWORD ii;
H245_MUX_ENTRY_ELEMENT_T *p_mux_el;
H245_MUX_ENTRY_ELEMENT_T *p_mux_el_tmp = NULL;
H245_MUX_ENTRY_ELEMENT_T *p_mux_el_lst = NULL;
if (!(p_mux_el = (H245_MUX_ENTRY_ELEMENT_T *)MemAlloc(sizeof(H245_MUX_ENTRY_ELEMENT_T))))
{
/* too complicated.. ran out of memory */
H245TRACE(0,1,"build_element_list_from_mux : H245_ERROR_NOMEM");
*p_acc_rej = H245_REJ_MUX_COMPLICATED;
return NULL;
}
/* zero it out */
memset (p_mux_el, 0, sizeof(H245_MUX_ENTRY_ELEMENT_T));
switch (p_ASN_mux_el->type.choice)
{
case typ_logicalChannelNumber_chosen:
/* assign as a logical channel */
p_mux_el->Kind = H245_MUX_LOGICAL_CHANNEL;
p_mux_el->u.Channel = p_ASN_mux_el->type.u.typ_logicalChannelNumber;
break;
case subElementList_chosen:
{
/* if the sub element list doesn't exist .. no go */
/* if the sub element list has less than 2 entries.. no go. */
if ((!p_ASN_mux_el->type.u.subElementList) ||
(p_ASN_mux_el->type.u.subElementList->count < 2))
{
/* invalid Element list.. */
H245TRACE(0,1,"build_element_list_from_mux : << ERROR >> Element Count < 2");
*p_acc_rej = H245_REJ;
free_mux_el_list (p_mux_el);
return NULL;
}
/* assign as entry element */
p_mux_el->Kind = H245_MUX_ENTRY_ELEMENT;
/* ok.. for every sub element in the list */
for (ii=0;ii<p_ASN_mux_el->type.u.subElementList->count;ii++)
{
if (!(p_mux_el_tmp = build_element_list_from_mux (&p_ASN_mux_el->type.u.subElementList->value[ii], p_acc_rej)))
{
/* *p_acc_rej is set from below */
free_mux_el_list (p_mux_el);
return NULL;
}
/* if first on the down sub element list.. assign to sub */
/* element portion of mux_el */
if (!p_mux_el_lst)
p_mux_el->u.pMuxTblEntryElem = p_mux_el_tmp;
/* otherwise.. just a list.. add it on.. */
else
p_mux_el_lst->pNext = p_mux_el_tmp;
p_mux_el_lst = p_mux_el_tmp;
}
}
break;
default:
/* Un supported structure */
H245TRACE(0,1,"build_element_list_from_mux : INVALID MUX TABLE ENTRY PDU 'type.choice' unknown");
*p_acc_rej = H245_REJ;
free_mux_el_list (p_mux_el);
return NULL;
}
switch (p_ASN_mux_el->repeatCount.choice)
{
case repeatCount_finite_chosen:
p_mux_el->RepeatCount = p_ASN_mux_el->repeatCount.u.repeatCount_finite;
break;
case untilClosingFlag_chosen:
p_mux_el->RepeatCount = 0;
break;
default:
/* Un supported structure */
H245TRACE(0,1,"build_element_list_from_mux : INVALID MUX TABLE ENTRY PDU 'repeatCount.choice' unknown");
*p_acc_rej = H245_REJ;
free_mux_el_list (p_mux_el);
return NULL;
break;
}
return p_mux_el;
}
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: process_mux_table_ind
*
* DESCRIPTION
*
*
* RETURN:
*
*****************************************************************************/
static H245_MUX_TABLE_T *
process_mux_table_ind (MltmdSystmCntrlMssg *p_pdu_ind,
unsigned short *p_seq,
H245_ACC_REJ_MUX_T rej_mux,
DWORD *p_rej_cnt,
DWORD *p_acc_cnt)
{
UINT ii; /* generic counter */
MultiplexEntrySend *p_ASN_mux; /* ans1 mux entry */
MultiplexEntryDescriptorLink p_ASN_med_desc_lnk; /* asn1 mux entry descriptor */
int mux_entry; /* current mux entry descc */
H245_MUX_TABLE_T *p_mux_table_list = NULL;
ASSERT(p_pdu_ind->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(p_pdu_ind->u.MltmdSystmCntrlMssg_rqst.choice == multiplexEntrySend_chosen);
/* initialize rej_mux */
for (ii=0;ii<15;ii++)
{
rej_mux[ii].AccRej = H245_ACC;
rej_mux[ii].MuxEntryId = 0;
}
*p_rej_cnt = 0;
*p_acc_cnt = 0;
p_ASN_mux = &(p_pdu_ind->u.MltmdSystmCntrlMssg_rqst.u.multiplexEntrySend);
/* get sequence number */
*p_seq = p_ASN_mux->sequenceNumber;
/* this should never happen.. */
if (!(p_ASN_mux->multiplexEntryDescriptors))
return NULL;
/* for each descriptor.. ie mux table entry */
for (p_ASN_med_desc_lnk = p_ASN_mux->multiplexEntryDescriptors, mux_entry=0;
p_ASN_med_desc_lnk;
p_ASN_med_desc_lnk = p_ASN_med_desc_lnk->next, mux_entry++)
{
/* remove descriptor from table */
H245_MUX_TABLE_T *p_mux_table;
H245_MUX_TABLE_T *p_mux_table_lst = NULL;
if (!(p_mux_table = (H245_MUX_TABLE_T *)MemAlloc(sizeof(H245_MUX_TABLE_T))))
{
/* houston.. we have a problem !!!!!!!! */
/* rejet this one.. */
/* and move on.. */
rej_mux[mux_entry].MuxEntryId = p_ASN_med_desc_lnk->value.multiplexTableEntryNumber;
rej_mux[mux_entry].AccRej = H245_REJ;
(*p_rej_cnt)++;
continue;
}
/* zero it out */
memset (p_mux_table, 0, sizeof(H245_MUX_TABLE_T));
/* assign mux table entry */
rej_mux[mux_entry].MuxEntryId = (DWORD)
p_mux_table->MuxEntryId =
p_ASN_med_desc_lnk->value.multiplexTableEntryNumber;
/* if element is not present */
if (p_ASN_med_desc_lnk->value.bit_mask != elementList_present)
{
p_mux_table->pMuxTblEntryElem = NULL;
rej_mux[mux_entry].AccRej = H245_ACC;
(*p_acc_cnt)++;
}
/* if element list present */
else
{
H245_MUX_ENTRY_ELEMENT_T *p_mux_el_lst = NULL;
H245_MUX_ENTRY_ELEMENT_T *p_mux_el_tmp = NULL;
/* start if off.. w/ ok */
rej_mux[mux_entry].AccRej = H245_ACC;
/* for each element in the element list.. */
/* build the subelements.. if error .. free */
/* what youve done so far.. and break out */
for (ii=0;
ii < p_ASN_med_desc_lnk->value.elementList.count;
ii++)
{
/* if any of the elements fail.. flag the entry w/ reject reason */
/* (this is done inside the build_element_list..) */
/* and break out.. continue on with the next descriptor */
if (!(p_mux_el_tmp = build_element_list_from_mux (&(p_ASN_med_desc_lnk->value.elementList.value[ii]),&(rej_mux[mux_entry].AccRej))))
{
/* free the list.. */
free_mux_el_list (p_mux_table->pMuxTblEntryElem);
break;
}
/* ***************************** */
/* LINK IN THE MUX ENTRY ELEMENT */
/* ***************************** */
/* if first time through */
if (!p_mux_el_lst)
p_mux_table->pMuxTblEntryElem = p_mux_el_tmp;
/* otherwize .. just tag on the end */
else
p_mux_el_lst->pNext = p_mux_el_tmp;
p_mux_el_lst = p_mux_el_tmp;
} /* for each element in descriptor list */
} /* if element list present */
/* if you've accepted the mux table entry descriptor */
if (rej_mux[mux_entry].AccRej == H245_ACC)
{
/* indicate an accept */
(*p_acc_cnt)++;
/* ******************************** */
/* LINK IN THE MUX TABLE DESCRIPTOR */
/* ******************************** */
/* first table entry on the list.. (first time through) */
if (!p_mux_table_list)
p_mux_table_list = p_mux_table;
else
p_mux_table_lst->pNext = p_mux_table;
p_mux_table_lst = p_mux_table;
}
else
{
/* indicate a reject */
(*p_rej_cnt)++;
/* otherwise.. free it and move on to something better */
MemFree(p_mux_table);
}
} /* for each desriptor in the list */
return p_mux_table_list;
} /* procedure */
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: process_term_cap_set_ind__cap_table
*
* DESCRIPTION allocates a new cap link and copies the capabiliites.
* links into the tiven capabilityTableLink, and if
* Parameters are NONSTANDARD does some gymnastics to copy
* data so it can be used..
*
* NOTE: Copied data must be freed when capability is deleted.
* see where the capability is deleted for exceptions
* for "NONSTD" parameter sets .. (this is not pretty)
*
* RETURN:
*
*****************************************************************************/
static HRESULT
process_term_cap_set_ind__cap_table ( struct InstanceStruct *pInstance,
struct TerminalCapabilitySet *pTermCapSet,
CapabilityTableLink pCapLink,
MltmdSystmCntrlMssg *p_pdu_rsp)
{
H245_TOTCAP_T totcap;
CapabilityTableLink pNewLink;
HRESULT lError;
while (pCapLink)
{
if (build_totcap_from_captbl (&totcap,
pCapLink,
H245_REMOTE) == H245_ERROR_OK)
{
/* ok.. assume the CapId is set.. find it in the remote table */
/* if it exists, delete it so we can add new one in it's place */
pNewLink = find_capid_by_entrynumber( pTermCapSet, totcap.CapId);
if (pNewLink)
{
del_cap_link ( pTermCapSet, pNewLink );
}
/* ok.. if you've deleted the cap.. now see if there is a new one to take it's place */
if (pCapLink->value.bit_mask & capability_present)
{
/* load and link into remote table entry */
pNewLink = alloc_link_cap_entry (pTermCapSet);
if (!pNewLink)
{
return H245_ERROR_NORESOURCE;
}
/* copy the cap over to the remote entry */
pNewLink->value = pCapLink->value;
// If it's nonstandard, the above didn't work, so fix it up...
lError = H245_ERROR_OK;
switch (pCapLink->value.capability.choice)
{
case Capability_nonStandard_chosen:
lError = CopyNonStandardParameter(&pNewLink->value.capability.u.Capability_nonStandard,
&pCapLink->value.capability.u.Capability_nonStandard);
break;
case receiveVideoCapability_chosen:
case transmitVideoCapability_chosen:
case rcvAndTrnsmtVdCpblty_chosen:
if (pCapLink->value.capability.u.receiveVideoCapability.choice == VdCpblty_nonStandard_chosen)
{
lError = CopyNonStandardParameter(&pNewLink->value.capability.u.receiveVideoCapability.u.VdCpblty_nonStandard,
&pCapLink->value.capability.u.receiveVideoCapability.u.VdCpblty_nonStandard);
}
break;
case receiveAudioCapability_chosen:
case transmitAudioCapability_chosen:
case rcvAndTrnsmtAdCpblty_chosen:
if (pCapLink->value.capability.u.receiveAudioCapability.choice == AdCpblty_nonStandard_chosen)
{
lError = CopyNonStandardParameter(&pNewLink->value.capability.u.receiveAudioCapability.u.AdCpblty_nonStandard,
&pCapLink->value.capability.u.receiveAudioCapability.u.AdCpblty_nonStandard);
}
break;
case rcvDtApplctnCpblty_chosen:
case trnsmtDtApplctnCpblty_chosen:
case rATDACy_chosen :
if (pCapLink->value.capability.u.rcvDtApplctnCpblty.application.choice == DACy_applctn_nnStndrd_chosen)
{
lError = CopyNonStandardParameter(&pNewLink->value.capability.u.rcvDtApplctnCpblty.application.u.DACy_applctn_nnStndrd,
&pCapLink->value.capability.u.rcvDtApplctnCpblty.application.u.DACy_applctn_nnStndrd);
}
break;
} // switch
if (lError != H245_ERROR_OK)
return lError;
} /* if capability_present */
} /* if build_totcap_from_captbl succeeded */
pCapLink = pCapLink->next;
} /* for all entries in link */
return H245_ERROR_OK;
}
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: process_term_cap_set_ind__cap_desc
*
* DESCRIPTION
*
*
* RETURN:
*
*****************************************************************************/
static HRESULT
process_term_cap_set_ind__cap_desc (struct InstanceStruct *pInstance,
struct TerminalCapabilitySet *pTermCapSet,
CapabilityDescriptor *pReqCapDesc,
MltmdSystmCntrlMssg *p_pdu_rsp)
{
unsigned int uCapDescNumber;
CapabilityDescriptor *pCapDesc;
unsigned int uCapDesc;
SmltnsCpbltsLink pSimCap;
SmltnsCpbltsLink pReqSimCap;
CapabilityDescriptor TempCapDesc;
unsigned int uSimCount;
unsigned int uReqAltCount;
unsigned int uReqAltCap;
unsigned int uAltCap;
HRESULT lError = H245_ERROR_OK;
uCapDescNumber = pReqCapDesc->capabilityDescriptorNumber & 255;
H245TRACE(pInstance->dwInst,20,"API:process_term_cap_set_ind - Remote Capability Descriptor #%d", uCapDescNumber);
// Find corresponding capability descriptor
pCapDesc = NULL;
for (uCapDesc = 0; uCapDesc < pTermCapSet->capabilityDescriptors.count; ++uCapDesc)
{
if (pTermCapSet->capabilityDescriptors.value[uCapDesc].capabilityDescriptorNumber == uCapDescNumber)
{
// Deallocate old simultaneous capabilities
pCapDesc = &pTermCapSet->capabilityDescriptors.value[uCapDesc];
if (pCapDesc->smltnsCpblts)
dealloc_simultaneous_cap(pCapDesc);
break;
} // if
} // for
if (pCapDesc == NULL)
{
// Allocate a new terminal capability descriptor
ASSERT(pTermCapSet->capabilityDescriptors.count < 256);
pCapDesc = &pTermCapSet->capabilityDescriptors.value[pTermCapSet->capabilityDescriptors.count++];
}
ASSERT(pCapDesc->smltnsCpblts == NULL);
if (!(pReqCapDesc->bit_mask & smltnsCpblts_present))
{
// Delete the terminal capability descriptor
pTermCapSet->capabilityDescriptors.count--;
*pCapDesc = pTermCapSet->capabilityDescriptors.value[pTermCapSet->capabilityDescriptors.count];
return H245_ERROR_OK;
}
// Make a copy of the (volatile) new capability descriptor
pCapDesc->bit_mask = 0;
pCapDesc->capabilityDescriptorNumber = (CapabilityDescriptorNumber)uCapDescNumber;
pCapDesc->smltnsCpblts = NULL;
// We copy the linked list to a temporary so that it
// gets reversed twice and ends up in same order
TempCapDesc.smltnsCpblts = NULL;
uSimCount = 0;
pReqSimCap = pReqCapDesc->smltnsCpblts;
while (pReqSimCap)
{
// Allocate a new simultaneous capability list element
pSimCap = MemAlloc(sizeof(*pSimCap));
if (pSimCap == NULL)
{
H245TRACE(pInstance->dwInst, 1,
"API:process_term_cap_set_ind: malloc failed");
lError = H245_ERROR_NOMEM;
break;
}
// Verify that each alternative capability in the request
// simultaneous capability is valid
// if so, copy it
uAltCap = 0;
uReqAltCount = pReqSimCap->value.count;
for (uReqAltCap = 0; uReqAltCap < uReqAltCount; ++uReqAltCap)
{
// Is the Capability in the remote Capability Table?
if (find_capid_by_entrynumber (pTermCapSet, pReqSimCap->value.value[uReqAltCap]) == NULL)
{
// can't find the Capability
H245TRACE(pInstance->dwInst,1,"API:process_term_cap_set_ind - Remote Capability Table Entry #%d not found",
pReqSimCap->value.value[uReqAltCap]);
lError = H245_ERROR_UNKNOWN;
}
else if (uAltCap >= H245_MAX_ALTCAPS)
{
// Exceeded arbitrary limit
H245TRACE(pInstance->dwInst,1,
"API:process_term_cap_set_ind - Too many alternative capabilities (%d)",
uAltCap);
lError = H245_ERROR_NORESOURCE;
break;
}
else
{
// Copy the capability number
pSimCap->value.value[uAltCap++] = pReqSimCap->value.value[uReqAltCap];
}
} /* for alternative capbilities */
if (uAltCap)
{
// Verify that we have not exceeded arbitrary limit
if (++uSimCount > H245_MAX_SIMCAPS)
{
// Exceeded arbitrary limit
H245TRACE(pInstance->dwInst, 1,
"API:process_term_cap_set_ind - Too many simultaneous capabilities (%d)",
uSimCount);
MemFree(pSimCap);
lError = H245_ERROR_NORESOURCE;
}
else
{
// Add new simultaneous capability to the temporary list
pSimCap->value.count = (unsigned short)uAltCap;
pSimCap->next = TempCapDesc.smltnsCpblts;
TempCapDesc.smltnsCpblts = pSimCap;
}
}
else
{
H245TRACE(pInstance->dwInst, 1,
"API:process_term_cap_set_ind - No valid alternative capabilities found");
MemFree(pSimCap);
lError = H245_ERROR_UNKNOWN;
}
pReqSimCap = pReqSimCap->next;
} // while
while (TempCapDesc.smltnsCpblts)
{
// Move elements from temporary to final linked list
pSimCap = TempCapDesc.smltnsCpblts;
TempCapDesc.smltnsCpblts = pSimCap->next;
pSimCap->next = pCapDesc->smltnsCpblts;
pCapDesc->smltnsCpblts = pSimCap;
}
// Error if no simultaneous capabilities found
if (pCapDesc->smltnsCpblts)
{
pCapDesc->bit_mask |= smltnsCpblts_present;
}
else
{
H245TRACE(pInstance->dwInst, 1,
"API:process_term_cap_set_ind - No simultaneous capabilities found");
lError = H245_ERROR_UNKNOWN;
}
return lError;
}
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: process_term_cap_set_ind__mux_cap
*
* DESCRIPTION
*
*
* RETURN:
*
* NOTES:
* We do a copy to set up a capability structure, then do another copy via
* H245CopyCap() to create a copy of the capability because the structure
* given to us by the ASN.1 decoded may contain pointers to data which will
* be deallocated upon return.
*
*****************************************************************************/
static HRESULT
process_term_cap_set_ind__mux_cap (struct InstanceStruct *pInstance,
struct TerminalCapabilitySet *pTermCapSet,
MultiplexCapability * pReqMuxCap,
MltmdSystmCntrlMssg *p_pdu_rsp)
{
H245_TOTCAP_T TotCap;
// Initialize temporary capability structure
memset(&TotCap, 0, sizeof(TotCap));
TotCap.Dir = H245_CAPDIR_RMTRXTX;
TotCap.DataType = H245_DATA_MUX;
// Get rid of old remote multiplex capability, if any
if (pTermCapSet->bit_mask & multiplexCapability_present)
{
del_mux_cap(pTermCapSet);
}
switch (pReqMuxCap->choice)
{
case MltplxCpblty_nonStandard_chosen:
// Save a copy of the multiplex capability
TotCap.Cap.H245Mux_NONSTD = pReqMuxCap->u.MltplxCpblty_nonStandard;
TotCap.ClientType = H245_CLIENT_MUX_NONSTD;
H245TRACE(pInstance->dwInst,1,"API:process_term_cap_set_ind__mux_cap - Nonstandard Mux not yet supported");
break;
case h222Capability_chosen:
// Save a copy of the multiplex capability
TotCap.Cap.H245Mux_H222 = pReqMuxCap->u.h222Capability;
TotCap.ClientType = H245_CLIENT_MUX_H222;
break;
case h223Capability_chosen:
// Save a copy of the multiplex capability
TotCap.Cap.H245Mux_H223 = pReqMuxCap->u.h223Capability;
TotCap.ClientType = H245_CLIENT_MUX_H223;
break;
case v76Capability_chosen:
// Save a copy of the multiplex capability
TotCap.Cap.H245Mux_VGMUX = pReqMuxCap->u.v76Capability;
TotCap.ClientType = H245_CLIENT_MUX_VGMUX;
break;
case h2250Capability_chosen:
// Save a copy of the multiplex capability
TotCap.Cap.H245Mux_H2250 = pReqMuxCap->u.h2250Capability;
TotCap.ClientType = H245_CLIENT_MUX_H2250;
break;
default:
H245TRACE(pInstance->dwInst,1,"API:process_term_cap_set_ind__mux_cap - invalid mux cap type %d",
&pReqMuxCap->choice);
return H245_ERROR_NOSUP;
}
return set_mux_cap(pInstance, pTermCapSet, &TotCap);
}
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: process_term_cap_set_ind
*
* DESCRIPTION
*
**************************************************************
*
* (TBD) .. this module will ack all terminal capbilities
* need to build reject.. (maybe later??)
*
* THIS IS A BIG TBD
*
**************************************************************
*
* RETURN:
*
*****************************************************************************/
static HRESULT
process_term_cap_set_ind (struct InstanceStruct *pInstance,
MltmdSystmCntrlMssg *p_pdu_req,
MltmdSystmCntrlMssg *p_pdu_rsp)
{
HRESULT lError = H245_ERROR_OK;
TerminalCapabilitySet *pTermCapSet;
ASSERT (p_pdu_req->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.choice == terminalCapabilitySet_chosen);
H245TRACE(pInstance->dwInst,10,"API:process_term_cap_set_ind <-");
/* build ack response */
p_pdu_rsp->choice = MSCMg_rspns_chosen;
p_pdu_rsp->u.MSCMg_rspns.choice = terminalCapabilitySetAck_chosen;
p_pdu_rsp->u.MSCMg_rspns.u.terminalCapabilitySetAck.sequenceNumber =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.terminalCapabilitySet.sequenceNumber;
pTermCapSet = &pInstance->API.PDU_RemoteTermCap.u.MltmdSystmCntrlMssg_rqst.u.terminalCapabilitySet;
//***************************
// Deal with Capability Table
//***************************
if (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.terminalCapabilitySet.bit_mask & capabilityTable_present)
{
CapabilityTableLink pCapTable = p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.terminalCapabilitySet.capabilityTable;
if (pCapTable->value.capability.choice == Capability_nonStandard_chosen &&
pCapTable->value.capability.u.Capability_nonStandard.nonStandardIdentifier.choice == h221NonStandard_chosen &&
pCapTable->value.capability.u.Capability_nonStandard.nonStandardIdentifier.u.h221NonStandard.t35CountryCode == 0xB5 &&
pCapTable->value.capability.u.Capability_nonStandard.nonStandardIdentifier.u.h221NonStandard.t35Extension == 0x42 &&
pCapTable->value.capability.u.Capability_nonStandard.nonStandardIdentifier.u.h221NonStandard.manufacturerCode == 0x8080)
{
pInstance->bMasterSlaveKludge = TRUE;
pCapTable = pCapTable->next;
}
lError = process_term_cap_set_ind__cap_table(pInstance,
pTermCapSet,
pCapTable,
p_pdu_rsp);
if (lError != H245_ERROR_OK)
{
H245TRACE(pInstance->dwInst,1,"API:process_term_cap_set_ind - cap table error %s",map_api_error(lError));
/* (TBC) need to reject somehow */
}
} /* if Capability Table Present */
//**************************************
// Deal with Capability Descriptor Table
// i.e. simultaneous capabilities
// NOTE: these are not held in the remote terminal capbility set
//**************************************
if (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.terminalCapabilitySet.bit_mask & capabilityDescriptors_present)
{
int des_cnt;
int ii;
des_cnt = p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.terminalCapabilitySet.capabilityDescriptors.count;
H245TRACE(pInstance->dwInst,20,"API:process_term_cap_set_ind - %d Simultaneous Capabilities",des_cnt);
for (ii = 0; ii < des_cnt; ++ii)
{
lError = process_term_cap_set_ind__cap_desc (pInstance,
pTermCapSet,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.
terminalCapabilitySet.capabilityDescriptors.value[ii],
p_pdu_rsp);
if (lError != H245_ERROR_OK)
{
H245TRACE(pInstance->dwInst,1,"API:process_term_cap_set_ind - cap desc error %s",map_api_error(lError));
/* (TBC) need to reject somehow */
}
} /* for each descriptor */
} /* if capability descriptor present */
/**************************************/
/* Deal with Multiplex Capability set */
/**************************************/
/* NOTE: these are not held in the remote terminal capability set */
if (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.terminalCapabilitySet.bit_mask & multiplexCapability_present)
{
/* send up the indication to the client for each new entry */
lError = process_term_cap_set_ind__mux_cap(pInstance,
pTermCapSet,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.
terminalCapabilitySet.multiplexCapability,
p_pdu_rsp);
if (lError != H245_ERROR_OK)
{
H245TRACE(pInstance->dwInst,1,"API:process_term_cap_set_ind - mux cap error %s",map_api_error(lError));
/* (TBC) need to reject somehow */
}
}
H245TRACE(pInstance->dwInst,10,"API:process_term_cap_set_ind -> OK");
return H245_ERROR_OK;
}
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: process_open_ind
*
* DESCRIPTION
*
* RETURN:
*
* ASSUME:
* Callback must happen inside this routine since the
* datastructures passed back to the application are allocated
* in this moudle.
*
* Application will <<<COPY>>> the needed data structures when
* callback occurs..
*
*****************************************************************************/
static HRESULT
process_open_ind (struct InstanceStruct *pInstance,
MltmdSystmCntrlMssg *p_pdu_req,
unsigned short *p_FwdChan, /* for return on error */
H245_ACC_REJ_T *p_AccRej, /* for return error */
H245_CONF_IND_T *p_conf_ind) /* out */
{
static H245_TOTCAP_T rx_totcap; /* for receive caps */
static H245_TOTCAP_T tx_totcap; /* for transmit caps */
static H245_MUX_T RxMux;
static H245_MUX_T TxMux;
unsigned short choice; /* tmp for type of cap to routine */
HRESULT lError;
Tracker_T *p_tracker;
H245TRACE(pInstance->dwInst,10,"API:process_open_ind <-");
*p_AccRej = H245_ACC;
/********************************/
/* check for forward parameters */
/********************************/
/* get forward Rx channel id */
p_conf_ind->u.Indication.u.IndOpen.RxChannel =
*p_FwdChan =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelNumber;
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - channel = %d",p_conf_ind->u.Indication.u.IndOpen.RxChannel);
/* get port number */
if (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.forwardLogicalChannelParameters.bit_mask & fLCPs_prtNmbr_present)
{
p_conf_ind->u.Indication.u.IndOpen.RxPort =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelParameters.fLCPs_prtNmbr;
}
else
p_conf_ind->u.Indication.u.IndOpen.RxPort = H245_INVALID_PORT_NUMBER;
/* ok.. forward data type selection */
switch (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelParameters.dataType.choice)
{
case DataType_nonStandard_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Rx nonStandard");
/* (TBD) what do I do here ?? */
*p_AccRej = H245_REJ_TYPE_NOTSUPPORT;
return H245_ERROR_NOSUP;
case nullData_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Rx nullData");
/* (TBD) what do I do here ?? */
*p_AccRej = H245_REJ_TYPE_NOTSUPPORT;
return H245_ERROR_NOSUP;
break;
case DataType_videoData_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Rx videoData");
p_conf_ind->u.Indication.u.IndOpen.RxDataType = H245_DATA_VIDEO;
choice =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.forwardLogicalChannelParameters.dataType.
u.DataType_videoData.choice;
break;
case DataType_audioData_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Rx audioData");
p_conf_ind->u.Indication.u.IndOpen.RxDataType = H245_DATA_AUDIO;
choice =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.forwardLogicalChannelParameters.dataType.
u.DataType_audioData.choice;
break;
case DataType_data_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Rx dataData");
p_conf_ind->u.Indication.u.IndOpen.RxDataType = H245_DATA_DATA;
choice =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.forwardLogicalChannelParameters.dataType.
u.DataType_data.application.choice;
break;
case encryptionData_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Rx encryptionData");
/* (TBC) what do I do here ?? */
*p_AccRej = H245_REJ_TYPE_NOTSUPPORT;
return H245_ERROR_NOSUP;
break;
default:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Rx encryptionData");
/* (TBC) what do I do here ?? */
*p_AccRej = H245_REJ_TYPE_UNKNOWN;
return H245_ERROR_NOSUP;
break;
}
/* load the tot cap's capability and client from capability */
/* this will give us the client type and the Capability for the indication */
if ((lError = build_totcap_cap_n_client_from_capability ((struct Capability *)
&(p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.forwardLogicalChannelParameters.dataType),
p_conf_ind->u.Indication.u.IndOpen.RxDataType,
choice,
&rx_totcap)) != H245_ERROR_OK)
{
*p_AccRej = H245_REJ_TYPE_NOTSUPPORT;
return lError;
}
/* load it from the totcap you just built.. then toss it aside.. like an empty can of soda.. */
p_conf_ind->u.Indication.u.IndOpen.RxClientType = rx_totcap.ClientType;
p_conf_ind->u.Indication.u.IndOpen.pRxCap = &(rx_totcap.Cap);
/* H.223/H.222 Mux table parameters for forward channel */
p_conf_ind->u.Indication.u.IndOpen.pRxMux = &RxMux;
switch (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.forwardLogicalChannelParameters.multiplexParameters.choice)
{
case fLCPs_mPs_h223LCPs_chosen:
/* H.223 Logical Parameters */
p_conf_ind->u.Indication.u.IndOpen.pRxMux->Kind = H245_H223;
lError = load_H223_param(&RxMux.u.H223,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelParameters.multiplexParameters.u.fLCPs_mPs_h223LCPs);
if (lError != H245_ERROR_OK)
{
*p_AccRej = H245_REJ_AL_COMB;
return lError;
}
break;
case fLCPs_mPs_h222LCPs_chosen:
/* H.222 Logical Parameters */
p_conf_ind->u.Indication.u.IndOpen.pRxMux->Kind = H245_H222;
lError = load_H222_param(&RxMux.u.H222,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelParameters.multiplexParameters.u.fLCPs_mPs_h222LCPs);
break;
case fLCPs_mPs_v76LCPs_chosen:
/* VGMUX Logical Parameters */
p_conf_ind->u.Indication.u.IndOpen.pRxMux->Kind = H245_VGMUX;
lError =load_VGMUX_param(&RxMux.u.VGMUX,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelParameters.multiplexParameters.u.fLCPs_mPs_v76LCPs);
break;
case fLCPs_mPs_h2250LCPs_chosen:
/* H.225.0 Logical Parameters */
p_conf_ind->u.Indication.u.IndOpen.pRxMux->Kind = H245_H2250;
lError = load_H2250_param(&RxMux.u.H2250,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelParameters.multiplexParameters.u.fLCPs_mPs_h2250LCPs);
break;
default:
lError = H245_ERROR_NOSUP;
} // switch
if (lError != H245_ERROR_OK)
{
*p_AccRej = H245_REJ;
return lError;
}
/********************************/
/* check for reverse parameters */
/********************************/
if (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.bit_mask & OLCl_rLCPs_present)
{
switch (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.OLCl_rLCPs.dataType.choice)
{
case DataType_nonStandard_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Tx nonStandard");
/* (TBC) what do I do here ?? */
*p_AccRej = H245_REJ_TYPE_NOTSUPPORT;
return H245_ERROR_NOSUP;
case nullData_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Tx nullData");
/* (TBC) what do I do here ?? */
*p_AccRej = H245_REJ_TYPE_NOTSUPPORT;
return H245_ERROR_NOSUP;
break;
case DataType_videoData_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Tx videoData");
p_conf_ind->u.Indication.u.IndOpen.TxDataType = H245_DATA_VIDEO;
choice =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.OLCl_rLCPs.dataType.u.DataType_videoData.choice;
break;
case DataType_audioData_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Tx audioData");
p_conf_ind->u.Indication.u.IndOpen.TxDataType = H245_DATA_AUDIO;
choice =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.OLCl_rLCPs.dataType.u.DataType_audioData.choice;
break;
case DataType_data_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Tx dataData");
p_conf_ind->u.Indication.u.IndOpen.TxDataType = H245_DATA_DATA;
choice =
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.OLCl_rLCPs.dataType.u.DataType_data.application.choice;
break;
case encryptionData_chosen:
H245TRACE(pInstance->dwInst,20,"API:process_open_ind - Tx encryptionData");
/* (TBC) what do I do here ?? */
*p_AccRej = H245_REJ_TYPE_NOTSUPPORT;
return H245_ERROR_NOSUP;
break;
default:
/* (TBC) what do I do here ?? */
*p_AccRej = H245_REJ_TYPE_UNKNOWN;
H245TRACE(pInstance->dwInst,1,"API:process_open_ind - unknown choice %d",
p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.OLCl_rLCPs.dataType.choice);
return H245_ERROR_NOSUP;
}
/* load the tot cap's capability and client from capability */
if ((lError = build_totcap_cap_n_client_from_capability ((struct Capability *)
&(p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.OLCl_rLCPs.dataType),
p_conf_ind->u.Indication.u.IndOpen.TxDataType,
choice,
&tx_totcap)) != H245_ERROR_OK)
{
*p_AccRej = H245_REJ_TYPE_NOTSUPPORT;
return lError;
}
p_conf_ind->u.Indication.u.IndOpen.TxClientType = tx_totcap.ClientType;
p_conf_ind->u.Indication.u.IndOpen.pTxCap = &(tx_totcap.Cap);
/* if H223/H222 Mux table parameters for reverse channel availalbe */
if (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.OLCl_rLCPs.bit_mask & OLCl_rLCPs_mltplxPrmtrs_present)
{
switch (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.OLCl_rLCPs.OLCl_rLCPs_mltplxPrmtrs.choice)
{
case rLCPs_mPs_h223LCPs_chosen:
p_conf_ind->u.Indication.u.IndOpen.pTxMux = &TxMux;
p_conf_ind->u.Indication.u.IndOpen.pTxMux->Kind = H245_H223;
lError = load_H223_param(&TxMux.u.H223,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.
OLCl_rLCPs.OLCl_rLCPs_mltplxPrmtrs.u.rLCPs_mPs_h223LCPs);
if (lError != H245_ERROR_OK)
{
*p_AccRej = H245_REJ_AL_COMB;
return H245_ERROR_NOSUP;
}
break;
case rLCPs_mPs_v76LCPs_chosen:
p_conf_ind->u.Indication.u.IndOpen.pTxMux = &TxMux;
p_conf_ind->u.Indication.u.IndOpen.pTxMux->Kind = H245_VGMUX;
lError = load_VGMUX_param(&TxMux.u.VGMUX,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.
OLCl_rLCPs.OLCl_rLCPs_mltplxPrmtrs.u.rLCPs_mPs_v76LCPs);
break;
case rLCPs_mPs_h2250LCPs_chosen:
p_conf_ind->u.Indication.u.IndOpen.pTxMux = &TxMux;
p_conf_ind->u.Indication.u.IndOpen.pTxMux->Kind = H245_H2250;
lError = load_H2250_param(&TxMux.u.H2250,
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.
OLCl_rLCPs.OLCl_rLCPs_mltplxPrmtrs.u.rLCPs_mPs_h2250LCPs);
break;
default:
lError = H245_ERROR_NOSUP;
}
if (lError != H245_ERROR_OK)
{
*p_AccRej = H245_REJ;
return lError;
}
} /* if H223/H222 mux table reverse parameters */
} /* if reverse parameters present */
if (p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.bit_mask & OpnLgclChnnl_sprtStck_present)
{
p_conf_ind->u.Indication.u.IndOpen.pSeparateStack =
&p_pdu_req->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.OpnLgclChnnl_sprtStck;
}
/* conflict resolution .. just do it now.. */
/* only on opens.. of same data type .. */
#if 0
#ifndef LOOPBACK
/* if master */
if (pInstance->API.MasterSlave == APIMS_Master)
{
p_tracker = NULL;
while (p_tracker = find_tracker_by_type (dwInst, API_OPEN_CHANNEL_T, p_tracker))
{
/* if allocated locally .. and incoming */
/* data type == outstanding incoming */
/* there is a conflict */
if ((p_tracker->u.Channel.ChannelAlloc == API_CH_ALLOC_LCL) &&
(p_tracker->u.Channel.DataType == p_conf_ind->u.Indication.u.IndOpen.RxDataType))
{
*p_AccRej = H245_REJ;
return H245_ERROR_INVALID_OP;
} /* if conflict */
} /* while */
} /* if master */
#endif /* LOOPBACK */
#endif
/* setup a tracker for this guy. */
p_tracker = alloc_link_tracker (pInstance,
API_OPEN_CHANNEL_T,
0,
API_ST_WAIT_LCLACK,
API_CH_ALLOC_RMT,
(p_pdu_req->u.MltmdSystmCntrlMssg_rqst.
u.openLogicalChannel.bit_mask & OLCl_rLCPs_present)?API_CH_TYPE_BI:API_CH_TYPE_UNI,
p_conf_ind->u.Indication.u.IndOpen.RxDataType,
H245_INVALID_CHANNEL,
p_conf_ind->u.Indication.u.IndOpen.RxChannel,
0);
if (!(p_tracker))
{
H245TRACE(pInstance->dwInst,1,"API:process_open_ind -> %s",map_api_error(H245_ERROR_NOMEM));
*p_AccRej = H245_REJ;
return H245_ERROR_NOMEM;
}
H245TRACE(pInstance->dwInst,10,"API:process_open_ind -> OK");
return H245_ERROR_OK;
}
/*****************************************************************************
*
* TYPE: Local
*
* PROCEDURE: process_bi_open_rsp
*
* DESCRIPTION
*
* RETURN:
*
* ASSUME:
* Callback must happen inside this routine since the
* datastructures passed back to the application are allocated
* in this moudle.
*
* Application will <<<COPY>>> the needed data structures when
* callback occurs..
*
*****************************************************************************/
static HRESULT
process_bi_open_rsp (struct InstanceStruct * pInstance, /* in */
MltmdSystmCntrlMssg *p_pdu_rsp, /* in */
H245_MUX_T *p_RxMux, /* in */
DWORD *p_RxChannel, /* out */
H245_CONF_IND_T *p_conf_ind /* out */
)
{
H245TRACE(pInstance->dwInst,10,"API:process_bi_open_rsp <-");
p_conf_ind->u.Confirm.Error = H245_ERROR_OK;
// Get Reverse Logical Channel Number
*p_RxChannel =
p_conf_ind->u.Confirm.u.ConfOpenNeedRsp.RxChannel =
p_pdu_rsp->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_rLCPs.reverseLogicalChannelNumber;
// Get Reverse Port Number
if (p_pdu_rsp->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_rLCPs.bit_mask & rLCPs_prtNmbr_present)
{
p_conf_ind->u.Confirm.u.ConfOpenNeedRsp.RxPort =
p_pdu_rsp->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_rLCPs.rLCPs_prtNmbr;
}
if (p_pdu_rsp->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_rLCPs.bit_mask & OLCAk_rLCPs_mPs_present)
{
// Get Reverse Logical Channel ACK Parameters
switch (p_pdu_rsp->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_rLCPs.OLCAk_rLCPs_mPs.choice)
{
case rLCPs_mPs_h222LCPs_chosen:
p_RxMux->Kind = H245_H222;
p_conf_ind->u.Confirm.Error = load_H222_param(&p_RxMux->u.H222,
&p_pdu_rsp->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_rLCPs.OLCAk_rLCPs_mPs.u.rLCPs_mPs_h222LCPs);
p_conf_ind->u.Confirm.u.ConfOpenNeedRsp.pRxMux = p_RxMux;
break;
case mPs_h2250LgclChnnlPrmtrs_chosen:
p_RxMux->Kind = H245_H2250ACK;
p_conf_ind->u.Confirm.Error = load_H2250_param(&p_RxMux->u.H2250,
&p_pdu_rsp->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_rLCPs.OLCAk_rLCPs_mPs.u. mPs_h2250LgclChnnlPrmtrs);
p_conf_ind->u.Confirm.u.ConfOpenNeedRsp.pRxMux = p_RxMux;
break;
default:
H245TRACE(pInstance->dwInst,1,"API:process_bi_open_rsp - unknown choice %d",
p_pdu_rsp->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_rLCPs.OLCAk_rLCPs_mPs.choice);
p_conf_ind->u.Confirm.Error = H245_ERROR_NOSUP;
} // switch
}
H245TRACE(pInstance->dwInst,10,"API:process_bi_open_rsp -> OK");
return H245_ERROR_OK;
}
WORD awObject[64];
unsigned int ArrayFromObject(WORD *pwObject, unsigned uSize, POBJECTID pObject)
{
register unsigned int uLength = 0;
while (pObject)
{
if (uLength >= uSize)
{
H245TRACE(0,1,"API:ArrayFromObject Object ID too long");
return uLength;
}
pwObject[uLength++] = (WORD) pObject->value;
pObject = pObject->next;
}
return uLength;
} // ArrayFromObject()
/*****************************************************************************
*
* TYPE: Callback
*
* PROCEDURE:
*
* DESCRIPTION
*
*
* RETURN:
*
*****************************************************************************/
static Tracker_T *
TrackerValidate(struct InstanceStruct *pInstance, DWORD_PTR dwTransId)
{
register Tracker_T *pTracker = (Tracker_T *)dwTransId;
if (find_tracker_by_pointer (pInstance, pTracker) != pTracker)
{
H245TRACE(pInstance->dwInst,1,"API:ValidateTracker -> Tracker Not Found");
return NULL;
}
return pTracker;
}
static DWORD_PTR
TranslateTransId(struct InstanceStruct *pInstance, DWORD_PTR dwTransId)
{
register Tracker_T *pTracker = (Tracker_T *)dwTransId;
if (pTracker == NULL)
{
H245TRACE(pInstance->dwInst,1,"API:TranslateTransId -> NULL Tracker");
return 0;
}
if (find_tracker_by_pointer (pInstance, pTracker) != pTracker)
{
H245TRACE(pInstance->dwInst,1,"API:TranslateTransId -> Tracker Not Found");
return 0;
}
return pTracker->TransId;
}
static void
TrackerFree(struct InstanceStruct *pInstance, DWORD_PTR dwTransId)
{
register Tracker_T *pTracker = (Tracker_T *)dwTransId;
if (pTracker == NULL)
{
H245TRACE(pInstance->dwInst,1,"API:TrackerFree -> NULL Tracker");
return;
}
if (find_tracker_by_pointer (pInstance, pTracker) != pTracker)
{
H245TRACE(pInstance->dwInst,1,"API:TrackerFree -> Tracker Not Found");
return;
}
unlink_dealloc_tracker (pInstance, pTracker);
}
static DWORD_PTR
TranslateAndFree(struct InstanceStruct *pInstance, DWORD_PTR dwTransId)
{
register Tracker_T *pTracker = (Tracker_T *)dwTransId;
if (pTracker == NULL)
{
H245TRACE(pInstance->dwInst,1,"API:TranslateAndFree -> NULL Tracker");
return 0;
}
if (find_tracker_by_pointer (pInstance, pTracker) != pTracker)
{
H245TRACE(pInstance->dwInst,1,"API:TranslateAndFree -> Tracker Not Found");
return 0;
}
dwTransId = pTracker->TransId;
unlink_dealloc_tracker (pInstance, pTracker);
return dwTransId;
}
static void
TrackerNewState(struct InstanceStruct *pInstance, DWORD_PTR dwTransId, int nNewState)
{
register Tracker_T *pTracker = (Tracker_T *)dwTransId;
if (pTracker == NULL)
{
H245TRACE(pInstance->dwInst,1,"API:TrackerNewState -> NULL Tracker");
return;
}
if (find_tracker_by_pointer (pInstance, pTracker) != pTracker)
{
H245TRACE(pInstance->dwInst,1,"API:TrackerNewState -> Tracker Not Found");
return;
}
pTracker->State = nNewState;
}
static WORD
GetRxChannel(struct InstanceStruct *pInstance, DWORD_PTR dwTransId)
{
register Tracker_T *pTracker = (Tracker_T *)dwTransId;
if (pTracker == NULL)
{
H245TRACE(pInstance->dwInst,1,"API:GetRxChannel -> NULL Tracker");
return 0;
}
if (find_tracker_by_pointer (pInstance, pTracker) != pTracker)
{
H245TRACE(pInstance->dwInst,1,"API:GetRxChannel -> Tracker Not Found");
return 0;
}
return (WORD)pTracker->u.Channel.RxChannel;
}
static WORD
GetTxChannel(struct InstanceStruct *pInstance, DWORD_PTR dwTransId)
{
register Tracker_T *pTracker = (Tracker_T *)dwTransId;
if (pTracker == NULL)
{
H245TRACE(pInstance->dwInst,1,"API:GetTxChannel -> NULL Tracker");
return 0;
}
if (find_tracker_by_pointer (pInstance, pTracker) != pTracker)
{
H245TRACE(pInstance->dwInst,1,"API:GetTxChannel -> Tracker Not Found");
return 0;
}
return (WORD)pTracker->u.Channel.TxChannel;
}
HRESULT
H245FunctionNotUnderstood(struct InstanceStruct *pInstance, PDU_T *pPdu)
{
HRESULT hr = H245_ERROR_OK;
MltmdSystmCntrlMssg *pMmPdu = NULL;
pMmPdu = (MltmdSystmCntrlMssg *) MemAlloc(sizeof(MltmdSystmCntrlMssg));
if(NULL == pMmPdu)
{
return H245_ERROR_NOMEM;
}
memset(pMmPdu, 0, sizeof(MltmdSystmCntrlMssg));
pMmPdu->choice = indication_chosen;
pMmPdu->u.indication.choice = functionNotUnderstood_chosen;
pMmPdu->u.indication.u.functionNotUnderstood.choice = pPdu->choice;
switch (pPdu->choice)
{
case FnctnNtUndrstd_request_chosen:
pMmPdu->u.indication.u.functionNotUnderstood.u.FnctnNtUndrstd_request =
pPdu->u.MltmdSystmCntrlMssg_rqst;
break;
case FnctnNtUndrstd_response_chosen:
pMmPdu->u.indication.u.functionNotUnderstood.u.FnctnNtUndrstd_response =
pPdu->u.MSCMg_rspns;
break;
case FnctnNtUndrstd_command_chosen:
pMmPdu->u.indication.u.functionNotUnderstood.u.FnctnNtUndrstd_command =
pPdu->u.MSCMg_cmmnd;
default:
MemFree(pMmPdu);
return H245_ERROR_OK;
}
hr = sendPDU(pInstance, pMmPdu);
MemFree(pMmPdu);
return hr;
} // H245FunctionNotUnderstood()
HRESULT
H245FsmConfirm (PDU_t * pPdu,
DWORD dwEvent,
struct InstanceStruct * pInstance,
DWORD_PTR dwTransId,
HRESULT lError)
{
H245_CONF_IND_T ConfInd;
DWORD dwIndex;
H245_MUX_T TxMux;
H245_MUX_T RxMux;
HRESULT lResult = H245_ERROR_OK;
ASSERT(pInstance != NULL);
ASSERT(pInstance->API.ConfIndCallBack != NULL);
H245TRACE(pInstance->dwInst,4,"H245FsmConfirm <- Event=%s (%d)",
map_fsm_event(dwEvent),dwEvent);
memset (&ConfInd, 0, sizeof(ConfInd));
ConfInd.Kind = H245_CONF;
ConfInd.u.Confirm.Confirm = dwEvent;
ConfInd.u.Confirm.dwPreserved = pInstance->API.dwPreserved;
ConfInd.u.Confirm.dwTransId = dwTransId;
ConfInd.u.Confirm.Error = lError;
switch (dwEvent)
{
/******************************/
/* */
/* master slave determination */
/* */
/******************************/
case H245_CONF_INIT_MSTSLV:
ConfInd.u.Confirm.dwTransId = TranslateAndFree(pInstance, dwTransId);
/* handle errors */
switch (lError)
{
case H245_ERROR_OK:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == mstrSlvDtrmntnAck_chosen);
pInstance->API.SystemState = APIST_Connected;
if (pPdu->u.MSCMg_rspns.u.mstrSlvDtrmntnAck.decision.choice == master_chosen)
{
pInstance->API.MasterSlave = APIMS_Master;
ConfInd.u.Confirm.u.ConfMstSlv = H245_MASTER;
}
else
{
pInstance->API.MasterSlave = APIMS_Slave;
ConfInd.u.Confirm.u.ConfMstSlv = H245_SLAVE;
}
break;
case REJECT:
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Master Slave Reject");
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
ConfInd.u.Confirm.u.ConfMstSlv = H245_INDETERMINATE;
break;
case TIMER_EXPIRY:
case ERROR_D_TIMEOUT:
case ERROR_F_TIMEOUT:
ConfInd.u.Confirm.Error = H245_ERROR_TIMEOUT;
ConfInd.u.Confirm.u.ConfMstSlv = H245_INDETERMINATE;
break;
// case FUNCT_NOT_SUP:
// case ERROR_A_INAPPROPRIATE:
// case ERROR_B_INAPPROPRIATE:
// case ERROR_C_INAPPROPRIATE:
// case MS_FAILED:
default:
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Master Slave Error %d", lError);
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
ConfInd.u.Confirm.u.ConfMstSlv = H245_INDETERMINATE;
break;
}
break;
/****************************************/
/* */
/* Terminal Capability exchange confirm */
/* */
/****************************************/
case H245_CONF_SEND_TERMCAP:
ConfInd.u.Confirm.dwTransId = TranslateAndFree(pInstance, dwTransId);
/* determine errors */
switch (lError)
{
case H245_ERROR_OK:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == terminalCapabilitySetAck_chosen);
ConfInd.u.Confirm.u.ConfSndTcap.AccRej = H245_ACC;
clean_cap_table(&pInstance->API.PDU_LocalTermCap.u.MltmdSystmCntrlMssg_rqst.u.terminalCapabilitySet);
break;
case REJECT:
ConfInd.u.Confirm.Error = H245_ERROR_OK;
ConfInd.u.Confirm.u.ConfSndTcap.AccRej = H245_REJ;
break;
case TIMER_EXPIRY:
case ERROR_D_TIMEOUT:
case ERROR_F_TIMEOUT:
ConfInd.u.Confirm.Error = H245_ERROR_TIMEOUT;
break;
// case FUNCT_NOT_SUP:
// case ERROR_A_INAPPROPRIATE:
// case ERROR_B_INAPPROPRIATE:
// case ERROR_C_INAPPROPRIATE:
default:
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Term Cap Error %d", lError);
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
break;
}
break;
/***************************************/
/* */
/* unidirectional logical channel open */
/* */
/***************************************/
case H245_CONF_OPEN:
ConfInd.u.Confirm.dwTransId = TranslateTransId(pInstance, dwTransId);
ConfInd.u.Confirm.u.ConfOpen.TxChannel = GetTxChannel(pInstance, dwTransId);
ConfInd.u.Confirm.u.ConfOpen.RxPort = H245_INVALID_PORT_NUMBER;
/* determine errors */
switch (lError)
{
case H245_ERROR_OK:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == openLogicalChannelAck_chosen);
ASSERT((pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.bit_mask & OLCAk_rLCPs_present) == 0);
if (pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.bit_mask & OLCAk_sprtStck_present)
{
ConfInd.u.Confirm.u.ConfOpen.pSeparateStack =
&pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_sprtStck;
}
if (pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.bit_mask & frwrdMltplxAckPrmtrs_present)
{
switch (pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.frwrdMltplxAckPrmtrs.choice)
{
case h2250LgclChnnlAckPrmtrs_chosen:
TxMux.Kind = H245_H2250ACK;
load_H2250ACK_param(&TxMux.u.H2250ACK,
&pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.frwrdMltplxAckPrmtrs.u.h2250LgclChnnlAckPrmtrs);
ConfInd.u.Confirm.u.ConfOpen.pTxMux = &TxMux;
break;
} // switch
}
ConfInd.u.Confirm.u.ConfOpen.AccRej = H245_ACC;
TrackerNewState(pInstance,dwTransId,API_ST_IDLE);
break;
case REJECT:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == openLogicalChannelReject_chosen);
ConfInd.u.Confirm.Error = H245_ERROR_OK;
ConfInd.u.Confirm.u.ConfOpen.AccRej =
pPdu->u.MSCMg_rspns.u.openLogicalChannelReject.cause.choice;
TrackerFree(pInstance,dwTransId);
break;
case TIMER_EXPIRY:
case ERROR_D_TIMEOUT:
case ERROR_F_TIMEOUT:
ConfInd.u.Confirm.Error = H245_ERROR_TIMEOUT;
ConfInd.u.Confirm.u.ConfOpen.AccRej = H245_REJ;
TrackerFree(pInstance,dwTransId);
break;
// case FUNCT_NOT_SUP:
// case ERROR_A_INAPPROPRIATE:
// case ERROR_B_INAPPROPRIATE:
// case ERROR_C_INAPPROPRIATE:
default:
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Open Channel Error %d", lError);
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
ConfInd.u.Confirm.u.ConfOpen.AccRej = H245_REJ;
TrackerFree(pInstance,dwTransId);
}
break;
/***********************************************/
/* */
/* bidirectional logical channel open (TBD)??? */
/* */
/***********************************************/
case H245_CONF_NEEDRSP_OPEN:
{
Tracker_T *pTracker;
pTracker = TrackerValidate(pInstance, dwTransId);
if (pTracker == NULL)
return H245_ERROR_OK;
ConfInd.u.Confirm.dwTransId = pTracker->TransId;
ConfInd.u.Confirm.u.ConfOpenNeedRsp.TxChannel = (WORD)pTracker->u.Channel.TxChannel;
ConfInd.u.Confirm.u.ConfOpenNeedRsp.RxPort = H245_INVALID_PORT_NUMBER;
/* determine errors */
switch (lError)
{
case H245_ERROR_OK:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == openLogicalChannelAck_chosen);
ASSERT((pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.bit_mask & OLCAk_rLCPs_present) != 0);
ConfInd.u.Confirm.u.ConfOpenNeedRsp.AccRej = H245_ACC;
if (pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.bit_mask & OLCAk_sprtStck_present)
{
ConfInd.u.Confirm.u.ConfOpenNeedRsp.pSeparateStack =
&pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.OLCAk_sprtStck;
}
if (pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.bit_mask & frwrdMltplxAckPrmtrs_present)
{
switch (pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.frwrdMltplxAckPrmtrs.choice)
{
case h2250LgclChnnlAckPrmtrs_chosen:
TxMux.Kind = H245_H2250ACK;
load_H2250ACK_param(&TxMux.u.H2250ACK,
&pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.frwrdMltplxAckPrmtrs.u.h2250LgclChnnlAckPrmtrs);
ConfInd.u.Confirm.u.ConfOpenNeedRsp.pTxMux = &TxMux;
break;
} // switch
}
/* NOTE Receive Channel is assigned in this call */
process_bi_open_rsp (pInstance,
pPdu,
&RxMux,
&(pTracker->u.Channel.RxChannel),
&ConfInd);
/* NOTE: this is a special case since we have to assign */
/* the receive channel to the tracker.. otherwise we */
/* will not be able to find it later.. */
/* Here we have to update both the state, and the channel */
pTracker->State = API_ST_WAIT_CONF;
break;
case REJECT:
ConfInd.u.Confirm.Confirm = H245_CONF_OPEN;
ConfInd.u.Confirm.u.ConfOpen.TxChannel = (WORD)pTracker->u.Channel.TxChannel;
ConfInd.u.Confirm.Error = H245_ERROR_OK;
ConfInd.u.Confirm.u.ConfOpen.AccRej =
pPdu->u.MSCMg_rspns.u.openLogicalChannelReject.cause.choice;
unlink_dealloc_tracker (pInstance, pTracker);
break;
case TIMER_EXPIRY:
case ERROR_D_TIMEOUT:
case ERROR_F_TIMEOUT:
ConfInd.u.Confirm.Confirm = H245_CONF_OPEN;
ConfInd.u.Confirm.u.ConfOpen.TxChannel = (WORD)pTracker->u.Channel.TxChannel;
ConfInd.u.Confirm.Error = H245_ERROR_TIMEOUT;
ConfInd.u.Confirm.u.ConfOpen.AccRej = H245_REJ;
unlink_dealloc_tracker (pInstance, pTracker);
break;
// case FUNCT_NOT_SUP:
// case ERROR_A_INAPPROPRIATE:
// case ERROR_B_INAPPROPRIATE:
// case ERROR_C_INAPPROPRIATE:
default:
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Open Channel Error %d", lError);
ConfInd.u.Confirm.Confirm = H245_CONF_OPEN;
ConfInd.u.Confirm.u.ConfOpen.TxChannel = (WORD)pTracker->u.Channel.TxChannel;
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
ConfInd.u.Confirm.u.ConfOpen.AccRej = H245_REJ;
unlink_dealloc_tracker (pInstance, pTracker);
}
}
break;
/************************************************/
/* */
/* unidirectional logical channel close */
/* */
/* bidirection logical channel close */
/* */
/************************************************/
case H245_CONF_CLOSE:
ConfInd.u.Confirm.dwTransId = TranslateTransId(pInstance, dwTransId);
ConfInd.u.Confirm.u.ConfClose.Channel = GetTxChannel(pInstance, dwTransId);
ConfInd.u.Confirm.u.ConfClose.AccRej = H245_ACC;
/* determine errors */
switch (lError)
{
case H245_ERROR_OK:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == closeLogicalChannelAck_chosen);
ConfInd.u.Confirm.u.ConfClose.AccRej = H245_ACC;
TrackerFree(pInstance,dwTransId);
break;
case REJECT:
/* should never be rejected */
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Close Channel Rejected");
TrackerNewState(pInstance,dwTransId,API_ST_IDLE);
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
ConfInd.u.Confirm.u.ConfClose.AccRej = H245_REJ;
break;
case TIMER_EXPIRY:
case ERROR_D_TIMEOUT:
case ERROR_F_TIMEOUT:
TrackerNewState(pInstance,dwTransId,API_ST_IDLE);
ConfInd.u.Confirm.Error = H245_ERROR_TIMEOUT;
ConfInd.u.Confirm.u.ConfClose.AccRej = H245_REJ;
break;
// case FUNCT_NOT_SUP:
// case ERROR_A_INAPPROPRIATE:
// case ERROR_B_INAPPROPRIATE:
// case ERROR_C_INAPPROPRIATE:
default:
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Close Channel Error %d", lError);
TrackerNewState(pInstance,dwTransId,API_ST_IDLE);
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
ConfInd.u.Confirm.u.ConfClose.AccRej = H245_REJ;
}
break;
/***************************/
/* */
/* request channel close */
/* */
/***************************/
case H245_CONF_REQ_CLOSE:
ConfInd.u.Confirm.dwTransId = TranslateTransId(pInstance, dwTransId);
ConfInd.u.Confirm.u.ConfReqClose.Channel = GetRxChannel(pInstance, dwTransId);
TrackerNewState(pInstance,dwTransId,API_ST_IDLE);
/* determine errors */
switch (lError)
{
case H245_ERROR_OK:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == requestChannelCloseAck_chosen);
ConfInd.u.Confirm.u.ConfReqClose.AccRej = H245_ACC;
break;
case REJECT:
ConfInd.u.Confirm.Error = H245_ERROR_OK;
ConfInd.u.Confirm.u.ConfReqClose.AccRej = H245_REJ;
break;
case TIMER_EXPIRY:
case ERROR_D_TIMEOUT:
case ERROR_F_TIMEOUT:
ConfInd.u.Confirm.Error = H245_ERROR_TIMEOUT;
ConfInd.u.Confirm.u.ConfReqClose.AccRej = H245_REJ;
break;
// case FUNCT_NOT_SUP:
// case ERROR_A_INAPPROPRIATE:
// case ERROR_B_INAPPROPRIATE:
// case ERROR_C_INAPPROPRIATE:
default:
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Request Channel Close Error %d", lError);
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
ConfInd.u.Confirm.u.ConfReqClose.AccRej = H245_REJ;
}
break;
/*******************/
/* */
/* mux table entry */
/* */
/*******************/
case H245_CONF_MUXTBL_SND:
{
UINT ii;
Tracker_T *pTracker;
pTracker = TrackerValidate(pInstance, dwTransId);
if (pTracker == NULL)
return H245_ERROR_OK;
ConfInd.u.Confirm.dwTransId = pTracker->TransId;
switch (lError)
{
case H245_ERROR_OK:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == multiplexEntrySendAck_chosen);
for (ii = 0;
ii < pPdu->u.MSCMg_rspns.u.multiplexEntrySendAck.multiplexTableEntryNumber.count;
ii ++)
{
pTracker->u.MuxEntryCount--;
ConfInd.u.Confirm.u.ConfMuxSnd.MuxEntryId =
pPdu->u.MSCMg_rspns.u.multiplexEntrySendAck.multiplexTableEntryNumber.value[ii];
ConfInd.u.Confirm.u.ConfMuxSnd.AccRej = H245_ACC;
if ((*pInstance->API.ConfIndCallBack)(&ConfInd, &pPdu->u.MSCMg_rspns.u.multiplexEntrySendAck) == H245_ERROR_NOSUP)
{
H245FunctionNotUnderstood(pInstance, pPdu);
}
pTracker = TrackerValidate(pInstance, dwTransId);
if (pTracker == NULL)
return H245_ERROR_OK;
}
if (pTracker->u.MuxEntryCount == 0)
{
unlink_dealloc_tracker (pInstance, pTracker);
}
pPdu = NULL; // Don't do callback again!
break;
case REJECT:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == multiplexEntrySendReject_chosen);
ConfInd.u.Confirm.Error = H245_ERROR_OK;
for (ii = 0;
ii < pPdu->u.MSCMg_rspns.u.multiplexEntrySendReject.rejectionDescriptions.count;
++ii)
{
pTracker->u.MuxEntryCount--;
ConfInd.u.Confirm.u.ConfMuxSnd.MuxEntryId =
pPdu->u.MSCMg_rspns.u.multiplexEntrySendReject.rejectionDescriptions.value[ii].multiplexTableEntryNumber;
switch (pPdu->u.MSCMg_rspns.u.multiplexEntrySendReject.rejectionDescriptions.value[ii].cause.choice)
{
default:
H245PANIC();
case MERDs_cs_unspcfdCs_chosen:
ConfInd.u.Confirm.u.ConfMuxSnd.AccRej = H245_REJ; /* unspecified */
break;
case descriptorTooComplex_chosen:
ConfInd.u.Confirm.u.ConfMuxSnd.AccRej = H245_REJ_MUX_COMPLICATED;
break;
}
if ((*pInstance->API.ConfIndCallBack)(&ConfInd, &pPdu->u.MSCMg_rspns.u.multiplexEntrySendReject) == H245_ERROR_NOSUP)
{
H245FunctionNotUnderstood(pInstance, pPdu);
}
pTracker = TrackerValidate(pInstance, dwTransId);
if (pTracker == NULL)
return H245_ERROR_OK;
}
if (pTracker->u.MuxEntryCount == 0)
{
unlink_dealloc_tracker (pInstance, pTracker);
}
pPdu = NULL; // Don't do callback again!
break;
case TIMER_EXPIRY:
case ERROR_D_TIMEOUT:
case ERROR_F_TIMEOUT:
unlink_dealloc_tracker (pInstance, pTracker);
ConfInd.u.Confirm.Error = H245_ERROR_TIMEOUT;
break;
// case FUNCT_NOT_SUP:
// case ERROR_A_INAPPROPRIATE:
// case ERROR_B_INAPPROPRIATE:
// case ERROR_C_INAPPROPRIATE:
default:
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm - Mux Table Send Error %d", lError);
unlink_dealloc_tracker (pInstance, pTracker);
ConfInd.u.Confirm.Error = H245_ERROR_UNKNOWN;
} // switch
}
break;
case H245_CONF_RMESE:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == requestMultiplexEntryAck_chosen);
ConfInd.u.Confirm.u.ConfRmese.dwCount =
pPdu->u.MSCMg_rspns.u.requestMultiplexEntryAck.entryNumbers.count;
for (dwIndex = 0; dwIndex < ConfInd.u.Confirm.u.ConfRmese.dwCount; ++dwIndex)
{
ConfInd.u.Confirm.u.ConfRmese.awMultiplexTableEntryNumbers[dwIndex] =
pPdu->u.MSCMg_rspns.u.requestMultiplexEntryAck.entryNumbers.value[dwIndex];
}
break;
case H245_CONF_RMESE_REJECT:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == rqstMltplxEntryRjct_chosen);
ConfInd.u.Confirm.u.ConfRmeseReject.dwCount =
pPdu->u.MSCMg_rspns.u.rqstMltplxEntryRjct.rejectionDescriptions.count;
for (dwIndex = 0; dwIndex < ConfInd.u.Confirm.u.ConfRmeseReject.dwCount; ++dwIndex)
{
ConfInd.u.Confirm.u.ConfRmeseReject.awMultiplexTableEntryNumbers[dwIndex] =
pPdu->u.MSCMg_rspns.u.rqstMltplxEntryRjct.rejectionDescriptions.value[dwIndex].multiplexTableEntryNumber;
}
break;
case H245_CONF_RMESE_EXPIRED:
ASSERT(pPdu == NULL);
break;
case H245_CONF_MRSE:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == requestModeAck_chosen);
ConfInd.u.Confirm.u.ConfMrse =
pPdu->u.MSCMg_rspns.u.requestModeAck.response.choice;
break;
case H245_CONF_MRSE_REJECT:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == requestModeReject_chosen);
ConfInd.u.Confirm.u.ConfMrseReject =
pPdu->u.MSCMg_rspns.u.requestModeReject.cause.choice;
break;
case H245_CONF_MRSE_EXPIRED:
ASSERT(pPdu == NULL);
break;
case H245_CONF_MLSE:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == maintenanceLoopAck_chosen);
ConfInd.u.Confirm.u.ConfMlse.LoopType =
pPdu->u.MSCMg_rspns.u.maintenanceLoopAck.type.choice;
switch (pPdu->u.MSCMg_rspns.u.maintenanceLoopAck.type.choice)
{
case systemLoop_chosen:
ConfInd.u.Confirm.u.ConfMlse.Channel = 0;
break;
case mediaLoop_chosen:
case logicalChannelLoop_chosen:
ConfInd.u.Confirm.u.ConfMlse.Channel =
pPdu->u.MSCMg_rspns.u.maintenanceLoopAck.type.u.mediaLoop;
break;
default:
H245TRACE(pInstance->dwInst,1,
"H245FsmConfirm: Invalid Maintenance Loop Ack type %d",
pPdu->u.MSCMg_rspns.u.maintenanceLoopAck.type.choice);
lResult = H245_ERROR_NOSUP;
} // switch
break;
case H245_CONF_MLSE_REJECT:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == maintenanceLoopReject_chosen);
ConfInd.u.Confirm.u.ConfMlseReject.LoopType =
pPdu->u.MSCMg_rspns.u.maintenanceLoopReject.type.choice;
switch (pPdu->u.MSCMg_rspns.u.maintenanceLoopReject.type.choice)
{
case systemLoop_chosen:
ConfInd.u.Confirm.u.ConfMlseReject.Channel = 0;
break;
case mediaLoop_chosen:
case logicalChannelLoop_chosen:
ConfInd.u.Confirm.u.ConfMlseReject.Channel =
pPdu->u.MSCMg_rspns.u.maintenanceLoopReject.type.u.mediaLoop;
break;
default:
H245TRACE(pInstance->dwInst,1,
"H245FsmConfirm: Invalid Maintenance Loop Reject type %d",
pPdu->u.MSCMg_rspns.u.maintenanceLoopReject.type.choice);
lResult = H245_ERROR_NOSUP;
} // switch
break;
case H245_CONF_MLSE_EXPIRED:
ASSERT(pPdu == NULL);
break;
case H245_CONF_RTDSE:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == roundTripDelayResponse_chosen);
break;
case H245_CONF_RTDSE_EXPIRED:
ASSERT(pPdu == NULL);
break;
default:
/* Possible Error */
H245TRACE(pInstance->dwInst, 1,
"H245FsmConfirm -> Invalid Confirm Event %d",
dwEvent);
return H245_ERROR_SUBSYS;
} // switch
if (lResult == H245_ERROR_OK)
{
if (pPdu)
{
if ((*pInstance->API.ConfIndCallBack)(&ConfInd, &pPdu->u.MSCMg_rspns.u) == H245_ERROR_NOSUP)
{
H245FunctionNotUnderstood(pInstance, pPdu);
}
}
else
{
(*pInstance->API.ConfIndCallBack)(&ConfInd, NULL);
}
H245TRACE(pInstance->dwInst,4,"H245FsmConfirm -> OK");
}
else
{
H245TRACE(pInstance->dwInst,1,"H245FsmConfirm -> %s", map_api_error(lResult));
}
return lResult;
} // H245FsmConfirm()
HRESULT
H245FsmIndication (PDU_t * pPdu,
DWORD dwEvent,
struct InstanceStruct * pInstance,
DWORD_PTR dwTransId,
HRESULT lError)
{
H245_CONF_IND_T ConfInd;
DWORD dwIndex;
MltmdSystmCntrlMssg *pRsp;
HRESULT lResult = H245_ERROR_OK;
#if 1
int nLength;
WCHAR * pwchar = NULL;
#endif
ASSERT(dwEvent == H245_IND_OPEN_CONF || pPdu != NULL);
ASSERT(pInstance != NULL);
ASSERT(pInstance->API.ConfIndCallBack != NULL);
H245TRACE(pInstance->dwInst,4,"H245FsmIndication <- Event=%s (%d)",
map_fsm_event(dwEvent),dwEvent);
memset (&ConfInd, 0, sizeof(ConfInd));
ConfInd.Kind = H245_IND;
ConfInd.u.Indication.Indicator = dwEvent;
ConfInd.u.Indication.dwPreserved = pInstance->API.dwPreserved;
switch (dwEvent)
{
/******************************/
/* */
/* master slave determination */
/* */
/******************************/
case H245_IND_MSTSLV:
/* handle errors */
switch (lError)
{
case H245_ERROR_OK:
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == mstrSlvDtrmntnAck_chosen);
pInstance->API.SystemState = APIST_Connected;
if (pPdu->u.MSCMg_rspns.u.mstrSlvDtrmntnAck.decision.choice == master_chosen)
{
pInstance->API.MasterSlave = APIMS_Master;
ConfInd.u.Indication.u.IndMstSlv = H245_MASTER;
}
else
{
pInstance->API.MasterSlave = APIMS_Slave;
ConfInd.u.Indication.u.IndMstSlv = H245_SLAVE;
}
break;
case MS_FAILED:
case REJECT:
case TIMER_EXPIRY:
ConfInd.u.Indication.u.IndMstSlv = H245_INDETERMINATE;
break;
// case ERROR_D_TIMEOUT:
// case ERROR_F_TIMEOUT:
// case FUNCT_NOT_SUP:
// case ERROR_A_INAPPROPRIATE:
// case ERROR_B_INAPPROPRIATE:
// case ERROR_C_INAPPROPRIATE:
default:
H245PANIC();
/* (TBC) */
return H245_ERROR_OK;
}
break;
/****************************************/
/* */
/* Terminal Capability exchange */
/* */
/****************************************/
/* decode_termcapset breaks the termcap set up and sends up */
/* a single indication to the client */
case H245_IND_CAP:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == terminalCapabilitySet_chosen);
pRsp = (PDU_t *)MemAlloc(sizeof(*pPdu));
if (pRsp == NULL)
{
H245TRACE(pInstance->dwInst,1,"H245FsmIndication TermCap: no memory for response");
return H245_ERROR_NOMEM;
}
memset(pRsp, 0, sizeof(*pRsp));
process_term_cap_set_ind (pInstance, pPdu, pRsp);
FsmOutgoing(pInstance, pRsp, 0);
MemFree (pRsp);
break;
case H245_IND_CESE_RELEASE:
break;
/************************************************/
/* */
/* unidirectional logical channel open */
/* */
/* bidirectional logical channel open */
/* */
/************************************************/
case H245_IND_OPEN:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == openLogicalChannel_chosen);
{
unsigned short forward_channel;
H245_ACC_REJ_T acc_rej;
/* if error, process_open_ind will tell us what to send for reject */
if (process_open_ind(pInstance,pPdu,&forward_channel,&acc_rej,&ConfInd) != H245_ERROR_OK)
{
// Reject the open
pRsp = (PDU_t *)MemAlloc(sizeof(*pPdu));
if (pRsp == NULL)
{
H245TRACE(pInstance->dwInst,1,"H245FsmIndication TermCap: no memory for response");
return H245_ERROR_NOMEM;
}
memset(pRsp, 0, sizeof(*pRsp));
pdu_rsp_open_logical_channel_rej(pRsp, forward_channel, (WORD)acc_rej);
FsmOutgoing(pInstance, pRsp, 0);
MemFree (pRsp);
}
}
break;
/************************************************/
/* */
/* Confirm bi-directional open */
/* */
/************************************************/
case H245_IND_OPEN_CONF:
#if defined(_DEBUG)
if (lError == H245_ERROR_OK)
{
ASSERT(pPdu != NULL);
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == opnLgclChnnlCnfrm_chosen);
}
#endif
{
Tracker_T *pTracker;
pTracker = TrackerValidate(pInstance, dwTransId);
if (pTracker == NULL)
return H245_ERROR_OK;
/* confirm processing */
ASSERT(pTracker->State == API_ST_WAIT_CONF);
ASSERT(pTracker->TrackerType == API_OPEN_CHANNEL_T);
ASSERT(pTracker->u.Channel.ChannelAlloc == API_CH_ALLOC_RMT);
ASSERT(pTracker->u.Channel.ChannelType == API_CH_TYPE_BI);
ConfInd.u.Indication.u.IndOpenConf.RxChannel = (WORD)pTracker->u.Channel.RxChannel;
ConfInd.u.Indication.u.IndOpenConf.TxChannel = (WORD)pTracker->u.Channel.TxChannel;
pTracker->State = API_ST_IDLE;
}
break;
/************************************************/
/* */
/* unidirectional logical channel close */
/* */
/* bidirectional logical channel close */
/* */
/************************************************/
case H245_IND_CLOSE:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == closeLogicalChannel_chosen);
{
Tracker_T *pTracker;
ConfInd.u.Indication.u.IndClose.Channel =
pPdu->u.MltmdSystmCntrlMssg_rqst.u.closeLogicalChannel.forwardLogicalChannelNumber;
ConfInd.u.Indication.u.IndClose.Reason =
(pPdu->u.MltmdSystmCntrlMssg_rqst.u.closeLogicalChannel.source.choice==user_chosen)?H245_USER:H245_LCSE;
/* find the tracker */
pTracker = find_tracker_by_rxchannel (pInstance,
ConfInd.u.Indication.u.IndClose.Channel,
API_CH_ALLOC_RMT);
if (!pTracker)
{
H245TRACE(pInstance->dwInst,4,"H245FsmIndication -> close indication - Tracker not found");
return H245_ERROR_OK;
}
unlink_dealloc_tracker (pInstance, pTracker);
}
break;
/************************************************/
/* */
/* request channel close */
/* */
/************************************************/
case H245_IND_REQ_CLOSE:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == requestChannelClose_chosen);
{
Tracker_T *pTracker;
ConfInd.u.Indication.u.IndReqClose =
pPdu->u.MltmdSystmCntrlMssg_rqst.u.requestChannelClose.forwardLogicalChannelNumber;
/* find the tracker */
pTracker = find_tracker_by_txchannel (pInstance,
ConfInd.u.Indication.u.IndReqClose,
API_CH_ALLOC_LCL);
if (!pTracker)
{
H245TRACE(pInstance->dwInst,4,"H245FsmIndication Request Channel Close: Tracker not found");
pRsp = (PDU_t *)MemAlloc(sizeof(*pPdu));
if (pRsp == NULL)
{
H245TRACE(pInstance->dwInst,1,"H245FsmIndication Request Channel Close: no memory for response");
return H245_ERROR_NOMEM;
}
memset(pRsp, 0, sizeof(*pRsp));
/* can't find it.. must be closed.. respond anyway */
pdu_rsp_request_channel_close_rej(pRsp, (WORD)ConfInd.u.Indication.u.IndReqClose,H245_REJ);
FsmOutgoing(pInstance, pRsp, 0);
MemFree(pRsp);
/* Possible Error.. could have been removed from list or */
/* could have been allocated remotely... and this is a protocol */
/* error */
return H245_ERROR_OK;
}
ASSERT(pTracker->State == API_ST_IDLE);
pTracker->State = API_ST_WAIT_LCLACK;
pTracker->TrackerType = API_CLOSE_CHANNEL_T;
}
break;
/************************************************/
/* */
/* Release Close Request */
/* */
/************************************************/
case H245_IND_CLCSE_RELEASE:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == rqstChnnlClsRls_chosen);
{
Tracker_T *pTracker;
/* find tracker.. and set to LCLACK_CANCEL */
/* this will tell api to notify user */
pTracker = find_tracker_by_txchannel (pInstance,
pPdu->u.indication.u.rqstChnnlClsRls.forwardLogicalChannelNumber,
API_CH_ALLOC_LCL);
if (pTracker)
{
if (pTracker->State != API_ST_WAIT_LCLACK)
{
return H245_ERROR_INVALID_INST;
}
pTracker->State = API_ST_WAIT_LCLACK_CANCEL;
}
else
{
H245TRACE(pInstance->dwInst,1,"H245FsmIndication -> IND_REL_CLSE: Cancel.. NO TRACKER FOUND");
}
}
break;
/************************************************/
/* */
/* mux table entry */
/* */
/************************************************/
case H245_IND_MUX_TBL:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == multiplexEntrySend_chosen);
{
unsigned short seq_num;
H245_ACC_REJ_MUX_T rej_mux;
H245_MUX_TABLE_T *p_mux_tbl;
DWORD rej_cnt;
DWORD acc_cnt;
Tracker_T *pTracker;
/* process the mux table entry */
p_mux_tbl = process_mux_table_ind(pPdu,&seq_num,rej_mux,&rej_cnt,&acc_cnt);
if (rej_cnt)
{
/* build the reject pdu from the rej_mux table */
if (!(pRsp = (MltmdSystmCntrlMssg *)MemAlloc(sizeof(MltmdSystmCntrlMssg))))
return H245_ERROR_NOMEM;
memset(pRsp, 0, sizeof(MltmdSystmCntrlMssg));
pdu_rsp_mux_table_rej (pRsp,seq_num,rej_mux,(rej_cnt+acc_cnt));
FsmOutgoing(pInstance, pRsp, 0);
MemFree(pRsp);
}
/* if there are any left to send up. */
if (p_mux_tbl)
{
if (!(pTracker = alloc_link_tracker (pInstance,
API_RECV_MUX_T,
/* use the TransId.. for the sequence number */
seq_num,
API_ST_WAIT_LCLACK,
API_CH_ALLOC_UNDEF,
API_CH_TYPE_UNDEF,
0,
H245_INVALID_CHANNEL, H245_INVALID_CHANNEL,
0)))
{
free_mux_table_list (p_mux_tbl);
H245TRACE(pInstance->dwInst,1,"API:process_open_ind -> %s",map_api_error(H245_ERROR_NOMEM));
/* (TBC) this should be a fatal error */
H245PANIC();
break;
}
pTracker->u.MuxEntryCount = acc_cnt;
ConfInd.u.Indication.u.IndMuxTbl.Count = acc_cnt;
ConfInd.u.Indication.u.IndMuxTbl.pMuxTbl = p_mux_tbl;
if ((*pInstance->API.ConfIndCallBack)(&ConfInd, &pPdu->u.MltmdSystmCntrlMssg_rqst.u) == H245_ERROR_NOSUP)
{
H245FunctionNotUnderstood(pInstance, pPdu);
}
free_mux_table_list (p_mux_tbl);
return H245_ERROR_OK;
}
}
break;
case H245_IND_MTSE_RELEASE:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == mltplxEntrySndRls_chosen);
break;
case H245_IND_RMESE:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == requestMultiplexEntry_chosen);
ConfInd.u.Indication.u.IndRmese.dwCount =
pPdu->u.MltmdSystmCntrlMssg_rqst.u.requestMultiplexEntry.entryNumbers.count;
for (dwIndex = 0; dwIndex < ConfInd.u.Indication.u.IndRmese.dwCount; ++dwIndex)
{
ConfInd.u.Indication.u.IndRmese.awMultiplexTableEntryNumbers[dwIndex] =
pPdu->u.MltmdSystmCntrlMssg_rqst.u.requestMultiplexEntry.entryNumbers.value[dwIndex];
}
break;
case H245_IND_RMESE_RELEASE:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == rqstMltplxEntryRls_chosen);
break;
case H245_IND_MRSE:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == requestMode_chosen);
ConfInd.u.Indication.u.IndMrse.pRequestedModes =
pPdu->u.MltmdSystmCntrlMssg_rqst.u.requestMode.requestedModes;
break;
case H245_IND_MRSE_RELEASE:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == requestModeRelease_chosen);
break;
case H245_IND_MLSE:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == maintenanceLoopRequest_chosen);
ConfInd.u.Indication.u.IndMlse.LoopType =
pPdu->u.MltmdSystmCntrlMssg_rqst.u.maintenanceLoopRequest.type.choice;
if (ConfInd.u.Indication.u.IndMlse.LoopType == systemLoop_chosen)
ConfInd.u.Indication.u.IndMlse.Channel = 0;
else
ConfInd.u.Indication.u.IndMlse.Channel =
pPdu->u.MltmdSystmCntrlMssg_rqst.u.maintenanceLoopRequest.type.u.mediaLoop;
break;
case H245_IND_MLSE_RELEASE:
ASSERT(pPdu->choice == MSCMg_cmmnd_chosen);
ASSERT(pPdu->u.MSCMg_cmmnd.choice == mntnncLpOffCmmnd_chosen);
break;
case H245_IND_NONSTANDARD_REQUEST:
case H245_IND_NONSTANDARD_RESPONSE:
case H245_IND_NONSTANDARD_COMMAND:
case H245_IND_NONSTANDARD:
ConfInd.u.Indication.u.IndNonstandard.pData = pPdu->u.indication.u.IndctnMssg_nonStandard.nonStandardData.data.value;
ConfInd.u.Indication.u.IndNonstandard.dwDataLength = pPdu->u.indication.u.IndctnMssg_nonStandard.nonStandardData.data.length;
switch (pPdu->u.indication.u.IndctnMssg_nonStandard.nonStandardData.nonStandardIdentifier.choice)
{
case object_chosen:
ConfInd.u.Indication.u.IndNonstandard.pwObjectId = awObject;
ConfInd.u.Indication.u.IndNonstandard.dwObjectIdLength =
ArrayFromObject(&awObject[0], sizeof(awObject)/sizeof(awObject[0]),
pPdu->u.indication.u.IndctnMssg_nonStandard.nonStandardData.nonStandardIdentifier.u.object);
ConfInd.u.Indication.u.IndNonstandard.byCountryCode = 0;
ConfInd.u.Indication.u.IndNonstandard.byExtension = 0;
ConfInd.u.Indication.u.IndNonstandard.wManufacturerCode = 0;
break;
case h221NonStandard_chosen:
ConfInd.u.Indication.u.IndNonstandard.pwObjectId = NULL;
ConfInd.u.Indication.u.IndNonstandard.dwObjectIdLength = 0;
ConfInd.u.Indication.u.IndNonstandard.byCountryCode = (BYTE)
pPdu->u.indication.u.IndctnMssg_nonStandard.nonStandardData.nonStandardIdentifier.u.h221NonStandard.t35CountryCode;
ConfInd.u.Indication.u.IndNonstandard.byExtension = (BYTE)
pPdu->u.indication.u.IndctnMssg_nonStandard.nonStandardData.nonStandardIdentifier.u.h221NonStandard.t35Extension;
ConfInd.u.Indication.u.IndNonstandard.wManufacturerCode =
pPdu->u.indication.u.IndctnMssg_nonStandard.nonStandardData.nonStandardIdentifier.u.h221NonStandard.manufacturerCode;
break;
default:
H245TRACE(pInstance->dwInst,1,
"H245FsmIndication: unrecognized nonstandard identifier type %d",
pPdu->u.indication.u.IndctnMssg_nonStandard.nonStandardData.nonStandardIdentifier.choice);
lResult = H245_ERROR_NOSUP;
} // switch
break;
case H245_IND_MISC_COMMAND:
ASSERT(pPdu->choice == MSCMg_cmmnd_chosen);
ASSERT(pPdu->u.MSCMg_cmmnd.choice == miscellaneousCommand_chosen);
break;
case H245_IND_MISC:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == miscellaneousIndication_chosen);
break;
case H245_IND_COMM_MODE_REQUEST:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == communicationModeRequest_chosen);
break;
case H245_IND_COMM_MODE_RESPONSE:
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == cmmnctnMdRspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.u.cmmnctnMdRspns.choice == communicationModeTable_chosen);
{
unsigned int uCount;
CommunicationModeTableLink pLink;
H245_COMM_MODE_ENTRY_T * pTable;
uCount = 0;
pLink = pPdu->u.MSCMg_rspns.u.cmmnctnMdRspns.u.communicationModeTable;
while (pLink)
{
++uCount;
pLink = pLink->next;
}
pTable = MemAlloc(uCount * sizeof(*pTable));
if (pTable)
{
ConfInd.u.Indication.u.IndCommRsp.pTable = pTable;
ConfInd.u.Indication.u.IndCommRsp.byTableCount = (BYTE)uCount;
pLink = pPdu->u.MSCMg_rspns.u.cmmnctnMdRspns.u.communicationModeTable;
while (pLink)
{
lResult = LoadCommModeEntry(pTable, &pLink->value);
if (lResult != H245_ERROR_OK)
{
MemFree(pTable);
return lResult;
}
++pTable;
pLink = pLink->next;
}
if ((*pInstance->API.ConfIndCallBack)(&ConfInd, &pPdu->u.MltmdSystmCntrlMssg_rqst.u) == H245_ERROR_NOSUP)
{
H245FunctionNotUnderstood(pInstance, pPdu);
}
MemFree(pTable);
H245TRACE(pInstance->dwInst,4,"H245FsmIndication -> OK");
return H245_ERROR_OK;
}
lResult = H245_ERROR_NOMEM;
}
break;
case H245_IND_COMM_MODE_COMMAND:
ASSERT(pPdu->choice == MSCMg_cmmnd_chosen);
ASSERT(pPdu->u.MSCMg_cmmnd.choice == communicationModeCommand_chosen);
{
unsigned int uCount;
CommunicationModeCommandLink pLink;
H245_COMM_MODE_ENTRY_T * pTable;
uCount = 0;
pLink = pPdu->u.MSCMg_cmmnd.u.communicationModeCommand.communicationModeTable;
while (pLink)
{
++uCount;
pLink = pLink->next;
}
pTable = MemAlloc(uCount * sizeof(*pTable));
if (pTable)
{
ConfInd.u.Indication.u.IndCommCmd.pTable = pTable;
ConfInd.u.Indication.u.IndCommCmd.byTableCount = (BYTE)uCount;
pLink = pPdu->u.MSCMg_cmmnd.u.communicationModeCommand.communicationModeTable;
while (pLink)
{
lResult = LoadCommModeEntry(pTable, &pLink->value);
if (lResult != H245_ERROR_OK)
{
MemFree(pTable);
return lResult;
}
++pTable;
pLink = pLink->next;
}
{
H245FunctionNotUnderstood(pInstance, pPdu);
}
if ((*pInstance->API.ConfIndCallBack)(&ConfInd, &pPdu->u.MltmdSystmCntrlMssg_rqst.u) == H245_ERROR_NOSUP)
{
H245FunctionNotUnderstood(pInstance, pPdu);
}
MemFree(pTable);
H245TRACE(pInstance->dwInst,4,"H245FsmIndication -> OK");
return H245_ERROR_OK;
}
lResult = H245_ERROR_NOMEM;
}
break;
case H245_IND_CONFERENCE_REQUEST:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == conferenceRequest_chosen);
ConfInd.u.Indication.u.IndConferReq.RequestType =
pPdu->u.MltmdSystmCntrlMssg_rqst.u.conferenceRequest.choice;
ConfInd.u.Indication.u.IndConferReq.byMcuNumber = (BYTE)
pPdu->u.MltmdSystmCntrlMssg_rqst.u.conferenceRequest.u.dropTerminal.mcuNumber;
ConfInd.u.Indication.u.IndConferReq.byTerminalNumber = (BYTE)
pPdu->u.MltmdSystmCntrlMssg_rqst.u.conferenceRequest.u.dropTerminal.terminalNumber;
break;
case H245_IND_CONFERENCE_RESPONSE:
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == conferenceResponse_chosen);
ConfInd.u.Indication.u.IndConferRsp.ResponseType =
pPdu->u.MSCMg_rspns.u.conferenceResponse.choice;
switch (pPdu->u.MSCMg_rspns.u.conferenceResponse.choice)
{
case mCTerminalIDResponse_chosen:
case terminalIDResponse_chosen:
case conferenceIDResponse_chosen:
case passwordResponse_chosen:
ConfInd.u.Indication.u.IndConferRsp.byMcuNumber = (BYTE)
pPdu->u.MSCMg_rspns.u.conferenceResponse.u.mCTerminalIDResponse.terminalLabel.mcuNumber;
ConfInd.u.Indication.u.IndConferRsp.byTerminalNumber = (BYTE)
pPdu->u.MSCMg_rspns.u.conferenceResponse.u.mCTerminalIDResponse.terminalLabel.terminalNumber;
ConfInd.u.Indication.u.IndConferRsp.pOctetString =
pPdu->u.MSCMg_rspns.u.conferenceResponse.u.mCTerminalIDResponse.terminalID.value;
ConfInd.u.Indication.u.IndConferRsp.byOctetStringLength = (BYTE)
pPdu->u.MSCMg_rspns.u.conferenceResponse.u.mCTerminalIDResponse.terminalID.length;
break;
case terminalListResponse_chosen:
ConfInd.u.Indication.u.IndConferRsp.pTerminalList =
pPdu->u.MSCMg_rspns.u.conferenceResponse.u.terminalListResponse.value;
ConfInd.u.Indication.u.IndConferRsp.wTerminalListCount = (WORD)
pPdu->u.MSCMg_rspns.u.conferenceResponse.u.terminalListResponse.count;
break;
case videoCommandReject_chosen:
case terminalDropReject_chosen:
break;
case makeMeChairResponse_chosen:
switch (pPdu->u.MSCMg_rspns.u.conferenceResponse.u.makeMeChairResponse.choice)
{
case grantedChairToken_chosen:
ConfInd.u.Indication.u.IndConferRsp.ResponseType = H245_RSP_GRANTED_CHAIR_TOKEN;
break;
default:
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: Invalid make me chair response %d",
pPdu->u.MSCMg_rspns.u.conferenceResponse.u.makeMeChairResponse.choice);
// Fall-through to next case
case deniedChairToken_chosen:
ConfInd.u.Indication.u.IndConferRsp.ResponseType = H245_RSP_DENIED_CHAIR_TOKEN;
} // switch
break;
default:
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: Invalid Conference Response type %d",
pPdu->u.MSCMg_rspns.u.conferenceResponse.choice);
lResult = H245_ERROR_NOSUP;
} // switch
break;
case H245_IND_CONFERENCE_COMMAND:
ASSERT(pPdu->choice == MSCMg_cmmnd_chosen);
ASSERT(pPdu->u.MSCMg_cmmnd.choice == conferenceCommand_chosen);
ConfInd.u.Indication.u.IndConferCmd.CommandType =
pPdu->u.MSCMg_cmmnd.u.conferenceCommand.choice;
ConfInd.u.Indication.u.IndConferCmd.Channel =
pPdu->u.MSCMg_cmmnd.u.conferenceCommand.u.brdcstMyLgclChnnl;
ConfInd.u.Indication.u.IndConferCmd.byMcuNumber = (BYTE)
pPdu->u.MSCMg_cmmnd.u.conferenceCommand.u.sendThisSource.mcuNumber;
ConfInd.u.Indication.u.IndConferCmd.byTerminalNumber = (BYTE)
pPdu->u.MSCMg_cmmnd.u.conferenceCommand.u.sendThisSource.terminalNumber;
break;
case H245_IND_CONFERENCE:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == conferenceIndication_chosen);
ConfInd.u.Indication.u.IndConfer.IndicationType =
pPdu->u.indication.u.conferenceIndication.choice;
ConfInd.u.Indication.u.IndConfer.bySbeNumber = (BYTE)
pPdu->u.indication.u.conferenceIndication.u.sbeNumber;
ConfInd.u.Indication.u.IndConfer.byMcuNumber = (BYTE)
pPdu->u.indication.u.conferenceIndication.u.terminalNumberAssign.mcuNumber;
ConfInd.u.Indication.u.IndConfer.byTerminalNumber = (BYTE)
pPdu->u.indication.u.conferenceIndication.u.terminalNumberAssign.terminalNumber;
break;
case H245_IND_SEND_TERMCAP:
ASSERT(pPdu->choice == MSCMg_cmmnd_chosen);
ASSERT(pPdu->u.MSCMg_cmmnd.choice == sndTrmnlCpbltySt_chosen);
break;
case H245_IND_ENCRYPTION:
ASSERT(pPdu->choice == MSCMg_cmmnd_chosen);
ASSERT(pPdu->u.MSCMg_cmmnd.choice == encryptionCommand_chosen);
break;
case H245_IND_FLOW_CONTROL:
ASSERT(pPdu->choice == MSCMg_cmmnd_chosen);
ASSERT(pPdu->u.MSCMg_cmmnd.choice == flowControlCommand_chosen);
ConfInd.u.Indication.u.IndFlowControl.Scope =
pPdu->u.MSCMg_cmmnd.u.flowControlCommand.scope.choice;
switch (pPdu->u.MSCMg_cmmnd.u.flowControlCommand.scope.choice)
{
case FCCd_scp_lgclChnnlNmbr_chosen:
ConfInd.u.Indication.u.IndFlowControl.Channel =
pPdu->u.MSCMg_cmmnd.u.flowControlCommand.scope.u.FCCd_scp_lgclChnnlNmbr;
break;
case FlwCntrlCmmnd_scp_rsrcID_chosen:
ConfInd.u.Indication.u.IndFlowControl.wResourceID =
pPdu->u.MSCMg_cmmnd.u.flowControlCommand.scope.u.FlwCntrlCmmnd_scp_rsrcID;
break;
case FCCd_scp_whlMltplx_chosen:
break;
default:
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: Invalid Flow Control restriction %d",
pPdu->u.MSCMg_cmmnd.u.flowControlCommand.restriction.choice);
lResult = H245_ERROR_NOSUP;
} // switch
switch (pPdu->u.MSCMg_cmmnd.u.flowControlCommand.restriction.choice)
{
case maximumBitRate_chosen:
ConfInd.u.Indication.u.IndFlowControl.dwRestriction =
pPdu->u.MSCMg_cmmnd.u.flowControlCommand.restriction.u.maximumBitRate;
break;
case noRestriction_chosen:
ConfInd.u.Indication.u.IndFlowControl.dwRestriction = H245_NO_RESTRICTION;
break;
default:
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: Invalid Flow Control restriction %d",
pPdu->u.MSCMg_cmmnd.u.flowControlCommand.restriction.choice);
lResult = H245_ERROR_NOSUP;
} // switch
break;
case H245_IND_ENDSESSION:
ASSERT(pPdu->choice == MSCMg_cmmnd_chosen);
ASSERT(pPdu->u.MSCMg_cmmnd.choice == endSessionCommand_chosen);
ConfInd.u.Indication.u.IndEndSession.SessionMode = H245_ENDSESSION_DISCONNECT;
switch (pPdu->u.MSCMg_cmmnd.u.endSessionCommand.choice)
{
case EndSssnCmmnd_nonStandard_chosen:
ConfInd.u.Indication.u.IndEndSession.SessionMode = H245_ENDSESSION_NONSTD,
ConfInd.u.Indication.u.IndEndSession.SessionNonStd =
pPdu->u.MSCMg_cmmnd.u.endSessionCommand.u.EndSssnCmmnd_nonStandard;
break;
case disconnect_chosen:
break;
case gstnOptions_chosen:
switch (pPdu->u.MSCMg_cmmnd.u.endSessionCommand.u.gstnOptions.choice)
{
case EndSessionCommand_gstnOptions_telephonyMode_chosen:
ConfInd.u.Indication.u.IndEndSession.SessionMode = H245_ENDSESSION_TELEPHONY;
break;
case v8bis_chosen:
ConfInd.u.Indication.u.IndEndSession.SessionMode = H245_ENDSESSION_V8BIS;
break;
case v34DSVD_chosen:
ConfInd.u.Indication.u.IndEndSession.SessionMode = H245_ENDSESSION_V34DSVD;
break;
case v34DuplexFAX_chosen:
ConfInd.u.Indication.u.IndEndSession.SessionMode = H245_ENDSESSION_V34DUPFAX;
break;
case v34H324_chosen:
ConfInd.u.Indication.u.IndEndSession.SessionMode = H245_ENDSESSION_V34H324;
break;
default:
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: Invalid End Session GSTN options %d",
pPdu->u.MSCMg_cmmnd.u.endSessionCommand.u.gstnOptions.choice);
} // switch
break;
default:
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: Invalid End Session type %d",
pPdu->u.MSCMg_cmmnd.u.endSessionCommand.choice);
} // switch
break;
case H245_IND_FUNCTION_NOT_UNDERSTOOD:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == functionNotUnderstood_chosen);
break;
case H245_IND_JITTER:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == jitterIndication_chosen);
break;
case H245_IND_H223_SKEW:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == h223SkewIndication_chosen);
ConfInd.u.Indication.u.IndH223Skew.LogicalChannelNumber1 =
pPdu->u.indication.u.h223SkewIndication.logicalChannelNumber1;
ConfInd.u.Indication.u.IndH223Skew.LogicalChannelNumber2 =
pPdu->u.indication.u.h223SkewIndication.logicalChannelNumber2;
ConfInd.u.Indication.u.IndH223Skew.wSkew =
pPdu->u.indication.u.h223SkewIndication.skew;
break;
case H245_IND_NEW_ATM_VC:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == newATMVCIndication_chosen);
break;
case H245_IND_USERINPUT:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == userInput_chosen);
ConfInd.u.Indication.u.IndUserInput.Kind =
pPdu->u.indication.u.userInput.choice;
switch (pPdu->u.indication.u.userInput.choice)
{
case UsrInptIndctn_nnStndrd_chosen:
ConfInd.u.Indication.u.IndUserInput.u.NonStd =
pPdu->u.indication.u.userInput.u.UsrInptIndctn_nnStndrd;
break;
case alphanumeric_chosen:
#if 1
nLength = MultiByteToWideChar(CP_ACP, // code page
0, // dwFlags
pPdu->u.indication.u.userInput.u.alphanumeric,
-1, // ASCII string length (in bytes)
NULL, // Unicode string
0); // max Unicode string length
pwchar = MemAlloc(nLength * sizeof(WCHAR));
if (pwchar == NULL)
{
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: no memory for user input", 0);
lResult = H245_ERROR_NOMEM;
}
else
{
nLength = MultiByteToWideChar(CP_ACP, // code page
0, // dwFlags
pPdu->u.indication.u.userInput.u.alphanumeric,
-1, // ASCII string length (in bytes)
pwchar, // Unicode string
nLength); // max Unicode string length
ConfInd.u.Indication.u.IndUserInput.u.pGenString = pwchar;
}
#else
ConfInd.u.Indication.u.IndUserInput.u.pGenString =
pPdu->u.indication.u.userInput.u.alphanumeric;
#endif
break;
default:
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: unrecognized user input type %d",
pPdu->u.indication.u.userInput.choice);
lResult = H245_ERROR_NOSUP;
} // switch
break;
case H245_IND_H2250_MAX_SKEW:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == h2250MxmmSkwIndctn_chosen);
ConfInd.u.Indication.u.IndH2250MaxSkew.LogicalChannelNumber1 =
pPdu->u.indication.u.h2250MxmmSkwIndctn.logicalChannelNumber1;
ConfInd.u.Indication.u.IndH2250MaxSkew.LogicalChannelNumber2 =
pPdu->u.indication.u.h2250MxmmSkwIndctn.logicalChannelNumber2;
ConfInd.u.Indication.u.IndH2250MaxSkew.wSkew =
pPdu->u.indication.u.h2250MxmmSkwIndctn.maximumSkew;
break;
case H245_IND_MC_LOCATION:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == mcLocationIndication_chosen);
lResult = LoadTransportAddress(&ConfInd.u.Indication.u.IndMcLocation,
&pPdu->u.indication.u.mcLocationIndication.signalAddress);
break;
case H245_IND_VENDOR_ID:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == vendorIdentification_chosen);
ConfInd.u.Indication.u.IndVendorId.Identifier =
pPdu->u.indication.u.vendorIdentification.vendor;
if (pPdu->u.indication.u.vendorIdentification.bit_mask & productNumber_present)
{
ConfInd.u.Indication.u.IndVendorId.pProductNumber =
pPdu->u.indication.u.vendorIdentification.productNumber.value;
ConfInd.u.Indication.u.IndVendorId.byProductNumberLength = (BYTE)
pPdu->u.indication.u.vendorIdentification.productNumber.length;
}
if (pPdu->u.indication.u.vendorIdentification.bit_mask & versionNumber_present)
{
ConfInd.u.Indication.u.IndVendorId.pVersionNumber =
pPdu->u.indication.u.vendorIdentification.versionNumber.value;
ConfInd.u.Indication.u.IndVendorId.byVersionNumberLength = (BYTE)
pPdu->u.indication.u.vendorIdentification.versionNumber.length;
}
break;
case H245_IND_FUNCTION_NOT_SUPPORTED:
ASSERT(pPdu->choice == indication_chosen);
ASSERT(pPdu->u.indication.choice == IndicationMessage_functionNotSupported_chosen);
ConfInd.u.Indication.u.IndFns.Cause =
pPdu->u.indication.u.functionNotSupported.cause.choice;
ConfInd.u.Indication.u.IndFns.Type = UNKNOWN;
/*if (pPdu->u.indication.u.functionNotSupported.bit_mask & returnedFunction_present)
{
int pduNum = MltmdSystmCntrlMssg_PDU;
OssBuf ossBuf;
MltmdSystmCntrlMssg *pPduReturned;
ossBuf.value = pPdu->u.indication.u.functionNotSupported.returnedFunction.value;
ossBuf.length = pPdu->u.indication.u.functionNotSupported.returnedFunction.length;
if (ossDecode(pInstance->p_ossWorld,
&pduNum,
&ossBuf,
(void * *)&pPduReturned) == PDU_DECODED)
{
switch (pPduReturned->choice)
{
case MltmdSystmCntrlMssg_rqst_chosen:
ConfInd.u.Indication.u.IndFns.Type =
pPduReturned->u.MltmdSystmCntrlMssg_rqst.choice -
RqstMssg_nonStandard_chosen + REQ_NONSTANDARD;
break;
case MSCMg_rspns_chosen:
ConfInd.u.Indication.u.IndFns.Type =
pPduReturned->u.MSCMg_rspns.choice -
RspnsMssg_nonStandard_chosen + RSP_NONSTANDARD;
break;
case MSCMg_cmmnd_chosen:
ConfInd.u.Indication.u.IndFns.Type =
pPduReturned->u.MSCMg_cmmnd.choice -
CmmndMssg_nonStandard_chosen + CMD_NONSTANDARD;
break;
case indication_chosen:
ConfInd.u.Indication.u.IndFns.Type =
pPduReturned->u.indication.choice -
IndctnMssg_nonStandard_chosen + IND_NONSTANDARD;
break;
default:
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication: unrecognized FunctionNotSupported message type %d",
pPduReturned->choice);
lResult = H245_ERROR_NOSUP;
} // switch
// Free the PDU
if (ossFreePDU(pInstance->p_ossWorld, pduNum, pPduReturned))
{
H245TRACE(pInstance->dwInst, 1, "H245FsmIndication: FREE FAILURE");
}
}
}
*/
break;
#if(0) // this isn't in H245 Version 3. and this code did nothing with it anyway
case H245_IND_H223_RECONFIG:
ASSERT(pPdu->choice == MltmdSystmCntrlMssg_rqst_chosen);
ASSERT(pPdu->u.MltmdSystmCntrlMssg_rqst.choice == h223AnnxARcnfgrtn_chosen);
break;
case H245_IND_H223_RECONFIG_ACK:
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == h223AnnxARcnfgrtnAck_chosen);
break;
case H245_IND_H223_RECONFIG_REJECT:
ASSERT(pPdu->choice == MSCMg_rspns_chosen);
ASSERT(pPdu->u.MSCMg_rspns.choice == h223AnnxARcnfgrtnRjct_chosen);
break;
#endif // if(0)
default:
/* Possible Error */
H245TRACE(pInstance->dwInst, 1,
"H245FsmIndication -> Invalid Indication Event %d", dwEvent);
lResult = H245_ERROR_SUBSYS;
} // switch
#if 1
if (pwchar)
MemFree(pwchar);
#endif
if (lResult == H245_ERROR_OK)
{
if ((*pInstance->API.ConfIndCallBack)(&ConfInd, &pPdu->u.MltmdSystmCntrlMssg_rqst.u) == H245_ERROR_NOSUP)
{
H245FunctionNotUnderstood(pInstance, pPdu);
}
H245TRACE(pInstance->dwInst,4,"H245FsmIndication -> OK");
}
else
{
H245TRACE(pInstance->dwInst,1,"H245FsmIndication -> %s", map_api_error(lResult));
}
return lResult;
} // H245FsmIndication()
Reference in New Issue Copy Permalink