You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
714 lines
22 KiB
714 lines
22 KiB
/************************************************************************
|
|
* *
|
|
* INTEL CORPORATION PROPRIETARY INFORMATION *
|
|
* *
|
|
* This software is supplied under the terms of a license *
|
|
* agreement or non-disclosure agreement with Intel Corporation *
|
|
* and may not be copied or disclosed except in accordance *
|
|
* with the terms of that agreement. *
|
|
* *
|
|
* Copyright (C) 1997 Intel Corp. All Rights Reserved *
|
|
* *
|
|
* *
|
|
* $Archive: S:\sturgeon\src\gkpdu\vcs\coder.cpv $
|
|
* *
|
|
* $Revision: 1.5 $
|
|
* $Date: 24 Jan 1997 19:38:44 $
|
|
* *
|
|
* $Author: BPOLING $
|
|
*
|
|
* $Log: S:\sturgeon\src\gkpdu\vcs\coder.cpv $
|
|
//
|
|
// Rev 1.5 24 Jan 1997 19:38:44 BPOLING
|
|
// remove string include files, not needed.
|
|
//
|
|
// Rev 1.2 18 Dec 1996 21:49:12 BPOLING
|
|
// builds with msdev and for windows only
|
|
//
|
|
// Rev 1.1 15 Nov 1996 16:17:44 BPOLING
|
|
// added vcs headers.
|
|
*
|
|
*************************************************************************
|
|
* *
|
|
* CODER.CPP *
|
|
* *
|
|
* PURPOSE: *
|
|
* *
|
|
* FUNCTIONS: *
|
|
* *
|
|
* COMMENTS: *
|
|
* *
|
|
* *
|
|
*************************************************************************
|
|
* *
|
|
* $History: CODER.CPP *
|
|
* *
|
|
* *
|
|
************************************************************************/
|
|
|
|
/************************************************************************
|
|
* Include Files *
|
|
***********************************************************************/
|
|
|
|
#include "precomp.h"
|
|
|
|
#ifdef __cplusplus
|
|
extern "C" {
|
|
#endif /*__cplusplus*/
|
|
|
|
#include "h225asn.h"
|
|
#include "coder.hpp"
|
|
|
|
#ifdef __cplusplus
|
|
}
|
|
#endif /*__cplusplus*/
|
|
|
|
/************************************************************************
|
|
* Local Manifest Constants *
|
|
***********************************************************************/
|
|
|
|
/************************************************************************
|
|
* GLOBAL VARIABLES *
|
|
************************************************************************/
|
|
|
|
|
|
/************************************************************************
|
|
* Local Private Data *
|
|
***********************************************************************/
|
|
|
|
/************************************************************************
|
|
* Start of Code *
|
|
***********************************************************************/
|
|
|
|
|
|
Coder::Coder(){
|
|
}
|
|
|
|
Coder::~Coder(){
|
|
|
|
EnterCriticalSection(&m_critSec);
|
|
GK_TermWorld(&m_World);
|
|
LeaveCriticalSection(&m_critSec);
|
|
DeleteCriticalSection(&m_critSec);
|
|
}
|
|
|
|
// initializes the oss library.
|
|
// the oss library provide ASN.1 encoding / decoding libraries.
|
|
//
|
|
|
|
int Coder::InitCoder()
|
|
{
|
|
|
|
int iError = 0;
|
|
m_protocolIdentifier1.next = &m_protocolIdentifier2;
|
|
m_protocolIdentifier1.value = ITU_T;
|
|
m_protocolIdentifier2.next = &m_protocolIdentifier3;
|
|
m_protocolIdentifier2.value = RECOMMENDATION;
|
|
m_protocolIdentifier3.next = &m_protocolIdentifier4;
|
|
m_protocolIdentifier3.value = SERIES;
|
|
m_protocolIdentifier4.next = &m_protocolIdentifier5;
|
|
m_protocolIdentifier4.value = RECOMM_NUMBER;
|
|
m_protocolIdentifier5.next = &m_protocolIdentifier6;
|
|
m_protocolIdentifier5.value = VERSION;
|
|
m_protocolIdentifier6.next = NULL;
|
|
m_protocolIdentifier6.value = ADDITIONAL;
|
|
InitializeCriticalSection(&m_critSec);
|
|
|
|
// Call TELES Library initialization routine
|
|
EnterCriticalSection(&m_critSec);
|
|
iError = GK_InitWorld(&m_World);
|
|
LeaveCriticalSection(&m_critSec);
|
|
|
|
return iError;
|
|
}
|
|
|
|
// ASN.1 Encode a H.323 PDU
|
|
// Take a H.323 structure and returns a H.323 PDU
|
|
//
|
|
int Coder:: Encode(RasMessage *pInputData, ASN1_BUF *pOutputOssBuf){
|
|
int iError;
|
|
|
|
// initialize encoding buffer structure values
|
|
pOutputOssBuf->value = NULL;
|
|
pOutputOssBuf->length = 0;
|
|
|
|
// encode pdu
|
|
EnterCriticalSection(&m_critSec);
|
|
iError = GK_Encode(&m_World,
|
|
(void *)pInputData,
|
|
RasMessage_PDU,
|
|
pOutputOssBuf);
|
|
LeaveCriticalSection(&m_critSec);
|
|
return iError;
|
|
}
|
|
|
|
|
|
int Coder::Decode(ASN1_BUF *pInputOssBuf, RasMessage **pOutputData){
|
|
int iError;
|
|
|
|
// NULL tells decoder to malloc memory for RasMessage
|
|
// user must free this memory by calling Coder::FreePDU()
|
|
*pOutputData = NULL;
|
|
|
|
// decode the pdu
|
|
EnterCriticalSection(&m_critSec);
|
|
iError = GK_Decode(&m_World,
|
|
(void **)pOutputData,
|
|
RasMessage_PDU,
|
|
pInputOssBuf);
|
|
LeaveCriticalSection(&m_critSec);
|
|
return iError;
|
|
}
|
|
|
|
// Used to free buffer created by decode
|
|
int Coder::Free(RasMessage *pData){
|
|
int iError;
|
|
|
|
EnterCriticalSection(&m_critSec);
|
|
// iError = freePDU(&m_World,RasMessage_PDU,pData, GKPDU_Module);
|
|
iError = freePDU(&m_World,RasMessage_PDU,pData, H225ASN_Module);
|
|
LeaveCriticalSection(&m_critSec);
|
|
return iError;
|
|
}
|
|
|
|
// Used to free buffer created by encode
|
|
void Coder::Free(ASN1_BUF Asn1Buf){
|
|
EnterCriticalSection(&m_critSec);
|
|
//GKPDU_Module->encfree(m_World.pEncInfo,(void *)(Asn1Buf.value));
|
|
ASN1_FreeEncoded(m_World.pEncInfo,(void *)(Asn1Buf.value));
|
|
LeaveCriticalSection(&m_critSec);
|
|
}
|
|
|
|
|
|
RequestSeqNum Coder::GetSequenceNumber(RasMessage *prasStruct){
|
|
|
|
RequestSeqNum rNum = 0;
|
|
|
|
switch(prasStruct->choice){
|
|
case gatekeeperRequest_chosen:
|
|
return prasStruct->u.gatekeeperRequest.requestSeqNum;
|
|
case gatekeeperConfirm_chosen:
|
|
return prasStruct->u.gatekeeperConfirm.requestSeqNum;
|
|
case gatekeeperReject_chosen:
|
|
return prasStruct->u.gatekeeperReject.requestSeqNum;
|
|
case registrationRequest_chosen:
|
|
return prasStruct->u.registrationRequest.requestSeqNum;
|
|
case registrationConfirm_chosen:
|
|
return prasStruct->u.registrationConfirm.requestSeqNum;
|
|
case registrationReject_chosen:
|
|
return prasStruct->u.registrationReject.requestSeqNum;
|
|
case unregistrationRequest_chosen:
|
|
return prasStruct->u.unregistrationRequest.requestSeqNum;
|
|
case unregistrationConfirm_chosen:
|
|
return prasStruct->u.unregistrationConfirm.requestSeqNum;
|
|
case unregistrationReject_chosen:
|
|
return prasStruct->u.unregistrationReject.requestSeqNum;
|
|
case admissionRequest_chosen:
|
|
return prasStruct->u.admissionRequest.requestSeqNum;
|
|
case admissionConfirm_chosen:
|
|
return prasStruct->u.admissionConfirm.requestSeqNum;
|
|
case admissionReject_chosen:
|
|
return prasStruct->u.admissionReject.requestSeqNum;
|
|
case bandwidthRequest_chosen:
|
|
return prasStruct->u.bandwidthRequest.requestSeqNum;
|
|
case bandwidthConfirm_chosen:
|
|
return prasStruct->u.bandwidthConfirm.requestSeqNum;
|
|
case bandwidthReject_chosen:
|
|
return prasStruct->u.bandwidthReject.requestSeqNum;
|
|
case disengageRequest_chosen:
|
|
return prasStruct->u.disengageRequest.requestSeqNum;
|
|
case disengageConfirm_chosen:
|
|
return prasStruct->u.disengageConfirm.requestSeqNum;
|
|
case disengageReject_chosen:
|
|
return prasStruct->u.disengageReject.requestSeqNum;
|
|
case locationRequest_chosen:
|
|
return prasStruct->u.locationRequest.requestSeqNum;
|
|
case locationConfirm_chosen:
|
|
return prasStruct->u.locationConfirm.requestSeqNum;
|
|
case locationReject_chosen:
|
|
return prasStruct->u.locationReject.requestSeqNum;
|
|
case infoRequest_chosen:
|
|
return prasStruct->u.infoRequest.requestSeqNum;
|
|
case infoRequestResponse_chosen:
|
|
return prasStruct->u.infoRequestResponse.requestSeqNum;
|
|
case nonStandardMessage_chosen:
|
|
return prasStruct->u.nonStandardMessage.requestSeqNum;
|
|
case unknownMessageResponse_chosen:
|
|
return prasStruct->u.unknownMessageResponse.requestSeqNum;
|
|
default:
|
|
return rNum;
|
|
}
|
|
|
|
return rNum;
|
|
|
|
}
|
|
|
|
|
|
RequestSeqNum Coder::SetSequenceNumber(RasMessage &rasStruct,RequestSeqNum reqNum){
|
|
|
|
RequestSeqNum rNum = 0;
|
|
|
|
switch(rasStruct.choice){
|
|
case gatekeeperRequest_chosen:
|
|
return (rasStruct.u.gatekeeperRequest.requestSeqNum = reqNum);
|
|
case gatekeeperConfirm_chosen:
|
|
return (rasStruct.u.gatekeeperConfirm.requestSeqNum = reqNum);
|
|
case gatekeeperReject_chosen:
|
|
return (rasStruct.u.gatekeeperReject.requestSeqNum = reqNum);
|
|
case registrationRequest_chosen:
|
|
return (rasStruct.u.registrationRequest.requestSeqNum = reqNum);
|
|
case registrationConfirm_chosen:
|
|
return (rasStruct.u.registrationConfirm.requestSeqNum = reqNum);
|
|
case registrationReject_chosen:
|
|
return (rasStruct.u.registrationReject.requestSeqNum = reqNum);
|
|
case unregistrationRequest_chosen:
|
|
return (rasStruct.u.unregistrationRequest.requestSeqNum = reqNum);
|
|
case unregistrationConfirm_chosen:
|
|
return (rasStruct.u.unregistrationConfirm.requestSeqNum = reqNum);
|
|
case unregistrationReject_chosen:
|
|
return (rasStruct.u.unregistrationReject.requestSeqNum = reqNum);
|
|
case admissionRequest_chosen:
|
|
return (rasStruct.u.admissionRequest.requestSeqNum = reqNum);
|
|
case admissionConfirm_chosen:
|
|
return (rasStruct.u.admissionConfirm.requestSeqNum = reqNum);
|
|
case admissionReject_chosen:
|
|
return (rasStruct.u.admissionReject.requestSeqNum = reqNum);
|
|
case bandwidthRequest_chosen:
|
|
return (rasStruct.u.bandwidthRequest.requestSeqNum = reqNum);
|
|
case bandwidthConfirm_chosen:
|
|
return (rasStruct.u.bandwidthConfirm.requestSeqNum = reqNum);
|
|
case bandwidthReject_chosen:
|
|
return (rasStruct.u.bandwidthReject.requestSeqNum = reqNum);
|
|
case disengageRequest_chosen:
|
|
return (rasStruct.u.disengageRequest.requestSeqNum = reqNum);
|
|
case disengageConfirm_chosen:
|
|
return (rasStruct.u.disengageConfirm.requestSeqNum = reqNum);
|
|
case disengageReject_chosen:
|
|
return (rasStruct.u.disengageReject.requestSeqNum = reqNum);
|
|
case locationRequest_chosen:
|
|
return (rasStruct.u.locationRequest.requestSeqNum = reqNum);
|
|
case locationConfirm_chosen:
|
|
return (rasStruct.u.locationConfirm.requestSeqNum = reqNum);
|
|
case locationReject_chosen:
|
|
return (rasStruct.u.locationReject.requestSeqNum = reqNum);
|
|
case infoRequest_chosen:
|
|
return (rasStruct.u.infoRequest.requestSeqNum = reqNum);
|
|
case infoRequestResponse_chosen:
|
|
return (rasStruct.u.infoRequestResponse.requestSeqNum = reqNum);
|
|
case nonStandardMessage_chosen:
|
|
return (rasStruct.u.nonStandardMessage.requestSeqNum = reqNum);
|
|
case unknownMessageResponse_chosen:
|
|
return (rasStruct.u.unknownMessageResponse.requestSeqNum = reqNum);
|
|
default:
|
|
return (rNum);
|
|
}
|
|
|
|
return rNum;
|
|
|
|
}
|
|
|
|
|
|
// Returns a pointer EndpointIdentifier for any RasMessage
|
|
// NULL for RasMessage that have no EndpointIdentifier
|
|
EndpointIdentifier *Coder::GetEndpointID(RasMessage *prasStruct)
|
|
{
|
|
|
|
switch(prasStruct->choice){
|
|
// Message with endpointID
|
|
case registrationConfirm_chosen:
|
|
return &(prasStruct->u.registrationConfirm.endpointIdentifier);
|
|
case unregistrationRequest_chosen:
|
|
// Optional
|
|
return &(prasStruct->u.unregistrationRequest.URt_endpntIdntfr);
|
|
case admissionRequest_chosen:
|
|
return &(prasStruct->u.admissionRequest.endpointIdentifier);
|
|
case bandwidthRequest_chosen:
|
|
return &(prasStruct->u.bandwidthRequest.endpointIdentifier);
|
|
case disengageRequest_chosen:
|
|
return &(prasStruct->u.disengageRequest.endpointIdentifier);
|
|
case infoRequestResponse_chosen:
|
|
return &(prasStruct->u.infoRequestResponse.endpointIdentifier);
|
|
case locationRequest_chosen:
|
|
// Optional
|
|
return &(prasStruct->u.locationRequest.LctnRqst_endpntIdntfr);
|
|
|
|
// Messages without an endpointID
|
|
default:
|
|
case gatekeeperRequest_chosen:
|
|
case gatekeeperConfirm_chosen:
|
|
case gatekeeperReject_chosen:
|
|
case registrationRequest_chosen:
|
|
case nonStandardMessage_chosen:
|
|
case unknownMessageResponse_chosen:
|
|
case registrationReject_chosen:
|
|
case unregistrationConfirm_chosen:
|
|
case unregistrationReject_chosen:
|
|
case admissionConfirm_chosen:
|
|
case admissionReject_chosen:
|
|
case bandwidthReject_chosen:
|
|
case bandwidthConfirm_chosen:
|
|
case disengageConfirm_chosen:
|
|
case disengageReject_chosen:
|
|
case locationConfirm_chosen:
|
|
case locationReject_chosen:
|
|
case infoRequest_chosen:
|
|
return NULL;
|
|
}
|
|
|
|
return NULL;
|
|
|
|
|
|
}
|
|
|
|
|
|
ProtocolIdentifier Coder::SetProtocolIdentifier(RasMessage &rasStruct){
|
|
|
|
switch(rasStruct.choice){
|
|
case gatekeeperRequest_chosen:
|
|
return (rasStruct.u.gatekeeperRequest.protocolIdentifier = &m_protocolIdentifier1);
|
|
case gatekeeperConfirm_chosen:
|
|
return (rasStruct.u.gatekeeperConfirm.protocolIdentifier = &m_protocolIdentifier1);
|
|
case gatekeeperReject_chosen:
|
|
return (rasStruct.u.gatekeeperReject.protocolIdentifier = &m_protocolIdentifier1);
|
|
case registrationRequest_chosen:
|
|
return (rasStruct.u.registrationRequest.protocolIdentifier = &m_protocolIdentifier1);
|
|
case registrationConfirm_chosen:
|
|
return (rasStruct.u.registrationConfirm.protocolIdentifier = &m_protocolIdentifier1);
|
|
case registrationReject_chosen:
|
|
return (rasStruct.u.registrationReject.protocolIdentifier = &m_protocolIdentifier1);
|
|
|
|
case unregistrationRequest_chosen:
|
|
case unregistrationConfirm_chosen:
|
|
case unregistrationReject_chosen:
|
|
case admissionRequest_chosen:
|
|
case admissionConfirm_chosen:
|
|
case admissionReject_chosen:
|
|
case bandwidthRequest_chosen:
|
|
case bandwidthConfirm_chosen:
|
|
case bandwidthReject_chosen:
|
|
case disengageRequest_chosen:
|
|
case disengageConfirm_chosen:
|
|
case disengageReject_chosen:
|
|
case locationRequest_chosen:
|
|
case locationConfirm_chosen:
|
|
case locationReject_chosen:
|
|
case infoRequest_chosen:
|
|
case infoRequestResponse_chosen:
|
|
case nonStandardMessage_chosen:
|
|
case unknownMessageResponse_chosen:
|
|
default:
|
|
return NULL;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
// Returns TRUE if protocols match, FALSE - otherwise
|
|
BOOL Coder::VerifyProtocolIdentifier(RasMessage &rasStruct){
|
|
struct ObjectID_ *pprotID;
|
|
struct ObjectID_ *pmprotID = &m_protocolIdentifier1;
|
|
|
|
switch(rasStruct.choice){
|
|
case gatekeeperRequest_chosen:
|
|
{
|
|
pprotID = rasStruct.u.gatekeeperRequest.protocolIdentifier;
|
|
break;
|
|
}
|
|
case gatekeeperConfirm_chosen:
|
|
{
|
|
pprotID = rasStruct.u.gatekeeperConfirm.protocolIdentifier;
|
|
break;
|
|
}
|
|
case gatekeeperReject_chosen:
|
|
{
|
|
pprotID = rasStruct.u.gatekeeperReject.protocolIdentifier;
|
|
break;
|
|
}
|
|
case registrationRequest_chosen:
|
|
{
|
|
pprotID = rasStruct.u.registrationRequest.protocolIdentifier;
|
|
break;
|
|
}
|
|
case registrationConfirm_chosen:
|
|
{
|
|
pprotID = rasStruct.u.registrationConfirm.protocolIdentifier;
|
|
break;
|
|
}
|
|
case registrationReject_chosen:
|
|
{
|
|
pprotID = rasStruct.u.registrationReject.protocolIdentifier;
|
|
break;
|
|
}
|
|
|
|
case unregistrationRequest_chosen:
|
|
case unregistrationConfirm_chosen:
|
|
case unregistrationReject_chosen:
|
|
case admissionRequest_chosen:
|
|
case admissionConfirm_chosen:
|
|
case admissionReject_chosen:
|
|
case bandwidthRequest_chosen:
|
|
case bandwidthConfirm_chosen:
|
|
case bandwidthReject_chosen:
|
|
case disengageRequest_chosen:
|
|
case disengageConfirm_chosen:
|
|
case disengageReject_chosen:
|
|
case locationRequest_chosen:
|
|
case locationConfirm_chosen:
|
|
case locationReject_chosen:
|
|
case infoRequest_chosen:
|
|
case infoRequestResponse_chosen:
|
|
case nonStandardMessage_chosen:
|
|
case unknownMessageResponse_chosen:
|
|
default:
|
|
return TRUE; // if no protocolIdentifier -> return TRUE by default;
|
|
}
|
|
|
|
while (!pprotID && !pmprotID)
|
|
{
|
|
if (pprotID->value != pmprotID->value)
|
|
return FALSE;
|
|
|
|
pprotID = pprotID->next;
|
|
pmprotID = pmprotID->next;
|
|
}
|
|
|
|
if (!pprotID && !pmprotID)
|
|
return TRUE;
|
|
else return FALSE;
|
|
}
|
|
|
|
// finds the requested protocol rasAddress and copies it
|
|
DWORD Coder::CopyRasAddress(TransportAddress *pDestAddress, PSEQTRANSADDS pSrcSeqRasAddress, unsigned short choice)
|
|
{
|
|
if(!pDestAddress) return ASN1_ERR_BADARGS;
|
|
|
|
// choice 0 just grabs first address
|
|
if(choice)
|
|
{
|
|
while(pSrcSeqRasAddress)
|
|
{
|
|
if(pSrcSeqRasAddress->value.choice == choice) break;
|
|
pSrcSeqRasAddress = pSrcSeqRasAddress->next;
|
|
}
|
|
}
|
|
|
|
if(pSrcSeqRasAddress)
|
|
{
|
|
CopyMemory(pDestAddress,&(pSrcSeqRasAddress->value),sizeof(TransportAddress));
|
|
}
|
|
else
|
|
{
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
return ASN1_SUCCESS;
|
|
}
|
|
|
|
DWORD Coder::CopyRasAddress(TransportAddress *pDestAddress, RasMessage *prasStruct, unsigned short choice)
|
|
{
|
|
PSEQTRANSADDS pSeqTransAdd;
|
|
|
|
if(!pDestAddress) return ASN1_ERR_BADARGS;
|
|
|
|
if(prasStruct->choice != registrationRequest_chosen)
|
|
return ASN1_ERR_BADARGS;
|
|
|
|
pSeqTransAdd = (PSEQTRANSADDS) prasStruct->u.registrationRequest.rasAddress;
|
|
|
|
while(pSeqTransAdd)
|
|
{
|
|
if(pSeqTransAdd->value.choice == choice) break;
|
|
pSeqTransAdd = pSeqTransAdd->next;
|
|
}
|
|
|
|
if(pSeqTransAdd)
|
|
{
|
|
CopyMemory(pDestAddress,&(pSeqTransAdd->value),sizeof(TransportAddress));
|
|
}
|
|
else
|
|
{
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
return ASN1_SUCCESS;
|
|
}
|
|
|
|
// finds the requested protocol callSignalAddress and copies it
|
|
DWORD Coder::CopyCallSignal(TransportAddress *pDestCallSignalAddress, PSEQTRANSADDS pSrcSeqCSAAddress, unsigned short choice)
|
|
{
|
|
if(!pDestCallSignalAddress) return ASN1_ERR_BADARGS;
|
|
|
|
while(pSrcSeqCSAAddress)
|
|
{
|
|
if(pSrcSeqCSAAddress->value.choice == choice) break;
|
|
pSrcSeqCSAAddress = pSrcSeqCSAAddress->next;
|
|
}
|
|
|
|
if(pSrcSeqCSAAddress)
|
|
{
|
|
CopyMemory(pDestCallSignalAddress,&(pSrcSeqCSAAddress->value),sizeof(TransportAddress));
|
|
}
|
|
else
|
|
{
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
return ASN1_SUCCESS;
|
|
}
|
|
|
|
DWORD Coder::CopyCallSignal(TransportAddress *pCallSignalAddress, RasMessage *prasStruct, unsigned short choice)
|
|
{
|
|
PSEQTRANSADDS pSeqTransAdd;
|
|
|
|
if(!pCallSignalAddress) return ASN1_ERR_BADARGS;
|
|
|
|
if(prasStruct->choice != registrationRequest_chosen)
|
|
return ASN1_ERR_BADARGS;
|
|
|
|
pSeqTransAdd = (PSEQTRANSADDS) prasStruct->u.registrationRequest.callSignalAddress;
|
|
|
|
while(pSeqTransAdd)
|
|
{
|
|
if(pSeqTransAdd->value.choice == choice) break;
|
|
pSeqTransAdd = pSeqTransAdd->next;
|
|
}
|
|
|
|
if(pSeqTransAdd)
|
|
{
|
|
CopyMemory(pCallSignalAddress,&(pSeqTransAdd->value),sizeof(TransportAddress));
|
|
}
|
|
else
|
|
{
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
return ASN1_SUCCESS;
|
|
}
|
|
|
|
|
|
|
|
// THE FOLLOWING IS ADDED FOR TELES ASN.1 INTEGRATION
|
|
|
|
extern "C" {
|
|
|
|
int GK_InitWorld(ASN1_CODER_INFO *pWorld)
|
|
{
|
|
int rc;
|
|
|
|
ZeroMemory(pWorld, sizeof(*pWorld));
|
|
|
|
if (H225ASN_Module == NULL)
|
|
{
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
rc = ASN1_CreateEncoder(
|
|
H225ASN_Module, // ptr to mdule
|
|
&(pWorld->pEncInfo), // ptr to encoder info
|
|
NULL, // buffer ptr
|
|
0, // buffer size
|
|
NULL); // parent ptr
|
|
if (rc == ASN1_SUCCESS)
|
|
{
|
|
ASSERT(pWorld->pEncInfo != NULL);
|
|
rc = ASN1_CreateDecoder(
|
|
H225ASN_Module, // ptr to mdule
|
|
&(pWorld->pDecInfo), // ptr to decoder info
|
|
NULL, // buffer ptr
|
|
0, // buffer size
|
|
NULL); // parent ptr
|
|
ASSERT(pWorld->pDecInfo != NULL);
|
|
}
|
|
|
|
if (rc != ASN1_SUCCESS)
|
|
{
|
|
GK_TermWorld(pWorld);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
int GK_TermWorld(ASN1_CODER_INFO *pWorld)
|
|
{
|
|
if (H225ASN_Module == NULL)
|
|
{
|
|
return ASN1_ERR_BADARGS;
|
|
}
|
|
|
|
ASN1_CloseEncoder(pWorld->pEncInfo);
|
|
ASN1_CloseDecoder(pWorld->pDecInfo);
|
|
|
|
ZeroMemory(pWorld, sizeof(*pWorld));
|
|
|
|
return ASN1_SUCCESS;
|
|
}
|
|
|
|
int GK_Encode(ASN1_CODER_INFO *pWorld, void *pStruct, int nPDU, ASN1_BUF *pBuf)
|
|
{
|
|
int rc;
|
|
ASN1encoding_t pEncInfo = pWorld->pEncInfo;
|
|
BOOL fBufferSupplied = (pBuf->value != NULL) && (pBuf->length != 0);
|
|
DWORD dwFlags = fBufferSupplied ? ASN1ENCODE_SETBUFFER : ASN1ENCODE_ALLOCATEBUFFER;
|
|
|
|
// clean up out parameters
|
|
if (! fBufferSupplied)
|
|
{
|
|
pBuf->length = 0;
|
|
pBuf->value = NULL;
|
|
}
|
|
|
|
rc = ASN1_Encode(
|
|
pEncInfo, // ptr to encoder info
|
|
pStruct, // pdu data structure
|
|
nPDU, // pdu id
|
|
dwFlags, // flags
|
|
pBuf->value, // buffer
|
|
pBuf->length); // buffer size if provided
|
|
if (ASN1_SUCCEEDED(rc))
|
|
{
|
|
if (fBufferSupplied)
|
|
{
|
|
ASSERT(pBuf->value == pEncInfo->buf);
|
|
ASSERT(pBuf->length >= pEncInfo->len);
|
|
}
|
|
else
|
|
{
|
|
pBuf->value = pEncInfo->buf; // buffer to encode into
|
|
}
|
|
pBuf->length = pEncInfo->len; // len of encoded data in buffer
|
|
}
|
|
else
|
|
{
|
|
ASSERT(FALSE);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
int GK_Decode(ASN1_CODER_INFO *pWorld, void **ppStruct, int nPDU, ASN1_BUF *pBuf)
|
|
{
|
|
ASN1decoding_t pDecInfo = pWorld->pDecInfo;
|
|
BYTE *pEncoded = pBuf->value;
|
|
ULONG cbEncodedSize = pBuf->length;
|
|
|
|
int rc = ASN1_Decode(
|
|
pDecInfo, // ptr to encoder info
|
|
ppStruct, // pdu data structure
|
|
nPDU, // pdu id
|
|
ASN1DECODE_SETBUFFER, // flags
|
|
pEncoded, // do not provide buffer
|
|
cbEncodedSize); // buffer size if provided
|
|
if (ASN1_SUCCEEDED(rc))
|
|
{
|
|
ASSERT(pDecInfo->pos > pDecInfo->buf);
|
|
pBuf->length -= (ULONG)(pDecInfo->pos - pDecInfo->buf);
|
|
pBuf->value = pDecInfo->pos;
|
|
}
|
|
else
|
|
{
|
|
ASSERT(FALSE);
|
|
*ppStruct = NULL;
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
} // extern "C"
|
|
|