windows-server-2003/net/rras/ip/nath323/h245info.cpp

/*---------------------------------------------------
Copyright (c) 1998, Microsoft Corporation
File: h245.cpp

Purpose: 
    Contains the H245 related function definitions. 
	These include the base classes -
	LOGICAL_CHANNEL
	H245_INFO

History:

    1. written as part of cbridge.cpp
        Byrisetty Rajeev (rajeevb)  12-Jun-1998
	2. moved to a separate file on 21-Aug-1998. This removes
		atl, rend, tapi headers and decreases file size

---------------------------------------------------*/


#include "stdafx.h"
#include "portmgmt.h"
#include "timerval.h"
#include "cbridge.h"
#include "main.h"

#if DBG

#define NUM_H245_MEDIA_TYPES            8

TCHAR* h245MediaTypes[NUM_H245_MEDIA_TYPES + 1] = {
            _T("Unknown"),
            _T("Non-standard"),
            _T("Null-data"),
            _T("Video"),
            _T("Audio"),
            _T("Data"),
            _T("Encrypted"),
            _T("H235 control"),
            _T("H235 media")
        };
            
#define NUM_H245_REQUEST_PDU_TYPES     13

TCHAR* h245RequestTypes[NUM_H245_REQUEST_PDU_TYPES + 1] = {
            _T("Unknown"),
            _T("Non-standard"),
            _T("Master-Slave Determination"),
            _T("Terminal Capability Set"),
            _T("Open Logical Channel"),
            _T("Close Logical Channel"),
            _T("Request Channel Close"),
            _T("Multiplex Entry Send"),
            _T("Request Multiplex Entry"),
            _T("Request Mode"),
            _T("Round Trip Delay Request"),
            _T("Maintenance Loop Request"),
            _T("Communication Mode Request"),
            _T("Conference Request")
        };

#define NUM_H245_RESPONSE_PDU_TYPES     21

TCHAR* h245ResponseTypes[NUM_H245_RESPONSE_PDU_TYPES + 1] = {   
            _T("Unknown"),
            _T("Non-Standard Message"), 
            _T("Master-Slave Determination Ack"), 
            _T("Master-Slave Determination Reject"),
            _T("Terminal Capability Set Ack"),
            _T("Terminal Capability Set Reject"),
            _T("Open Logical Channel Ack"),
            _T("Open Logical Channel Reject"),
            _T("Close Logical Channel Ack"),
            _T("Request Channel Close Ack"),
            _T("Request Channel Close Reject"),
            _T("Multiplex Entry Send Ack"),
            _T("Multiplex Entry Send Reject"),
            _T("Request Multiplex Entry Ack"),
            _T("Request Multiplex Entry Reject"),
            _T("Request Mode Ack"),
            _T("Request Mode Reject"),
            _T("Round Trip Delay Response"),
            _T("Maintenance Loop Ack"),
            _T("Maintenance Loop Reject"),
            _T("Communication Mode Response"),
            _T("Conference Response")
        };

#endif // DBG 
        
inline HRESULT
H245_INFO::QueueReceive()
{

    HRESULT HResult = EventMgrIssueRecv (m_SocketInfo.Socket, *this);

    if (FAILED(HResult))
    {
		DebugF (_T("H245_INFO::QueueReceive: Async Receive call failed.\n"));
    }

    return HResult;
}


inline HRESULT
H245_INFO::QueueSend(
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
{
    BYTE *pBuf   = NULL;
    DWORD BufLen = 0;

    // This function encodes the TPKT header also into the buffer
    HRESULT HResult = EncodeH245PDU(*pH245pdu, // decoded ASN.1 part
                                    &pBuf,
                                    &BufLen);
    if (FAILED(HResult))
    {
        DebugF(_T("EncodeH245PDU() failed: %x\n"), HResult);
        return HResult;
    }

    // call the event manager to make the async send call
    // the event mgr will free the buffer.

    HResult = EventMgrIssueSend (m_SocketInfo.Socket, *this, pBuf, BufLen);
    
    if (FAILED(HResult))
    {
		DebugF(_T("H245_INFO::QueueSend(), AsyncSend() failed: 0x%x\n"),
                HResult);
    }

    // Issuing the send succeeded.

    return HResult;
}

/* virtual */ HRESULT 
H245_INFO::SendCallback(
    IN      HRESULT					  CallbackHResult
    )
{
    CALL_BRIDGE *pCallBridge = &GetCallBridge();
	HRESULT Result = S_OK;

    pCallBridge->Lock();

	if (!pCallBridge -> IsTerminated ()) {

		if (FAILED(CallbackHResult))
		{
			pCallBridge->Terminate ();

			_ASSERTE(pCallBridge->IsTerminated());

			Result = CallbackHResult;
			
		} 

    } else {
    
        // This is here to take care of closing the socket
        // when callbridge sends EndSession PDU during
        // termination path. 
        GetSocketInfo ().Clear (TRUE);
    }
   
    pCallBridge->Unlock();
    
    return Result;
}


// This clearly assumes that the H.245 listen address will
// always be within the Connect PDU and the dest side will be the one
// which will be calling connect()

inline HRESULT 
DEST_H245_INFO::ConnectToCallee(
	)
{
	// we must be in H245_STATE_CON_INFO
	_ASSERTE(H245_STATE_CON_INFO == m_H245State);

	// we saved the callee's h245 address/port in the call to SetCalleeInfo
	_ASSERTE(ntohl (m_CalleeAddress.sin_addr.s_addr));
	_ASSERTE(ntohs (m_CalleeAddress.sin_port));

	// try to connect to this address/port
	// and save the address/port
	HRESULT HResult = m_SocketInfo.Connect (&m_CalleeAddress);
	if (FAILED(HResult))
	{
		DebugF (_T("H245: 0x%x failed to connect to callee %08X:%04X.\n"),
            &GetCallBridge (),
            SOCKADDR_IN_PRINTF (&m_CalleeAddress));

		return HResult;
	}
    //_ASSERTE(S_FALSE != HResult);

	// queue receive
	HResult = QueueReceive();
	if (FAILED(HResult))
	{
		DebugF (_T("H245: 0x%x failed to queue receive.\n"),
            &GetCallBridge ());

		DumpError (HResult);

		return HResult;
	}
    //_ASSERTE(S_FALSE != HResult);

	// transition to state H245_STATE_CON_ESTD
	m_H245State = H245_STATE_CON_ESTD;

	return HResult;
}

HRESULT SOURCE_H245_INFO::ListenForCaller (
	IN	SOCKADDR_IN *	ListenAddress)
{
    // queues an overlapped accept and returns the
    // port on which its listening for incoming connections
    // it uses the same local ip address as the source q931 connection

	SOCKET			ListenSocket;
	HRESULT			Result;
	WORD		    Port = 0;		// in HOST order
	SOCKADDR_IN     TrivialRedirectSourceAddress = {0};
	SOCKADDR_IN     TrivialRedirectDestAddress = {0};
	ULONG           SourceAdapterIndex;
	ULONG           Status;

	ListenSocket = INVALID_SOCKET;

    Result = EventMgrIssueAccept(
		ntohl (ListenAddress -> sin_addr.s_addr),
		*this, 
		Port,	// out param
		ListenSocket);

	ListenAddress -> sin_port = htons (Port);

    if (FAILED (Result)) {

        DebugF (_T("H245: 0x%x failed to issue accept from caller.\n"), &GetCallBridge ());
		DumpError (Result);
        return Result;
    }

  
    //_ASSERTE(S_FALSE != HResult);

    // save the listen socket, address and port in our socket info
    m_SocketInfo.SetListenInfo (ListenSocket, ListenAddress);
    
    // Open trivial source-side NAT mapping
    //
    // The purpose of this mapping is to puncture the firewall for H.245
    // session if the firewall happened to be activated.
    // Note that this assumes that the caller sends both Q.931 and H.245
    // traffic from the same IP address.

    SourceAdapterIndex = ::NhMapAddressToAdapter (htonl (GetCallBridge().GetSourceInterfaceAddress()));

    if(SourceAdapterIndex == (ULONG)-1)
    {
        DebugF (_T("H245: 0x%x failed to map address %08X to adapter index.\n"),
            &GetCallBridge (),
            GetCallBridge().GetSourceInterfaceAddress());
            
        return E_FAIL;
    }
    
#if PARTIAL_TRIVIAL_REDIRECTS_ENABLED // enable this when it would be possible to set up a trivial redirect 
                                      // with only source port (new and old) unspecified.

    GetCallBridge().GetSourceAddress(&TrivialRedirectSourceAddress);
#endif // PARTIAL_TRIVIAL_REDIRECTS_ENABLED

    TrivialRedirectDestAddress.sin_addr.s_addr = ListenAddress->sin_addr.s_addr;
    TrivialRedirectDestAddress.sin_port = ListenAddress->sin_port;

    Status = m_SocketInfo.CreateTrivialNatRedirect(
            &TrivialRedirectDestAddress,
            &TrivialRedirectSourceAddress,
            SourceAdapterIndex);

    if (Status != S_OK) {
	
        return E_FAIL;
    }

    // transition state to H245_STATE_CON_LISTEN
    m_H245State = H245_STATE_CON_LISTEN;

    return S_OK;
}


// virtual
HRESULT SOURCE_H245_INFO::AcceptCallback (
    IN	DWORD			Status,
    IN	SOCKET			Socket,
	IN	SOCKADDR_IN *	LocalAddress,
	IN	SOCKADDR_IN *	RemoteAddress)
{
    HRESULT         HResult = Status;
    CALL_BRIDGE     *pCallBridge = &GetCallBridge();

    ///////////////////////////////
    //// LOCK the CALL_BRIDGE
    ///////////////////////////////

    pCallBridge->Lock();

	if (!pCallBridge -> IsTerminated ()) {

		do {
			if (FAILED (HResult))
			{
				// An error occured. Terminate the CALL_BRIDGE
				DebugF (_T("H245: 0x%x accept failed, terminating.\n"), &GetCallBridge ());

				DumpError (HResult);

				break;
			}

			// we must be in H245_STATE_CON_LISTEN state
			_ASSERTE(H245_STATE_CON_LISTEN == m_H245State);
        
			// call the dest instance to establish a connection with the callee
			HResult = GetDestH245Info().ConnectToCallee();

			if (FAILED(HResult))
				break;
			
			//_ASSERTE(S_FALSE != HResult);
        
			// close the listen socket, don't cancel trivial NAT redirect
			m_SocketInfo.Clear(FALSE);
			m_SocketInfo.Init(Socket, LocalAddress, RemoteAddress);
			            
			// queue receive
			HResult = QueueReceive();

			if (FAILED(HResult))
				break;
			
				//_ASSERTE(S_FALSE != HResult);
        
			// transition state to H245_STATE_CON_ESTD
			m_H245State = H245_STATE_CON_ESTD;

		} while (FALSE);

		if (FAILED (HResult))
		{

			// initiate shutdown
			pCallBridge->Terminate ();

			_ASSERTE(pCallBridge->IsTerminated());
    
		}
	}

    ///////////////////////////////
    //// UNLOCK the CALL_BRIDGE
    ///////////////////////////////
    pCallBridge->Unlock();

    return HResult;
}

/*++

Routine Description:
    This function is responsible for freeing pBuf (if it is not stored).
    
Arguments:
    
Return Values:
    
--*/
//virtual
HRESULT
H245_INFO::ReceiveCallback(
    IN      HRESULT                 CallbackHResult,
    IN      BYTE                   *pBuf,
    IN      DWORD                   BufLen
    )
{
    MultimediaSystemControlMessage  *pDecodedH245pdu = NULL;
    CALL_BRIDGE *pCallBridge = &GetCallBridge();
 
    pCallBridge->Lock();

	if (!pCallBridge -> IsTerminated ()) {

		if (SUCCEEDED(CallbackHResult))
		{
			CallbackHResult = DecodeH245PDU(pBuf, BufLen, &pDecodedH245pdu);

			if (SUCCEEDED(CallbackHResult))
			{
				// Process the PDU
				CallbackHResult = ReceiveCallback(pDecodedH245pdu);
				FreeH245PDU(pDecodedH245pdu);
			}
			else
			{
                DebugF (_T("H245: 0x%x error 0x%x on decode.\n"),
                    &GetCallBridge (),
                    CallbackHResult);

				pCallBridge->Terminate ();
			}
		}	
		else
		{
			// An error occured. Terminate the CALL_BRIDGE
            DebugF (_T("H245: 0x%x error 0x%x on receive callback.\n"),
                &GetCallBridge (),
                    CallbackHResult);
			pCallBridge->Terminate ();
		}	
    }

    pCallBridge -> Unlock();

    EM_FREE(pBuf);

    return CallbackHResult;
}


/* virtual */ HRESULT 
H245_INFO::ReceiveCallback(
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
/*++

Routine Description:
    Only Request PDUs are handled by this H245_INFO instance.
    All the other PDUs are just passed on for processing to the
    other instance.

    CODEWORK: How should we handle endSessionCommand PDUs ?
    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    HRESULT HResult;

	// check to see if we must destroy self
    // CHECK_TERMINATION;

    // we must have a valid decoded PDU 
    _ASSERTE(NULL != pH245pdu);

	// we must be in H245_STATE_CON_ESTD state
	_ASSERTE(H245_STATE_CON_ESTD == m_H245State);

    // check message type
    if (MultimediaSystemControlMessage_request_chosen ==
            pH245pdu->choice)
    {
        // we only handle requests in the H245 instance which
        // actually receives the PDU
        HResult = HandleRequestMessage(pH245pdu);
    }
    else
    {
        // we don't process these here, pass them on to the other
        // H245 instance.
        HResult = GetOtherH245Info().ProcessMessage(pH245pdu);
    }

    // CODEWORK: Which errors should result in just dropped PDUs
    // and which ones should result in shutting down the whole call ???
    
    // if there is an error
    if (FAILED(HResult) && HResult != E_INVALIDARG)
    {
        goto shutdown;
    }

    // CODEWORK: If HResult is E_INVALIDARG, this means that the PDU
    // should be dropped. We need to let the caller know about this
    // and send him a closeLC message or some such.
    // Probably an OLC PDU should get an OLCReject etc.
    
    // we must queue a receive irrespective of whether or not the
    // previous message was dropped.
    // queue an async receive
    HResult = QueueReceive();
    if (FAILED(HResult))
    {
        goto shutdown;
    }

    return HResult;

shutdown:

    // initiate shutdown
    GetCallBridge().Terminate ();

    return HResult;
}



///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Routines for processing H.245 PDUs                                        //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


HRESULT
H245_INFO::HandleRequestMessage(
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
/*++

Routine Description:
    Only the OLC and CLC PDUs are handled here. All the rest are
    just passed on to the other H245_INFO instance for processing.
    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    BOOL IsDestH245Info = (&GetCallBridge().GetDestH323State().GetH245Info() == this);
    LogicalChannelNumber LCN;
    
    // it must be a request message
    _ASSERTE(MultimediaSystemControlMessage_request_chosen ==
             pH245pdu->choice);

    // we must be in connected state
    _ASSERTE(H245_STATE_CON_ESTD == m_H245State);

    HRESULT HResult = E_FAIL;

    // check the PDU type
    switch(pH245pdu->u.request.choice)
    {
    case openLogicalChannel_chosen:
        {
            LCN = pH245pdu->u.request.u.openLogicalChannel.forwardLogicalChannelNumber;

#if DBG
            DebugF (_T("H245: 0x%x calle%c sent 'Open Logical Channel' (%s, LCN - %d).\n"), 
                    &GetCallBridge(), IsDestH245Info ? 'e' : 'r',
                    h245MediaTypes[pH245pdu->u.request.u.openLogicalChannel.forwardLogicalChannelParameters.dataType.choice],
                    LCN);
#endif
                 
            HResult = HandleOpenLogicalChannelPDU(pH245pdu);
        }
        break;

    case closeLogicalChannel_chosen:
        {
            LCN =  pH245pdu->u.request.u.closeLogicalChannel.forwardLogicalChannelNumber;
            DebugF (_T("H245: 0x%x calle%c sent 'Close Logical Channel' (LCN - %d).\n"),
                    &GetCallBridge(), IsDestH245Info ? 'e' : 'r', LCN);
            HResult = HandleCloseLogicalChannelPDU(pH245pdu);
        }
        break;

    default:
        {
            // pass it on to the other H245 instance
#if DBG
            DebugF (_T("H245: 0x%x calle%c sent '%s'. Forwarding without processing.\n"),
                 &GetCallBridge(), IsDestH245Info ? 'e' : 'r',              
                 h245RequestTypes[pH245pdu->u.request.choice]);
#endif

            HResult = GetOtherH245Info().ProcessMessage(
                          pH245pdu);
        }
        break;
    };

    return HResult;
}


HRESULT
H245_INFO::ProcessMessage(
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
/*++

Routine Description:
    Only Response PDUs need processing. All other PDUs
    are simply sent out.
    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    BOOL IsDestH245Info = (&GetCallBridge().GetDestH323State().GetH245Info() == this);

	// we must be in H245_STATE_CON_ESTD state
	_ASSERTE(H245_STATE_CON_ESTD == m_H245State);

    // all messages are passed on
    // we only do special processing of response messages here
    if (MultimediaSystemControlMessage_response_chosen ==
            pH245pdu->choice)
    {
        HRESULT HResult = E_FAIL;

        // we only process requests in the H245 instance which
        // actually receives the PDU
        HResult = ProcessResponseMessage(pH245pdu);

        // XXX This if is redundant
        // if we are dropping the PDU, no further processing is required
        if (HResult == E_INVALIDARG)
        {
		    DebugF(_T("DEST_Q931_INFO::ProcessMessage(&%x), ")
                _T("dropping response message, returning E_INVALIDARG\n"),
			    pH245pdu);
            return E_INVALIDARG;
        }
        else if (FAILED(HResult))
        {
		    DebugF( _T("DEST_Q931_INFO::ProcessMessage(&%x), ")
                _T("unable to process response message, returning 0x%x\n"),
			    pH245pdu, HResult);
            return HResult;
        }
    }
    else  if (MultimediaSystemControlMessage_command_chosen ==
            pH245pdu->choice)
    {
        DebugF (_T("H245: 0x%x calle%c sent 'Command Message' (Type %d). Forwarding without processing.\n"),
             &GetCallBridge(), IsDestH245Info ? 'r' : 'e',
             pH245pdu -> u.command.choice);

    }
    else  if (indication_chosen == pH245pdu->choice)
    {
            DebugF (_T("H245: 0x%x calle%c sent 'Indication Message' (Type %d). Forwarding without processing.\n"),
             &GetCallBridge(), IsDestH245Info ? 'r' : 'e',
             pH245pdu -> u.indication.choice);
    }

    // queue async send for the PDU
    HRESULT HResult = E_FAIL;
    HResult = QueueSend(pH245pdu);
    if (HResult != S_OK) {
		DebugF( _T("DEST_Q931_INFO::ProcessMessage(&%x) QueueSend failed, returning %x\n"),
			pH245pdu, HResult);
        return HResult;
    }

    return S_OK;
}


//
// we process response messages here
// since the logical channel info for these messages resides in this H245,
// the other H245 instance doesn't process them
// 
HRESULT
H245_INFO::ProcessResponseMessage(
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
{
    BOOL IsDestH245Info = (&GetCallBridge().GetDestH323State().GetH245Info() == this);

    // it must be a response message
    _ASSERTE(MultimediaSystemControlMessage_response_chosen ==   \
                pH245pdu->choice);

    // NOTE: LogicalChannelNumber is USHORT, but we can treat it as an
    // unsigned WORD
    _ASSERTE(sizeof(LogicalChannelNumber) == sizeof(WORD));

    // obtain the logical channel number
    WORD LogChanNum = 0;
    switch(pH245pdu->u.response.choice)
    {
    case openLogicalChannelAck_chosen:
        {
            OpenLogicalChannelAck &OlcAckPDU =
                pH245pdu->u.response.u.openLogicalChannelAck;
            LogChanNum = OlcAckPDU.forwardLogicalChannelNumber;
            DebugF (_T("H245: 0x%x calle%c sent 'Open Logical Channel Ack' (LCN - %d).\n"), 
                &GetCallBridge (), IsDestH245Info ? 'r' : 'e', LogChanNum);
        }
        break;

    case openLogicalChannelReject_chosen:
        {
            OpenLogicalChannelReject &OlcRejectPDU =
                pH245pdu->u.response.u.openLogicalChannelReject;
            LogChanNum = OlcRejectPDU.forwardLogicalChannelNumber;
            DebugF (_T("H245: 0x%x calle%c sent 'Open Logical Channel Reject' (LCN - %d).\n"),
                &GetCallBridge (), IsDestH245Info ? 'r' : 'e', LogChanNum);
        }
        break;

#if 0  // 0 ******* Region Commented Out Begins *******
    case closeLogicalChannelAck_chosen:
        {
            CloseLogicalChannelAck &ClcAckPDU =
                pH245pdu->u.response.u.closeLogicalChannelAck;
            LogChanNum = ClcAckPDU.forwardLogicalChannelNumber;
        }
        break;
#endif // 0 ******* Region Commented Out Ends   *******

        // Let the CLCAck messages also go right through

    default:
        {
#if DBG
            // pass it on to the other H245 instance
            DebugF (_T("H245: 0x%x calle%c sent '%s'. Forwarding without processing.\n"),
                 &GetCallBridge(), IsDestH245Info ? 'r' : 'e',              
                 h245ResponseTypes[pH245pdu->u.request.choice]);
#endif

            return S_OK;
        }
        break;
    };

    // find the logical channel that must process this PDU,
    // if none found, drop the PDU
    LOGICAL_CHANNEL *pLogicalChannel = 
        m_LogicalChannelArray.FindByLogicalChannelNum(LogChanNum);
    if (NULL == pLogicalChannel)
    {
		DebugF(_T("H245_INFO::ProcessResponseMessage(&%x), ")
            _T("no logical channel with the forward logical channel num = %d, ")
            _T("returning E_INVALIDARG\n"),
			pH245pdu, LogChanNum);
        return E_INVALIDARG;        
    }

    // pass the PDU to the logical channel for processing
    HRESULT HResult = E_FAIL;
    switch(pH245pdu->u.response.choice)
    {
    case openLogicalChannelAck_chosen:
        {
            HResult = pLogicalChannel->ProcessOpenLogicalChannelAckPDU(
                        pH245pdu
                        );
        }
        break;

    case openLogicalChannelReject_chosen:
        {
            HResult = pLogicalChannel->ProcessOpenLogicalChannelRejectPDU(
                        pH245pdu
                        );
        }
        break;

#if 0  // 0 ******* Region Commented Out Begins *******
    case closeLogicalChannelAck_chosen:
        {
            HResult = pLogicalChannel->ProcessCloseLogicalChannelAckPDU(
                        pH245pdu
                        );
        }
        break;
#endif // 0 ******* Region Commented Out Ends   *******

    default:
        {
            // do nothing, let it go to the client terminal
            DebugF(_T("H245_INFO::ProcessResponseMessage(&%x), we shouldn't have come here, returning E_UNEXPECTED\n"),
		        pH245pdu);
            return E_UNEXPECTED;
        }
        break;
    };

    return HResult;
}

// Make Checks specific to RTP logical channels
HRESULT
H245_INFO::CheckOpenRtpLogicalChannelPDU(
    IN  OpenLogicalChannel              &OlcPDU,
	OUT	SOCKADDR_IN *					ReturnSourceAddress)

	/*++

Routine Description:

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    HRESULT HResult;
    
    // it must be unidirectional
    // bidirectional channels are only present for data channels
    if (OpenLogicalChannel_reverseLogicalChannelParameters_present &
            OlcPDU.bit_mask)
    {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
                _T("has reverse logical channel parameters, ")
                _T("returning E_INVALIDARG\n")
                );
        return E_INVALIDARG;
    }

    // there shouldn't be a separate stack
    // we don't proxy data on the separate stack address/port
    if (OpenLogicalChannel_separateStack_present &
            OlcPDU.bit_mask)
    {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu)")
                _T("has a separate stack, returning E_INVALIDARG\n")
                );
        return E_INVALIDARG;
    }

    OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters	&MultiplexParams = 
        OlcPDU.forwardLogicalChannelParameters.multiplexParameters;

    H2250LogicalChannelParameters &	H2250Params =
        MultiplexParams.u.h2250LogicalChannelParameters;

    // we must have a media control channel
    if (!(H2250LogicalChannelParameters_mediaControlChannel_present &
          H2250Params.bit_mask))
    {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
            _T("doesn't have a mediaControlChannel, returning E_INVALIDARG\n")
            );
        return E_INVALIDARG;
    }

    // we only proxy best-effort UDP RTCP streams for now
    if ((H2250LogicalChannelParameters_mediaControlGuaranteedDelivery_present &
         H2250Params.bit_mask) &&
        (TRUE ==
         H2250Params.mediaControlGuaranteedDelivery))
    {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
            _T("requires guaranteed media delivery for RTCP, returning E_INVALIDARG\n")
            );
        return E_INVALIDARG;
    }

    // the proposed RTCP address should be a unicast IPv4 address
    if ((unicastAddress_chosen != H2250Params.mediaControlChannel.choice) ||
        (UnicastAddress_iPAddress_chosen !=
         H2250Params.mediaControlChannel.u.unicastAddress.choice))
    {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
            _T("RTCP address is not a unicast IPv4 address, ")
            _T("address type = %d, unicast address type = %d")
            _T("returning E_INVALIDARG\n"),
            H2250Params.mediaControlChannel.choice,
            H2250Params.mediaControlChannel.u.unicastAddress.choice);
        return E_INVALIDARG;
    }

    // we only proxy best-effort UDP data streams for now
    if ((H2250LogicalChannelParameters_mediaGuaranteedDelivery_present & H2250Params.bit_mask)
		&& H2250Params.mediaGuaranteedDelivery) {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
            _T("requires guaranteed media delivery for RTP, returning E_INVALIDARG\n")
            );
        return E_INVALIDARG;
    }

    // get in the source ipv4 address and RTCP port
    HResult = GetH245TransportInfo(
        H2250Params.mediaControlChannel,
		ReturnSourceAddress);

    return HResult;
}

// Make checks needed for the DataType member in forward and reverse
// LogicalChannelParameters
inline HRESULT
CheckT120DataType(
    IN DataType  &dataType
    )
/*++

Routine Description:

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    // The reverse logical channel should also be of type data.
    if (dataType.choice != DataType_data_chosen)
    {
        return E_INVALIDARG;
    }

    // and of type T120 alone
    if (dataType.u.data.application.choice !=
        DataApplicationCapability_application_t120_chosen)
        return E_INVALIDARG;

    // Separate LAN stack is needed
    if (dataType.u.data.application.u.t120.choice != separateLANStack_chosen)
        return E_INVALIDARG;
    
    return S_OK;
}


// Make Checks specific to T.120 logical channels
// If SeparateStack is not present the routine returns
// INADDR_NONE for the T120ConnectToIPAddr
HRESULT
H245_INFO::CheckOpenT120LogicalChannelPDU(
    IN  OpenLogicalChannel  &OlcPDU,
    OUT DWORD               &T120ConnectToIPAddr,
    OUT WORD                &T120ConnectToPort
    )
/*++

Routine Description:

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    HRESULT HResult;

    // This function is called only for data channels
    _ASSERTE(OlcPDU.forwardLogicalChannelParameters.dataType.choice ==
             DataType_data_chosen);
    
    // It must be bidirectional since this is a data channel.

    if (!(OpenLogicalChannel_reverseLogicalChannelParameters_present &
          OlcPDU.bit_mask))
    {
        DebugF( _T("H245_INFO::CheckT120OpenLogicalChannelPDU() ")
            _T("has no reverse logical channel parameters, ")
            _T("returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    
    // Ensure that for both forward and reverse LogicalchannelParmeters
    // the datatype is application t120 and separateLANStack
    HResult = CheckT120DataType(
                  OlcPDU.forwardLogicalChannelParameters.dataType
                  );
    if (HResult == E_INVALIDARG)
    {
        return E_INVALIDARG;
    }
    
    HResult = CheckT120DataType (OlcPDU.reverseLogicalChannelParameters.dataType);
    if (HResult == E_INVALIDARG)
        return E_INVALIDARG;
    
    // CODEWORK: What all other checks are needed here ?

    // CODEWORK: there could probably be other ways to send the address
    // Investigate all possibilities.

    // This means we have the address the T.120 endpoint is listening on
    if (OpenLogicalChannel_separateStack_present &
          OlcPDU.bit_mask)
    {
        return(GetT120ConnectToAddress(
                   OlcPDU.separateStack,
                   T120ConnectToIPAddr,
                   T120ConnectToPort)
               );
    }

    // If the address is not present, return INADDR_NONE
    
    T120ConnectToIPAddr = INADDR_NONE;
    T120ConnectToPort = 0;
    // CODEWORK: Do we need a separate success code for this scenario
    // (in which the address is not present) ?
    return S_OK;
}


HRESULT
H245_INFO::CheckOpenLogicalChannelPDU(
    IN  MultimediaSystemControlMessage  &H245pdu,
    OUT BYTE                            &SessionId,
    OUT MEDIA_TYPE                      &MediaType
    )
/*++

Routine Description:

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
   
    // it must be an open logical channel request message
    _ASSERTE (openLogicalChannel_chosen == H245pdu.u.request.choice);

    OpenLogicalChannel &OlcPDU = H245pdu.u.request.u.openLogicalChannel;

    // the forward logical channel number cannot be 0 as thats reserved
    // for the H245 channel
    if (0 == OlcPDU.forwardLogicalChannelNumber)
    {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
                _T("has a forward logical channel number of 0, ")
                _T("returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    if (DataType_videoData_chosen == 
          OlcPDU.forwardLogicalChannelParameters.dataType.choice)
    {
        MediaType = MEDIA_TYPE_VIDEO;
    }
    else if (DataType_audioData_chosen == 
             OlcPDU.forwardLogicalChannelParameters.dataType.choice)
    {
        MediaType = MEDIA_TYPE_AUDIO;
    }
    else if (DataType_data_chosen == 
             OlcPDU.forwardLogicalChannelParameters.dataType.choice)
    {
        MediaType = MEDIA_TYPE_DATA;
    }
    else
    {
        // we only support audio, video and data types
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
            _T("has a non audio/video data type = %d, ")
            _T("returning E_INVALIDARG\n"),
            OlcPDU.forwardLogicalChannelParameters.dataType.choice);
        return E_INVALIDARG;
    }
    
    // it should have the h2250 parameters
    // TODO : check if this is a requirement
	// now THESE are some identifiers to be PROUD of!  :/
    OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters &
		MultiplexParams = OlcPDU.forwardLogicalChannelParameters.multiplexParameters;
    if (MultiplexParams.choice !=
		  OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters_h2250LogicalChannelParameters_chosen)
    {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
                _T("has an unexpected multiplex param type (non h2250)= %d, ")
                _T("returning E_INVALIDARG\n"),
                MultiplexParams.choice);
        return E_INVALIDARG;
    }
        
    // there shouldn't be a mediaChannel as the ITU spec requires it not
    // to be present when the transport is unicast and we only support
    // unicast IPv4 addresses
    H2250LogicalChannelParameters &H2250Params =
        MultiplexParams.u.h2250LogicalChannelParameters;
    if (H2250LogicalChannelParameters_mediaChannel_present &
        H2250Params.bit_mask)
    {
        DebugF( _T("H245_INFO::CheckOpenLogicalChannelPDU(&H245pdu) ")
                _T("has a mediaChannel, returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    // get the session id
    // BYTE cast is intentional as the value should be in [0.255]
    _ASSERTE(H2250Params.sessionID <= 255);
    SessionId = (BYTE)H2250Params.sessionID;

    return S_OK;
}

HRESULT
H245_INFO::CreateRtpLogicalChannel(
    IN      OpenLogicalChannel               &OlcPDU,
    IN      BYTE                              SessionId,
    IN      MEDIA_TYPE                        MediaType,
    IN      MultimediaSystemControlMessage   *pH245pdu,
    OUT     LOGICAL_CHANNEL                 **ppReturnLogicalChannel 
    )
/*++

Routine Description:

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
	SOCKADDR_IN		SourceRtcpAddress;
    HRESULT HResult;

    *ppReturnLogicalChannel = NULL;
    
    HResult = CheckOpenRtpLogicalChannelPDU (OlcPDU, &SourceRtcpAddress);

    if (E_INVALIDARG == HResult) // XXX
    {
        return E_INVALIDARG;
    }

    // CODEWORK: We have to check only the 
    // RTP LOGICAL_CHANNELS
    // check if there is a logical channel with the same non-zero 
    // session id with the other H245 instance
    LOGICAL_CHANNEL *pAssocLogicalChannel = 
        (0 == SessionId) ? 
        NULL :
        GetOtherH245Info().GetLogicalChannelArray().FindBySessionId(SessionId);
    
    // For audio and video data create an RTP Logical Channel
    WORD LogChanNum = OlcPDU.forwardLogicalChannelNumber;
    RTP_LOGICAL_CHANNEL *pLogicalChannel = new RTP_LOGICAL_CHANNEL();
    if (NULL == pLogicalChannel)
    {
        DebugF( _T("H245_INFO::CreateRtpLogicalChannel() ")
                _T("cannot create a RTP_LOGICAL_CHANNEL, returning E_OUTOFMEMORY\n")
                );
        return E_OUTOFMEMORY;
    }

    // intialize the logical channel
    HResult = pLogicalChannel->HandleOpenLogicalChannelPDU(
        *this,                  // H245_INFO
        MediaType,              // The type of the media

		ntohl (m_SocketInfo.LocalAddress.sin_addr.s_addr),		// our local address
		ntohl (m_SocketInfo.RemoteAddress.sin_addr.s_addr),		// our remote address

        ntohl (GetOtherH245Info().GetSocketInfo().LocalAddress.sin_addr.s_addr),	// other h245 local address
        ntohl (GetOtherH245Info().GetSocketInfo().RemoteAddress.sin_addr.s_addr),	// other h245 remote address
        LogChanNum,             // logical channel number
        SessionId,              // session id
        (RTP_LOGICAL_CHANNEL* )pAssocLogicalChannel,
        // associated logical channel
        // XXX What is a clean way of doing this ?
		ntohl (SourceRtcpAddress.sin_addr.s_addr),
		ntohs (SourceRtcpAddress.sin_port),
        pH245pdu				// h245 pdu (OLC)
        );
    
    if (FAILED(HResult))
    {
        // destroy the logical channel
        delete pLogicalChannel;
        
        DebugF( _T("H245_INFO::CreateRtpLogicalChannel(&%x) ")
                _T("cannot initialize RTP_LOGICAL_CHANNEL, returning 0x%x\n"),
                pH245pdu, HResult);
    }
    else
    {
        *ppReturnLogicalChannel = pLogicalChannel;
    }
    
    _ASSERTE(S_FALSE != HResult);
    return HResult;
}


HRESULT
H245_INFO::CreateT120LogicalChannel(
    IN      OpenLogicalChannel               &OlcPDU,
    IN      BYTE                              SessionId,
    IN      MEDIA_TYPE                        MediaType,
    IN      MultimediaSystemControlMessage   *pH245pdu,
    OUT     LOGICAL_CHANNEL                 **ppReturnLogicalChannel 
    )
/*++

Routine Description:										

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    DWORD   T120ConnectToIPAddr;
    WORD    T120ConnectToPort;
    HRESULT HResult;

    *ppReturnLogicalChannel = NULL;
    
    // CODEWORK: Have success code which returns a value saying
    // this PDU does not have the T120 listen address
    HResult = CheckOpenT120LogicalChannelPDU(OlcPDU,
                                             T120ConnectToIPAddr,
                                             T120ConnectToPort
                                             );
    if (E_INVALIDARG == HResult) // XXX
    {
        return E_INVALIDARG;
    }

    // For data create a T.120 Logical Channel
    WORD LogChanNum = OlcPDU.forwardLogicalChannelNumber;
    T120_LOGICAL_CHANNEL *pLogicalChannel = new T120_LOGICAL_CHANNEL();
    if (NULL == pLogicalChannel)
    {
        DebugF( _T("H245_INFO::CreateT120LogicalChannel(&%x) ")
               _T("cannot create a T120_LOGICAL_CHANNEL, returning E_OUTOFMEMORY\n"),
               pH245pdu);
        return E_OUTOFMEMORY;
    }

    // intialize the logical channel
    HResult = pLogicalChannel->HandleOpenLogicalChannelPDU(
        *this,                  // H245_INFO
        MediaType,              // The type of the media
        LogChanNum,             // logical channel number
        SessionId,              // session id
        T120ConnectToIPAddr,    // T.120 end point is listening on this
        T120ConnectToPort,      // IPAddr and Port
        pH245pdu				// h245 pdu (OLC)
        );
    
    if (FAILED(HResult))
    {
        // destroy the logical channel
        delete pLogicalChannel;
        
        DebugF( _T("H245_INFO::CreateT120LogicalChannel(&%x) ")
                _T("cannot initialize T120_LOGICAL_CHANNEL, returning 0x%x\n"),
                pH245pdu, HResult);
    }
    else
    {
        *ppReturnLogicalChannel = pLogicalChannel;
    }

    _ASSERTE(S_FALSE != HResult);
    return HResult;
}


HRESULT
H245_INFO::HandleOpenLogicalChannelPDU(
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
/*++

Routine Description:

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    // it must be an open logical channel request message
    _ASSERTE(MultimediaSystemControlMessage_request_chosen ==   \
                pH245pdu->choice);
    _ASSERTE(openLogicalChannel_chosen ==   \
                pH245pdu->u.request.choice);

    HRESULT HResult = E_FAIL;

    OpenLogicalChannel &OlcPDU = 
        pH245pdu->u.request.u.openLogicalChannel;

    // check to see if there is already a logical channel with the
    // same forward logical channel number
    // NOTE: the array indices are not the same as the forward logical
    // channel number (0 is reserved for H245 channel and the ITU spec
    // allows a terminal to use any other value for it - i.e. they need
    // not be consecutive)
    // NOTE: LogicalChannelNumber is USHORT, but we can treat it as an
    // unsigned WORD
    _ASSERTE(sizeof(LogicalChannelNumber) == sizeof(WORD));
    WORD LogChanNum = OlcPDU.forwardLogicalChannelNumber;
    if (NULL != m_LogicalChannelArray.FindByLogicalChannelNum(LogChanNum))
    {
		DebugF( _T("H245_INFO::HandleOpenLogicalChannelPDU(&%x) ")
            _T("a logical channel with the forward logical channel num = %d ")
            _T("already exists, returning E_INVALIDARG\n"),
			pH245pdu, LogChanNum);
        return E_INVALIDARG;        
    }

    // check to see if we can handle this OLC PDU and
    // return its session id, source ipv4 address, RTCP port
    BYTE        SessionId;
    MEDIA_TYPE  MediaType;
    
    HResult = CheckOpenLogicalChannelPDU(
                *pH245pdu, 
                SessionId, 
                MediaType
                );
    if (FAILED(HResult))
    {
		DebugF( _T("H245_INFO::HandleOpenLogicalChannelPDU(&%x) ")
            _T("cannot handle Open Logical Channel PDU, returning 0x%x\n"),
			pH245pdu, HResult);
        return HResult;
    }

    // check to see if we already have a logical channel with this session id
    if ( (0 != SessionId) &&
         (NULL != m_LogicalChannelArray.FindBySessionId(SessionId)) )
    {
		DebugF( _T("H245_INFO::HandleOpenLogicalChannelPDU(&%x) ")
            _T("another Logical Channel exists with same session id = %u, ")
            _T("returning E_INVALIDARG\n"),
			pH245pdu, SessionId);
        return E_INVALIDARG;
    }

    LOGICAL_CHANNEL *pLogicalChannel = NULL;
    
    // create an instance of a LOGICAL_CHANNEL
    if (IsMediaTypeRtp(MediaType))
    {
        HResult = CreateRtpLogicalChannel(
                      OlcPDU,
                      SessionId,
                      MediaType,
                      pH245pdu,
                      &pLogicalChannel
                      );
    }
    else
    {
        HResult = CreateT120LogicalChannel(
                      OlcPDU,
                      SessionId,
                      MediaType,
                      pH245pdu,
                      &pLogicalChannel
                      );            
    }

    if (FAILED(HResult))
    {
		DebugF( _T("H245_INFO::HandleOpenLogicalChannelPDU(&%x) ")
            _T("Creating Logical channel failed, returning 0x%x\n"),
			pH245pdu, HResult);
        return HResult;
    }
    
    // insert the logical channel into the array
	// we add this to the array so that the logical channel is
	// available to the other h245 instance when its processing the PDU
	// this is only being done for keeping the code clean 
	// and not really needed now
    HResult = m_LogicalChannelArray.Add(*pLogicalChannel);
    if (FAILED(HResult))
    {
        // destroy the logical channel
        // this also removes any associations with any logical channel
        // in the other H245 instance
        delete pLogicalChannel;

		DebugF( _T("H245_INFO::HandleOpenLogicalChannelPDU(&%x) ")
            _T("cannot add new LOGICAL_CHANNEL to the array, returning 0x%x"),
			pH245pdu, HResult);
        return HResult;
    }
    _ASSERTE(S_FALSE != HResult);

    return HResult;    
}


// handles a request message to close a logical channel
// we start a timer and close the channel on receiving either a 
// CloseLogicalChannelAck PDU or a timeout
HRESULT
H245_INFO::HandleCloseLogicalChannelPDU(
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
/*++

Routine Description:

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    // it must be an open logical channel request message
    _ASSERTE(closeLogicalChannel_chosen ==  pH245pdu->u.request.choice);

    HRESULT HResult = E_FAIL;

    CloseLogicalChannel &ClcPDU = 
        pH245pdu->u.request.u.closeLogicalChannel;

    // verify that the logical channel indicated in the message exists
    // NOTE: LogicalChannelNumber is USHORT, but we can treat it as an
    // unsigned WORD
    _ASSERTE(sizeof(LogicalChannelNumber) == sizeof(WORD));
    WORD LogChanNum = ClcPDU.forwardLogicalChannelNumber;
    LOGICAL_CHANNEL *pLogicalChannel = 
        m_LogicalChannelArray.FindByLogicalChannelNum(LogChanNum);
    if (NULL == pLogicalChannel)
    {
		DebugF( _T("H245_INFO::HandleCloseLogicalChannelPDU(&%x), ")
            _T("no logical channel with the forward logical channel num = %d, ")
            _T("returning E_INVALIDARG\n"),
			pH245pdu, LogChanNum);
        return E_INVALIDARG;        
    }

    // let the Logical Channel instance process the message
    // it also forwards the message to the other H245 instance
    // NOTE: the logical channel should not be used after this call as it
    // may have deleted and removed itself from the array. it only returns
    // an error in case the error cannot be handled by simply deleting
    // itself (the logical channel)
    HResult = pLogicalChannel->HandleCloseLogicalChannelPDU(
                pH245pdu
                );
    if (FAILED(HResult))
    {
		DebugF( _T("H245_INFO::HandleCloseLogicalChannelPDU(&%x), ")
            _T("logical channel (%d) couldn't handle close logical channel PDU, ")
            _T("returning 0x%x\n"),
			pH245pdu, LogChanNum, HResult);
        return HResult;        
    }
    _ASSERTE(S_OK == HResult);

    DebugF( _T("H245_INFO::HandleCloseLogicalChannelPDU(&%x) returning 0x%x\n"),
        pH245pdu, HResult);
    return HResult;
}

/* virtual */
H245_INFO::~H245_INFO (void)
{
}


HRESULT
H245_INFO::SendEndSessionCommand (
    void
    )
/*++

Routine Description:
    Encodes and sends H.245 EndSession PDU

Arguments:
    None

Return Values:
    Passes through the result of calling another function

Notes:

--*/

{
    MultimediaSystemControlMessage   EndSessionCommand;
    HRESULT Result;

    EndSessionCommand.choice  = MultimediaSystemControlMessage_command_chosen;
    EndSessionCommand.u.command.choice = endSessionCommand_chosen;
    EndSessionCommand.u.command.u.endSessionCommand.choice = disconnect_chosen;

    Result = QueueSend (&EndSessionCommand);

    if (FAILED(Result))
    {
        DebugF(_T("H245: 0x%x failed to send EndSession PDU. Error=0x%x\n"),
            &GetCallBridge (),
             Result);
    }

    return Result;

} // H245_INFO::SendEndSessionCommand