1009 lines
33 KiB
C
1009 lines
33 KiB
C
/***********************************************************************
|
|
* *
|
|
* Filename: pduparse.c *
|
|
* Module: H245 Finite State Machine Subsystem *
|
|
* *
|
|
***********************************************************************
|
|
* INTEL Corporation Proprietary Information *
|
|
* *
|
|
* This listing is supplied under the terms of a license agreement *
|
|
* with INTEL Corporation and may not be copied nor disclosed except *
|
|
* in accordance with the terms of that agreement. *
|
|
* *
|
|
* Copyright (c) 1996 Intel Corporation. All rights reserved. *
|
|
***********************************************************************
|
|
* *
|
|
* $Workfile: PDUPARSE.C $
|
|
* $Revision: 1.6 $
|
|
* $Modtime: 09 Dec 1996 13:36:34 $
|
|
* $Log: S:/STURGEON/SRC/H245/SRC/VCS/PDUPARSE.C_v $
|
|
*
|
|
* Rev 1.6 09 Dec 1996 13:36:56 EHOWARDX
|
|
* Updated copyright notice.
|
|
*
|
|
* Rev 1.5 29 Jul 1996 16:58:08 EHOWARDX
|
|
*
|
|
* Missed some Geneva update PDU types.
|
|
*
|
|
* Rev 1.4 05 Jun 1996 17:15:02 EHOWARDX
|
|
* MaintenanceLoop fix.
|
|
*
|
|
* Rev 1.3 04 Jun 1996 13:58:06 EHOWARDX
|
|
* Fixed Release build warnings.
|
|
*
|
|
* Rev 1.2 29 May 1996 15:20:24 EHOWARDX
|
|
* Change to use HRESULT.
|
|
*
|
|
* Rev 1.1 28 May 1996 14:25:26 EHOWARDX
|
|
* Tel Aviv update.
|
|
*
|
|
* Rev 1.0 09 May 1996 21:06:40 EHOWARDX
|
|
* Initial revision.
|
|
*
|
|
* Rev 1.8.1.4 09 May 1996 19:48:40 EHOWARDX
|
|
* Change TimerExpiryF function arguements.
|
|
*
|
|
* Rev 1.8.1.3 25 Apr 1996 17:00:16 EHOWARDX
|
|
* Minor fixes.
|
|
*
|
|
* Rev 1.8.1.2 15 Apr 1996 10:48:00 EHOWARDX
|
|
* Update.
|
|
*
|
|
* Rev 1.8.1.1 10 Apr 1996 21:15:54 EHOWARDX
|
|
* Check-in for safety in middle of re-design.
|
|
*
|
|
* Rev 1.8.1.0 05 Apr 1996 20:53:06 EHOWARDX
|
|
* Branched.
|
|
* *
|
|
***********************************************************************/
|
|
|
|
#include "precomp.h"
|
|
|
|
#include "h245api.h"
|
|
#include "h245com.h"
|
|
#include "h245fsm.h"
|
|
|
|
/*
|
|
* NAME
|
|
* PduParseIncoming - parse an inbound PDU and determine Entity, Event, etc.
|
|
*
|
|
*
|
|
* PARAMETERS
|
|
* INPUT pInst Pointer to FSM Instance structure
|
|
* INPUT pPdu Pointer to an incoming PDU structure
|
|
* OUTPUT pEntity Pointer to variable to return PDU state entity in
|
|
* OUTPUT pEvent Pointer to variable to return PDU event in
|
|
* OUTPUT pKey Pointer to variable to return lookup key in
|
|
* OUTPUT pbCreate Pointer to variable to return create flag in
|
|
*
|
|
* RETURN VALUE
|
|
* SUCCESS or FAIL
|
|
*/
|
|
|
|
|
|
HRESULT
|
|
PduParseIncoming(struct InstanceStruct *pInstance, PDU_t *pPdu,
|
|
Entity_t *pEntity, Event_t *pEvent, Key_t *pKey, int *pbCreate)
|
|
{
|
|
ASSERT(pInstance != NULL);
|
|
ASSERT(pPdu != NULL);
|
|
ASSERT(pEntity != NULL);
|
|
ASSERT(pEvent != NULL);
|
|
ASSERT(pKey != NULL);
|
|
ASSERT(pbCreate != NULL);
|
|
|
|
// Set default value for key
|
|
*pKey = 0;
|
|
|
|
switch (pPdu->choice)
|
|
{
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// REQUEST
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
case MltmdSystmCntrlMssg_rqst_chosen:
|
|
*pbCreate = TRUE;
|
|
switch (pPdu->u.MltmdSystmCntrlMssg_rqst.choice)
|
|
{
|
|
case RqstMssg_nonStandard_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = NonStandardRequestPDU;
|
|
break;
|
|
|
|
case masterSlaveDetermination_chosen:
|
|
*pEntity = MSDSE;
|
|
*pEvent = MSDetPDU;
|
|
break;
|
|
|
|
case terminalCapabilitySet_chosen:
|
|
*pEntity = CESE_IN;
|
|
*pEvent = TermCapSetPDU;
|
|
break;
|
|
|
|
case openLogicalChannel_chosen:
|
|
if (pPdu->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.bit_mask & OLCl_rLCPs_present)
|
|
{
|
|
*pEntity = BLCSE_IN;
|
|
*pEvent = OpenBChPDU;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_IN;
|
|
*pEvent = OpenUChPDU;
|
|
}
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case closeLogicalChannel_chosen:
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.closeLogicalChannel.forwardLogicalChannelNumber;
|
|
if (ObjectFind(pInstance, BLCSE_IN, *pKey) != NULL)
|
|
{
|
|
*pEntity = BLCSE_IN;
|
|
*pEvent = CloseBChPDU;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_IN;
|
|
*pEvent = CloseUChPDU;
|
|
}
|
|
break;
|
|
|
|
case requestChannelClose_chosen:
|
|
*pEntity = CLCSE_IN;
|
|
*pEvent = ReqChClosePDU;
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.requestChannelClose.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case multiplexEntrySend_chosen:
|
|
*pEntity = MTSE_IN;
|
|
*pEvent = MultiplexEntrySendPDU;
|
|
break;
|
|
|
|
case requestMultiplexEntry_chosen:
|
|
*pEntity = RMESE_IN;
|
|
*pEvent = RequestMultiplexEntryPDU;
|
|
break;
|
|
|
|
case requestMode_chosen:
|
|
*pEntity = MRSE_IN;
|
|
*pEvent = RequestModePDU;
|
|
break;
|
|
|
|
case roundTripDelayRequest_chosen:
|
|
*pEntity = RTDSE;
|
|
*pEvent = RoundTripDelayRequestPDU;
|
|
break;
|
|
|
|
case maintenanceLoopRequest_chosen:
|
|
*pEntity = MLSE_IN;
|
|
*pEvent = MaintenanceLoopRequestPDU;
|
|
switch (pPdu->u.MltmdSystmCntrlMssg_rqst.u.maintenanceLoopRequest.type.choice)
|
|
{
|
|
case systemLoop_chosen:
|
|
break;
|
|
case mediaLoop_chosen:
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.maintenanceLoopRequest.type.u.mediaLoop;
|
|
break;
|
|
case logicalChannelLoop_chosen:
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.maintenanceLoopRequest.type.u.logicalChannelLoop;
|
|
break;
|
|
default:
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
break;
|
|
|
|
case communicationModeRequest_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = CommunicationModeRequestPDU;
|
|
break;
|
|
|
|
case conferenceRequest_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = ConferenceRequestPDU;
|
|
break;
|
|
#if(0) // this is not part of H.245 version 3
|
|
case h223AnnxARcnfgrtn_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = H223ReconfigPDU;
|
|
break;
|
|
#endif // if (0)
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseIncoming: Invalid Request %d",
|
|
pPdu->u.MltmdSystmCntrlMssg_rqst.choice);
|
|
return H245_ERROR_PARAM;
|
|
}
|
|
break;
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// RESPONSE
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
case MSCMg_rspns_chosen:
|
|
*pbCreate = FALSE;
|
|
switch (pPdu->u.MSCMg_rspns.choice)
|
|
{
|
|
case RspnsMssg_nonStandard_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = NonStandardResponsePDU;
|
|
break;
|
|
|
|
case mstrSlvDtrmntnAck_chosen:
|
|
*pEntity = MSDSE;
|
|
*pEvent = MSDetAckPDU;
|
|
break;
|
|
|
|
case mstrSlvDtrmntnRjct_chosen:
|
|
*pEntity = MSDSE;
|
|
*pEvent = MSDetRejectPDU;
|
|
break;
|
|
|
|
case terminalCapabilitySetAck_chosen:
|
|
*pEntity = CESE_OUT;
|
|
*pEvent = TermCapSetAckPDU;
|
|
break;
|
|
|
|
case trmnlCpbltyStRjct_chosen:
|
|
*pEntity = CESE_OUT;
|
|
*pEvent = TermCapSetRejectPDU;
|
|
break;
|
|
|
|
case openLogicalChannelAck_chosen:
|
|
if (pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.bit_mask & OLCAk_rLCPs_present)
|
|
{
|
|
*pEntity = BLCSE_OUT;
|
|
*pEvent = OpenBChAckPDU;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_OUT;
|
|
*pEvent = OpenUChAckPDU;
|
|
}
|
|
*pKey = pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case openLogicalChannelReject_chosen:
|
|
*pKey = pPdu->u.MSCMg_rspns.u.openLogicalChannelReject.forwardLogicalChannelNumber;
|
|
if (ObjectFind(pInstance, BLCSE_OUT, *pKey) != NULL)
|
|
{
|
|
*pEntity = BLCSE_OUT;
|
|
*pEvent = OpenBChRejectPDU;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_OUT;
|
|
*pEvent = OpenUChRejectPDU;
|
|
}
|
|
break;
|
|
|
|
case closeLogicalChannelAck_chosen:
|
|
*pKey = pPdu->u.MSCMg_rspns.u.closeLogicalChannelAck.forwardLogicalChannelNumber;
|
|
if (ObjectFind(pInstance, BLCSE_OUT, *pKey) != NULL)
|
|
{
|
|
*pEntity = BLCSE_OUT;
|
|
*pEvent = CloseBChAckPDU;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_OUT;
|
|
*pEvent = CloseUChAckPDU;
|
|
}
|
|
break;
|
|
|
|
case requestChannelCloseAck_chosen:
|
|
*pEntity = CLCSE_OUT;
|
|
*pEvent = ReqChCloseAckPDU;
|
|
*pKey = pPdu->u.MSCMg_rspns.u.requestChannelCloseAck.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case rqstChnnlClsRjct_chosen:
|
|
*pEntity = CLCSE_OUT;
|
|
*pEvent = ReqChCloseRejectPDU;
|
|
*pKey = pPdu->u.MSCMg_rspns.u.rqstChnnlClsRjct.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case multiplexEntrySendAck_chosen:
|
|
*pEntity = MTSE_OUT;
|
|
*pEvent = MultiplexEntrySendAckPDU;
|
|
break;
|
|
|
|
case multiplexEntrySendReject_chosen:
|
|
*pEntity = MTSE_OUT;
|
|
*pEvent = MultiplexEntrySendRejectPDU;
|
|
break;
|
|
|
|
case requestMultiplexEntryAck_chosen:
|
|
*pEntity = RMESE_OUT;
|
|
*pEvent = RequestMultiplexEntryAckPDU;
|
|
break;
|
|
|
|
case rqstMltplxEntryRjct_chosen:
|
|
*pEntity = RMESE_OUT;
|
|
*pEvent = RequestMultiplexEntryRejectPDU;
|
|
break;
|
|
|
|
case requestModeAck_chosen:
|
|
*pEntity = MRSE_OUT;
|
|
*pEvent = RequestModeAckPDU;
|
|
break;
|
|
|
|
case requestModeReject_chosen:
|
|
*pEntity = MRSE_OUT;
|
|
*pEvent = RequestModeRejectPDU;
|
|
break;
|
|
|
|
case roundTripDelayResponse_chosen:
|
|
*pEntity = RTDSE;
|
|
*pEvent = RoundTripDelayResponsePDU;
|
|
break;
|
|
|
|
case maintenanceLoopAck_chosen:
|
|
*pEntity = MLSE_OUT;
|
|
*pEvent = MaintenanceLoopAckPDU;
|
|
switch (pPdu->u.MSCMg_rspns.u.maintenanceLoopAck.type.choice)
|
|
{
|
|
case systemLoop_chosen:
|
|
break;
|
|
case mediaLoop_chosen:
|
|
*pKey = pPdu->u.MSCMg_rspns.u.maintenanceLoopAck.type.u.mediaLoop;
|
|
break;
|
|
case logicalChannelLoop_chosen:
|
|
*pKey = pPdu->u.MSCMg_rspns.u.maintenanceLoopAck.type.u.logicalChannelLoop;
|
|
break;
|
|
default:
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
break;
|
|
|
|
case maintenanceLoopReject_chosen:
|
|
*pEntity = MLSE_OUT;
|
|
*pEvent = MaintenanceLoopRejectPDU;
|
|
switch (pPdu->u.MSCMg_rspns.u.maintenanceLoopReject.type.choice)
|
|
{
|
|
case systemLoop_chosen:
|
|
break;
|
|
case mediaLoop_chosen:
|
|
*pKey = pPdu->u.MSCMg_rspns.u.maintenanceLoopReject.type.u.mediaLoop;
|
|
break;
|
|
case logicalChannelLoop_chosen:
|
|
*pKey = pPdu->u.MSCMg_rspns.u.maintenanceLoopReject.type.u.logicalChannelLoop;
|
|
break;
|
|
default:
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
break;
|
|
|
|
case cmmnctnMdRspns_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = CommunicationModeResponsePDU;
|
|
break;
|
|
|
|
case conferenceResponse_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = ConferenceResponsePDU;
|
|
break;
|
|
#if(0) // this is not part of H.245 version 3
|
|
case h223AnnxARcnfgrtnAck_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = H223ReconfigAckPDU;
|
|
break;
|
|
|
|
case h223AnnxARcnfgrtnRjct_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = H223ReconfigRejectPDU;
|
|
break;
|
|
#endif // if(0)
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseIncoming: Invalid Response %d",
|
|
pPdu->u.MSCMg_rspns.choice);
|
|
return H245_ERROR_PARAM;
|
|
}
|
|
break;
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// COMMAND
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
case MSCMg_cmmnd_chosen:
|
|
*pbCreate = FALSE;
|
|
switch (pPdu->u.MSCMg_cmmnd.choice)
|
|
{
|
|
case CmmndMssg_nonStandard_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = NonStandardCommandPDU;
|
|
break;
|
|
|
|
case mntnncLpOffCmmnd_chosen:
|
|
*pEntity = MLSE_IN;
|
|
*pEvent = MaintenanceLoopOffCommandPDU;
|
|
break;
|
|
|
|
case sndTrmnlCpbltySt_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = SendTerminalCapabilitySetPDU;
|
|
*pbCreate = TRUE;
|
|
break;
|
|
|
|
case encryptionCommand_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = EncryptionCommandPDU;
|
|
break;
|
|
|
|
case flowControlCommand_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = FlowControlCommandPDU;
|
|
break;
|
|
|
|
case endSessionCommand_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = EndSessionCommandPDU;
|
|
break;
|
|
|
|
case miscellaneousCommand_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = MiscellaneousCommandPDU;
|
|
break;
|
|
|
|
case communicationModeCommand_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = CommunicationModeCommandPDU;
|
|
break;
|
|
|
|
case conferenceCommand_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = ConferenceCommandPDU;
|
|
break;
|
|
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseIncoming: Invalid Command %d",
|
|
pPdu->u.MSCMg_cmmnd.choice);
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
break;
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// INDICATION
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
case indication_chosen:
|
|
*pbCreate = FALSE;
|
|
switch (pPdu->u.indication.choice)
|
|
{
|
|
case IndctnMssg_nonStandard_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = NonStandardIndicationPDU;
|
|
break;
|
|
|
|
case functionNotUnderstood_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = FunctionNotUnderstoodPDU;
|
|
break;
|
|
|
|
case mstrSlvDtrmntnRls_chosen:
|
|
*pEntity = MSDSE;
|
|
*pEvent = MSDetReleasePDU;
|
|
break;
|
|
|
|
case trmnlCpbltyStRls_chosen:
|
|
*pEntity = CESE_IN;
|
|
*pEvent = TermCapSetReleasePDU;
|
|
break;
|
|
|
|
case opnLgclChnnlCnfrm_chosen:
|
|
*pEntity = BLCSE_IN;
|
|
*pEvent = OpenBChConfirmPDU;
|
|
*pKey = pPdu->u.indication.u.opnLgclChnnlCnfrm.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case rqstChnnlClsRls_chosen:
|
|
*pEntity = CLCSE_IN;
|
|
*pEvent = ReqChCloseReleasePDU;
|
|
*pKey = pPdu->u.indication.u.rqstChnnlClsRls.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case mltplxEntrySndRls_chosen:
|
|
*pEntity = MTSE_IN;
|
|
*pEvent = MultiplexEntrySendReleasePDU;
|
|
break;
|
|
|
|
case rqstMltplxEntryRls_chosen:
|
|
*pEntity = RMESE_IN;
|
|
*pEvent = RequestMultiplexEntryReleasePDU;
|
|
break;
|
|
|
|
case requestModeRelease_chosen:
|
|
*pEntity = MRSE_IN;
|
|
*pEvent = RequestModeReleasePDU;
|
|
break;
|
|
|
|
case miscellaneousIndication_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = MiscellaneousIndicationPDU;
|
|
break;
|
|
|
|
case jitterIndication_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = JitterIndicationPDU;
|
|
break;
|
|
|
|
case h223SkewIndication_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = H223SkewIndicationPDU;
|
|
break;
|
|
|
|
case newATMVCIndication_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = NewATMVCIndicationPDU;
|
|
break;
|
|
|
|
case userInput_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = UserInputIndicationPDU;
|
|
break;
|
|
|
|
case h2250MxmmSkwIndctn_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = H2250MaximumSkewIndicationPDU;
|
|
break;
|
|
|
|
case mcLocationIndication_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = MCLocationIndicationPDU;
|
|
break;
|
|
|
|
case conferenceIndication_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = ConferenceIndicationPDU;
|
|
break;
|
|
|
|
case vendorIdentification_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = VendorIdentificationPDU;
|
|
break;
|
|
|
|
case IndicationMessage_functionNotSupported_chosen:
|
|
*pEntity = STATELESS;
|
|
*pEvent = FunctionNotSupportedPDU;
|
|
break;
|
|
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseIncoming: Invalid Indication %d",
|
|
pPdu->u.indication.choice);
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
break;
|
|
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseIncoming: Invalid Message Type %d",
|
|
pPdu->choice);
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
|
|
return H245_ERROR_OK;
|
|
} // PduParseIncoming()
|
|
|
|
|
|
|
|
/*
|
|
* NAME
|
|
* PduParseOutgoing - parse an outbound PDU and determine Entity, Event, etc.
|
|
*
|
|
* PARAMETERS
|
|
* INPUT pInst Pointer to FSM Instance structure
|
|
* INPUT pPdu Pointer to an incoming PDU structure
|
|
* OUTPUT pEntity Pointer to variable to return PDU state entity in
|
|
* OUTPUT pEvent Pointer to variable to return PDU event in
|
|
* OUTPUT pKey Pointer to variable to return lookup key in
|
|
* OUTPUT pbCreate Pointer to variable to return create flag in
|
|
*
|
|
* RETURN VALUE
|
|
* SUCCESS or FAIL
|
|
*/
|
|
|
|
HRESULT
|
|
PduParseOutgoing(struct InstanceStruct *pInstance, PDU_t *pPdu,
|
|
Entity_t *pEntity, Event_t *pEvent, Key_t *pKey, int *pbCreate)
|
|
{
|
|
ASSERT(pInstance != NULL);
|
|
ASSERT(pPdu != NULL);
|
|
ASSERT(pEntity != NULL);
|
|
ASSERT(pEvent != NULL);
|
|
ASSERT(pKey != NULL);
|
|
ASSERT(pbCreate != NULL);
|
|
|
|
// Set default value for key
|
|
*pKey = 0;
|
|
|
|
switch (pPdu->choice)
|
|
{
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// REQUEST
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
case MltmdSystmCntrlMssg_rqst_chosen:
|
|
*pbCreate = TRUE;
|
|
switch (pPdu->u.MltmdSystmCntrlMssg_rqst.choice)
|
|
{
|
|
case RqstMssg_nonStandard_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
case masterSlaveDetermination_chosen:
|
|
*pEntity = MSDSE;
|
|
*pEvent = MSDetReq;
|
|
break;
|
|
|
|
case terminalCapabilitySet_chosen:
|
|
*pEntity = CESE_OUT;
|
|
*pEvent = TransferCapRequest;
|
|
break;
|
|
|
|
case openLogicalChannel_chosen:
|
|
if (pPdu->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.bit_mask & OLCl_rLCPs_present)
|
|
{
|
|
*pEntity = BLCSE_OUT;
|
|
*pEvent = ReqBEstablish;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_OUT;
|
|
*pEvent = ReqUEstablish;
|
|
}
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.openLogicalChannel.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case closeLogicalChannel_chosen:
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.closeLogicalChannel.forwardLogicalChannelNumber;
|
|
if (ObjectFind(pInstance, BLCSE_OUT, *pKey) != NULL)
|
|
{
|
|
*pEntity = BLCSE_OUT;
|
|
*pEvent = ReqClsBLCSE;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_OUT;
|
|
*pEvent = ReqURelease;
|
|
}
|
|
break;
|
|
|
|
case requestChannelClose_chosen:
|
|
*pEntity = CLCSE_OUT;
|
|
*pEvent = ReqClose;
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.requestChannelClose.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case multiplexEntrySend_chosen:
|
|
*pEntity = MTSE_OUT;
|
|
*pEvent = MTSE_TRANSFER_request;
|
|
break;
|
|
|
|
case requestMultiplexEntry_chosen:
|
|
*pEntity = RMESE_OUT;
|
|
*pEvent = RMESE_SEND_request;
|
|
break;
|
|
|
|
case requestMode_chosen:
|
|
*pEntity = MRSE_OUT;
|
|
*pEvent = MRSE_TRANSFER_request;
|
|
break;
|
|
|
|
case roundTripDelayRequest_chosen:
|
|
*pEntity = RTDSE;
|
|
*pEvent = RTDSE_TRANSFER_request;
|
|
break;
|
|
|
|
case maintenanceLoopRequest_chosen:
|
|
*pEntity = MLSE_OUT;
|
|
*pEvent = MLSE_LOOP_request;
|
|
switch (pPdu->u.MltmdSystmCntrlMssg_rqst.u.maintenanceLoopRequest.type.choice)
|
|
{
|
|
case systemLoop_chosen:
|
|
break;
|
|
case mediaLoop_chosen:
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.maintenanceLoopRequest.type.u.mediaLoop;
|
|
break;
|
|
case logicalChannelLoop_chosen:
|
|
*pKey = pPdu->u.MltmdSystmCntrlMssg_rqst.u.maintenanceLoopRequest.type.u.logicalChannelLoop;
|
|
break;
|
|
default:
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
break;
|
|
|
|
case communicationModeRequest_chosen:
|
|
case conferenceRequest_chosen:
|
|
// case h223AnnxARcnfgrtn_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseOutgoing: Invalid Request %d",
|
|
pPdu->u.MltmdSystmCntrlMssg_rqst.choice);
|
|
return H245_ERROR_PARAM;
|
|
}
|
|
break;
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// RESPONSE
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
case MSCMg_rspns_chosen:
|
|
*pbCreate = FALSE;
|
|
switch (pPdu->u.MSCMg_rspns.choice)
|
|
{
|
|
case RspnsMssg_nonStandard_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
#if 0
|
|
// Master Slave Determination Ack is generated by State Machine only
|
|
case mstrSlvDtrmntnAck_chosen:
|
|
*pEntity = MSDSE;
|
|
break;
|
|
|
|
// Master Slave Determination Reject is generated by State Machine only
|
|
case mstrSlvDtrmntnRjct_chosen:
|
|
*pEntity = MSDSE;
|
|
break;
|
|
#endif
|
|
|
|
case terminalCapabilitySetAck_chosen:
|
|
*pEntity = CESE_IN;
|
|
*pEvent = CESE_TRANSFER_response;
|
|
break;
|
|
|
|
case trmnlCpbltyStRjct_chosen:
|
|
*pEntity = CESE_IN;
|
|
*pEvent = CESE_REJECT_request;
|
|
break;
|
|
|
|
case openLogicalChannelAck_chosen:
|
|
if (pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.bit_mask & OLCAk_rLCPs_present)
|
|
{
|
|
*pEntity = BLCSE_IN;
|
|
*pEvent = ResponseBEstablish;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_IN;
|
|
*pEvent = ResponseUEstablish;
|
|
}
|
|
*pKey = pPdu->u.MSCMg_rspns.u.openLogicalChannelAck.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case openLogicalChannelReject_chosen:
|
|
*pKey = pPdu->u.MSCMg_rspns.u.openLogicalChannelReject.forwardLogicalChannelNumber;
|
|
if (ObjectFind(pInstance, BLCSE_IN, *pKey) != NULL)
|
|
{
|
|
*pEntity = BLCSE_IN;
|
|
*pEvent = OpenRejectBLCSE;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_IN;
|
|
*pEvent = EstablishUReject;
|
|
}
|
|
break;
|
|
|
|
#if 0
|
|
// Close Logical Channel Ack is generated by State Machine only
|
|
case closeLogicalChannelAck_chosen:
|
|
*pKey = pPdu->u.MSCMg_rspns.u.closeLogicalChannelAck.forwardLogicalChannelNumber;
|
|
if (ObjectFind(pInstance, BLCSE_IN, *pKey) != NULL)
|
|
{
|
|
*pEntity = BLCSE_IN;
|
|
}
|
|
else
|
|
{
|
|
*pEntity = LCSE_IN;
|
|
}
|
|
break;
|
|
#endif
|
|
|
|
case requestChannelCloseAck_chosen:
|
|
*pEntity = CLCSE_IN;
|
|
*pEvent = CLCSE_CLOSE_response;
|
|
*pKey = pPdu->u.MSCMg_rspns.u.requestChannelCloseAck.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case rqstChnnlClsRjct_chosen:
|
|
*pEntity = CLCSE_IN;
|
|
*pEvent = CLCSE_REJECT_request;
|
|
*pKey = pPdu->u.MSCMg_rspns.u.rqstChnnlClsRjct.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
case multiplexEntrySendAck_chosen:
|
|
*pEntity = MTSE_IN;
|
|
*pEvent = MTSE_TRANSFER_response;
|
|
break;
|
|
|
|
case multiplexEntrySendReject_chosen:
|
|
*pEntity = MTSE_IN;
|
|
*pEvent = MTSE_REJECT_request;
|
|
break;
|
|
|
|
case requestMultiplexEntryAck_chosen:
|
|
*pEntity = RMESE_IN;
|
|
*pEvent = RMESE_SEND_response;
|
|
break;
|
|
|
|
case rqstMltplxEntryRjct_chosen:
|
|
*pEntity = RMESE_IN;
|
|
*pEvent = RMESE_REJECT_request;
|
|
break;
|
|
|
|
case requestModeAck_chosen:
|
|
*pEntity = MRSE_IN;
|
|
*pEvent = MRSE_TRANSFER_response;
|
|
break;
|
|
|
|
case requestModeReject_chosen:
|
|
*pEntity = MRSE_IN;
|
|
*pEvent = MRSE_REJECT_request;
|
|
break;
|
|
|
|
#if 0
|
|
// Round Trip Delay Response sent by State Machine only
|
|
case roundTripDelayResponse_chosen:
|
|
*pEntity = RTDSE;
|
|
*pEvent = RoundTripDelayResponse;
|
|
break;
|
|
#endif
|
|
|
|
case maintenanceLoopAck_chosen:
|
|
*pEntity = MLSE_IN;
|
|
*pEvent = MLSE_LOOP_response;
|
|
// Caveat: Channel number must be zero if system loop!
|
|
*pKey = pPdu->u.MSCMg_rspns.u.maintenanceLoopAck.type.u.mediaLoop;
|
|
break;
|
|
|
|
case maintenanceLoopReject_chosen:
|
|
*pEntity = MLSE_IN;
|
|
*pEvent = MLSE_IN_RELEASE_request;
|
|
// Caveat: Channel number must be zero if system loop!
|
|
*pKey = pPdu->u.MSCMg_rspns.u.maintenanceLoopReject.type.u.mediaLoop;
|
|
break;
|
|
|
|
case cmmnctnMdRspns_chosen:
|
|
case conferenceResponse_chosen:
|
|
// case h223AnnxARcnfgrtnAck_chosen:
|
|
// case h223AnnxARcnfgrtnRjct_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseOutgoing: Invalid Response %d",
|
|
pPdu->u.MSCMg_rspns.choice);
|
|
return H245_ERROR_PARAM;
|
|
}
|
|
break;
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// COMMAND
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
case MSCMg_cmmnd_chosen:
|
|
*pbCreate = FALSE;
|
|
switch (pPdu->u.MSCMg_cmmnd.choice)
|
|
{
|
|
case CmmndMssg_nonStandard_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
case mntnncLpOffCmmnd_chosen:
|
|
*pEntity = MLSE_OUT;
|
|
*pEvent = MLSE_OUT_RELEASE_request;
|
|
break;
|
|
|
|
case sndTrmnlCpbltySt_chosen:
|
|
case encryptionCommand_chosen:
|
|
case flowControlCommand_chosen:
|
|
case endSessionCommand_chosen:
|
|
case miscellaneousCommand_chosen:
|
|
case communicationModeCommand_chosen:
|
|
case conferenceCommand_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseOutgoing: Invalid Command %d",
|
|
pPdu->u.MSCMg_cmmnd.choice);
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
break;
|
|
|
|
////////////////////////////////////////////////////////////////////
|
|
//
|
|
// INDICATION
|
|
//
|
|
////////////////////////////////////////////////////////////////////
|
|
case indication_chosen:
|
|
*pbCreate = FALSE;
|
|
switch (pPdu->u.indication.choice)
|
|
{
|
|
case IndctnMssg_nonStandard_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
case functionNotUnderstood_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
#if 0
|
|
// Master Slave Determination Release is sent by State Machine Only
|
|
case mstrSlvDtrmntnRls_chosen:
|
|
*pEntity = MSDSE;
|
|
break;
|
|
|
|
// Terminal Capability Set Release is sent by State Machine Only
|
|
case trmnlCpbltyStRls_chosen:
|
|
*pEntity = CESE_OUT
|
|
break;
|
|
#endif
|
|
|
|
case opnLgclChnnlCnfrm_chosen:
|
|
*pEntity = BLCSE_OUT;
|
|
*pEvent = RspConfirmBLCSE;
|
|
*pKey = pPdu->u.indication.u.opnLgclChnnlCnfrm.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
#if 0
|
|
// Request Channel Close Release is sent by State Machine Only
|
|
case rqstChnnlClsRls_chosen:
|
|
*pEntity = CLCSE_OUT;
|
|
*pKey = pPdu->u.indication.u.rqstChnnlClsRls.forwardLogicalChannelNumber;
|
|
break;
|
|
|
|
// Multiplex Entry Send Release is sent by State Machine Only
|
|
case mltplxEntrySndRls_chosen:
|
|
*pEntity = MTSE_OUT;
|
|
break;
|
|
|
|
// Request Multiplex Entry Release is sent by State Machine Only
|
|
case rqstMltplxEntryRls_chosen:
|
|
*pEntity = RMESE_OUT;
|
|
break;
|
|
|
|
// Request Mode Release is sent by State Machine Only
|
|
case requestModeRelease_chosen:
|
|
*pEntity = MRSE_OUT;
|
|
break;
|
|
#endif
|
|
|
|
case miscellaneousIndication_chosen:
|
|
case jitterIndication_chosen:
|
|
case h223SkewIndication_chosen:
|
|
case newATMVCIndication_chosen:
|
|
case userInput_chosen:
|
|
case h2250MxmmSkwIndctn_chosen:
|
|
case mcLocationIndication_chosen:
|
|
case conferenceIndication_chosen:
|
|
case vendorIdentification_chosen:
|
|
case IndicationMessage_functionNotSupported_chosen:
|
|
*pEntity = STATELESS;
|
|
break;
|
|
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseOutgoing: Invalid Indication %d",
|
|
pPdu->u.indication.choice);
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
break;
|
|
|
|
default:
|
|
H245TRACE(pInstance->dwInst, 1, "PduParseOutgoing: Invalid Message Type %d",
|
|
pPdu->choice);
|
|
return H245_ERROR_PARAM;
|
|
} // switch
|
|
|
|
return H245_ERROR_OK;
|
|
} // PduParseOutgoing()
|