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

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


// destructor
// virtual
RTP_LOGICAL_CHANNEL::~RTP_LOGICAL_CHANNEL (void)
{
	// close NAT mappings
	CloseNATMappings();

    // release reference to any associated channel or allocated ports
	ReleaseAssociationAndPorts();
}


/*++
  Release ports only if there is no associated channel. If there is an
  associated channel the ports will be freed when it is deleted. Note that
  a logical channel could be closed and reopened again.
--*/

inline void 
RTP_LOGICAL_CHANNEL::ReleaseAssociationAndPorts()
{
    // if there is an associated logical channel
    if (NULL != m_pAssocLogicalChannel)
    {
        //  release reference to it
        m_pAssocLogicalChannel->ResetAssociationRef();
        m_pAssocLogicalChannel = NULL;
    }
    else
    {
        if (m_OwnSourceRecvRTPPort != 0)
            PortPoolFreeRTPPort(m_OwnSourceRecvRTPPort);
        if (m_OwnAssocLCRecvRTPPort != 0)
            PortPoolFreeRTPPort(m_OwnAssocLCRecvRTPPort);
        if (m_OwnDestSendRTPPort != 0)
            PortPoolFreeRTPPort(m_OwnDestSendRTPPort);
        if (m_OwnAssocLCSendRTPPort != 0)
            PortPoolFreeRTPPort(m_OwnAssocLCSendRTPPort);
        m_OwnSourceRecvRTPPort  = m_OwnSourceRecvRTCPPort   = 0;
        m_OwnAssocLCRecvRTPPort = m_OwnDestRecvRTCPPort     = 0;
        m_OwnDestSendRTPPort    = m_OwnDestSendRTCPPort     = 0;
        m_OwnAssocLCSendRTPPort = m_OwnSourceSendRTCPPort   = 0;
    }
}

/*++
 This function is called after the OLC is received.
 --*/

HRESULT
RTP_LOGICAL_CHANNEL::SetPorts (void)
{
	HRESULT HResult = E_FAIL;

	// if there is an associated LC, copy all the ports from that LC.
	// else, allocate them now
    if (NULL != m_pAssocLogicalChannel)
    {
        // tell the associated logical channel that we are associated
        // with it
        m_pAssocLogicalChannel->SetAssociationRef(*this);

        // save the associated channel's own source/dest ports
		// assoc channel's source ports become our dest ports and vice versa
        m_OwnDestRecvRTCPPort	= m_pAssocLogicalChannel->m_OwnSourceRecvRTCPPort;
        m_OwnSourceRecvRTCPPort	= m_pAssocLogicalChannel->m_OwnDestRecvRTCPPort;

        m_OwnDestSendRTCPPort	= m_pAssocLogicalChannel->m_OwnSourceSendRTCPPort;
        m_OwnSourceSendRTCPPort	= m_pAssocLogicalChannel->m_OwnDestSendRTCPPort;

        // Copy the RTP ports
        m_OwnSourceRecvRTPPort  = m_pAssocLogicalChannel->m_OwnAssocLCRecvRTPPort;
        m_OwnAssocLCRecvRTPPort = m_pAssocLogicalChannel->m_OwnSourceRecvRTPPort;

        m_OwnDestSendRTPPort    = m_pAssocLogicalChannel->m_OwnAssocLCSendRTPPort;
        m_OwnAssocLCSendRTPPort = m_pAssocLogicalChannel->m_OwnDestSendRTPPort;
    }
    else
    {
        // allocate own ports - the portmgt apis return an even port only (RTP)
        // and the assumption is that the RTCP port = RTP port + 1
		// however, we use the odd port for receiving RTCP and the even
		// port for sending RTP
        HResult = PortPoolAllocRTPPort (&m_OwnSourceRecvRTPPort);
        if (FAILED(HResult))
        {
            DebugF( _T("RTP_LOGICAL_CHANNEL::SetPorts")
				_T("failed to allocate m_OwnSourceRecvRTPPort, returning 0x%x\n"),
                HResult);
            goto cleanup;
        }
        m_OwnSourceRecvRTCPPort = m_OwnSourceRecvRTPPort + 1;

        HResult = PortPoolAllocRTPPort (&m_OwnAssocLCRecvRTPPort);
        if (FAILED(HResult))
        {
            DebugF( _T("RTP_LOGICAL_CHANNEL::SetPorts")
				_T("failed to allocate m_OwnAssocLCRecvRTPPort, returning 0x%x\n"),
                HResult);
            goto cleanup;
        }
        m_OwnDestRecvRTCPPort = m_OwnAssocLCRecvRTPPort + 1;

        HResult = PortPoolAllocRTPPort (&m_OwnDestSendRTPPort);
        if (FAILED(HResult))
        {
            DebugF( _T("RTP_LOGICAL_CHANNEL::SetPorts")
				_T("failed to allocate m_OwnDestSendRTPPort, returning 0x%x\n"),
                HResult);
            goto cleanup;
        }
        m_OwnDestSendRTCPPort = m_OwnDestSendRTPPort + 1;

        HResult = PortPoolAllocRTPPort (&m_OwnAssocLCSendRTPPort);
        if (FAILED(HResult))
        {
            DebugF( _T("RTP_LOGICAL_CHANNEL::SetPorts, ")
                _T("failed to allocate m_OwnAssocLCSendRTPPort, returning 0x%x\n"),
                HResult);
            goto cleanup;
        }
        m_OwnSourceSendRTCPPort = m_OwnAssocLCSendRTPPort + 1;
    }
    
	DebugF (_T("RTP : 0x%x using ports %04X, %04X, %04X, %04X.\n"),
            &GetCallBridge (),
            m_OwnSourceRecvRTPPort, m_OwnAssocLCRecvRTPPort,
            m_OwnDestSendRTPPort, m_OwnAssocLCSendRTPPort);

	DebugF (_T("RTCP: 0x%x using ports %04X, %04X, %04X, %04X.\n"),
            &GetCallBridge (),
            m_OwnSourceRecvRTCPPort, m_OwnDestRecvRTCPPort,
            m_OwnDestSendRTCPPort, m_OwnSourceSendRTCPPort);

	return S_OK;

 cleanup:
    if (m_OwnSourceRecvRTPPort != 0)
        PortPoolFreeRTPPort(m_OwnSourceRecvRTPPort);
    if (m_OwnAssocLCRecvRTPPort != 0)
        PortPoolFreeRTPPort(m_OwnAssocLCRecvRTPPort);
    if (m_OwnDestSendRTPPort != 0)
        PortPoolFreeRTPPort(m_OwnDestSendRTPPort);
    if (m_OwnAssocLCSendRTPPort != 0)
        PortPoolFreeRTPPort(m_OwnAssocLCSendRTPPort);
    m_OwnSourceRecvRTPPort  = m_OwnSourceRecvRTCPPort   = 0;
    m_OwnAssocLCRecvRTPPort = m_OwnDestRecvRTCPPort     = 0;
    m_OwnDestSendRTPPort    = m_OwnDestSendRTCPPort     = 0;
    m_OwnAssocLCSendRTPPort = m_OwnSourceSendRTCPPort   = 0;
    
    return HResult;
}


///////////////////////////////////////////////////////////////////////////////
//                                                                           //
// Routines for setting up and tearing down NAT Redirects                    //
//                                                                           //
///////////////////////////////////////////////////////////////////////////////


// opens the forward RTP, forward RTCP and reverse RTCP streams
// This function is called after the OLCAck is received.
HRESULT
RTP_LOGICAL_CHANNEL::OpenNATMappings(
	)
{
    // open NAT mapping for source -> dest RTP stream
	// this is the forward RTP stream and we must always open this

	NTSTATUS	Status;
	ULONG RedirectFlags = NatRedirectFlagNoTimeout;

	if (m_OwnDestIPv4Address == m_DestIPv4Address ||
		m_SourceIPv4Address  == m_OwnSourceIPv4Address)
	{
		RedirectFlags |= NatRedirectFlagLoopback;
	}

	Status = NatCreateRedirectEx (
            NatHandle,
			RedirectFlags,	                // flags
			IPPROTO_UDP,				    // UDP
			htonl(m_OwnSourceIPv4Address),	// source packet dest address (local)
			htons(m_OwnSourceRecvRTPPort),	// source packet dest port (local)
			htonl(0),			            // wildcard - source packet source address
			htons(0),			            // wildcard - source packet source port
			htonl(m_DestRTPIPv4Address),	// NewDestinationAddress
			htons(m_DestRTPPort),			// NewDestinationPort
			htonl(m_OwnDestIPv4Address),	// NewSourceAddress
			htons(m_OwnDestSendRTPPort),	// NewSourcePort
            NULL,                           // RestrictedAdapterIndex
			NULL,                   		// CompletionRoutine
			NULL,							// CompletionContext
            NULL);                          // NotifyEvent

	if (Status != NO_ERROR) {
	
        DebugF (_T("RTP : 0x%x failed to set up redirect for forward RTP stream: (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X). Error - %d.\n"),
            &GetCallBridge (),
    		m_OwnSourceIPv4Address,		    
    		m_OwnSourceRecvRTPPort,		    
    		m_OwnDestIPv4Address,		    
    		m_OwnDestSendRTPPort,		    
    		m_DestRTPIPv4Address,		    
            m_DestRTPPort,			        
            Status);

		return E_FAIL;
	} 
	else {
	
    	DebugF (_T("RTP : 0x%x set up redirect for forward RTP stream: (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X).\n"),
            &GetCallBridge (),
    		m_OwnSourceIPv4Address,		
    		m_OwnSourceRecvRTPPort,		
    		m_OwnDestIPv4Address,		
    		m_OwnDestSendRTPPort,		
    		m_DestRTPIPv4Address,		
            m_DestRTPPort);			    
    }

	// check to see if we must open the RTCP streams in both directions
	// source <-> dest
	
	// if there is no associated logical channel or the assoc logical
	// channel is in neither LC_STATE_OPEN_ACK_RCVD nor 
	// LC_STATE_OPENED_CLOSE_RCVD, we must open the RTCP streams
	if ((!m_pAssocLogicalChannel) ||
		 ((LC_STATE_OPEN_ACK_RCVD != m_pAssocLogicalChannel -> m_LogicalChannelState) &&
		 (LC_STATE_OPENED_CLOSE_RCVD != m_pAssocLogicalChannel -> m_LogicalChannelState))) {

		// open NAT mapping for forward RTCP stream
		Status = NatCreateRedirectEx (
			NatHandle,
			RedirectFlags,	                // flags
			IPPROTO_UDP,				    // UDP
			htonl(m_OwnSourceIPv4Address),	// source packet dest address (local)
			htons(m_OwnSourceRecvRTCPPort),	// source packet dest port (local)
			htonl(0),				        // wildcard - source packet source address
			htons(0),				        // wildcard - source packet source port
			htonl(m_DestRTCPIPv4Address),	// NewDestinationAddress
			htons(m_DestRTCPPort),			// NewDestinationPort
			htonl(m_OwnDestIPv4Address),	// NewSourceAddress
			htons(m_OwnDestSendRTCPPort),	// NewSourcePort
            NULL,                           // RestrictedAdapterIndex
			NULL,                           // CompletionRoutine
			NULL,							// CompletionContext
			NULL);                          // NotifyEvent

		if (Status != NO_ERROR) {
			// close the forward RTP stream
			// ignore error code

		    DebugF (_T("RTCP: 0x%x failed to set up redirect for forward RCTP stream: (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X). Error - %d.\n"),
                &GetCallBridge (),
                m_OwnSourceIPv4Address,		
                m_OwnSourceRecvRTCPPort,	
                m_OwnDestIPv4Address,		
                m_OwnDestSendRTCPPort,		
                m_DestRTCPIPv4Address,		
                m_DestRTCPPort,
                Status);

			NatCancelRedirect (
                NatHandle,
				IPPROTO_UDP,					// UDP
				htonl(m_OwnSourceIPv4Address),	// source packet dest address (local)
				htons(m_OwnSourceRecvRTPPort),	// source packet dest port (local)
				htonl(0),						// wildcard - source packet source address
				htons(0),						// wildcard - source packet source port
				htonl(m_DestRTPIPv4Address),	// NewDestinationAddress
				htons(m_DestRTPPort),			// NewDestinationPort
				htonl(m_OwnDestIPv4Address),	// NewSourceAddress
				htons(m_OwnDestSendRTPPort));	// NewSourcePort

			return E_FAIL;
		}
		else {
		
		    DebugF (_T("RTCP: 0x%x set up redirect for forward RCTP stream: (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X).\n"),
                &GetCallBridge (),
                m_OwnSourceIPv4Address,		// source packet dest address (local)
                m_OwnSourceRecvRTCPPort,	// source packet dest port (local)
                m_OwnDestIPv4Address,		// NewSourceAddress
                m_OwnDestSendRTCPPort,		// NewSourcePort
                m_DestRTCPIPv4Address,		// NewDestinationAddress
                m_DestRTCPPort);			// NewDestinationPort
        }

		// open NAT mapping for reverse RTCP stream
		Status = NatCreateRedirectEx (
            NatHandle,
			RedirectFlags,						// flags
			IPPROTO_UDP,		// UDP
			htonl(m_OwnDestIPv4Address),	// source packet dest address (local)
			htons(m_OwnDestRecvRTCPPort),	// source packet dest port (local)
			htonl(0),			// wildcard - source packet source address
			htons(0),			// wildcard - source packet source port
			htonl(m_SourceRTCPIPv4Address),	// NewDestinationAddress
			htons(m_SourceRTCPPort),		// NewDestinationPort
			htonl(m_OwnSourceIPv4Address),	// NewSourceAddress
			htons(m_OwnSourceSendRTCPPort),	// NewSourcePort
            NULL,                           // RestrictedAdapterIndex
			NULL,                           // CompletionRoutine
			NULL,							// CompletionContext
            NULL);                          // NotifyEvent

		if (Status != NO_ERROR) {
		
	        DebugF (_T("RTCP: 0x%x failed to set up redirect for reverse RTCP stream: (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X). Error - %d.\n"),
                &GetCallBridge (),
                m_OwnDestIPv4Address,			
                m_OwnDestRecvRTCPPort,			
                m_OwnSourceIPv4Address,			
                m_OwnSourceSendRTCPPort,		
                m_SourceRTCPIPv4Address,		
                m_SourceRTCPPort,				
                Status);
                
			// close the forward RTP stream
			// ignore error code

			NatCancelRedirect(
                NatHandle,
				IPPROTO_UDP,					// UDP
				htonl(m_OwnSourceIPv4Address),	// source packet dest address (local)
				htons(m_OwnSourceRecvRTPPort),	// source packet dest port (local)
				htonl(0),						// wildcard - source packet source address
				htons(0),						// wildcard - source packet source port
				htonl(m_DestRTPIPv4Address),	// NewDestinationAddress
				htons(m_DestRTPPort),			// NewDestinationPort
				htonl(m_OwnDestIPv4Address),	// NewSourceAddress
				htons(m_OwnDestSendRTPPort)		// NewSourcePort
				);

			// close the forward RTCP stream
			// ignore error code
			NatCancelRedirect(
                NatHandle,
				IPPROTO_UDP,					// UDP
				htonl(m_OwnSourceIPv4Address),	// source packet dest address (local)
				htons(m_OwnSourceRecvRTCPPort),	// source packet dest port (local)
				htonl(0),						// wildcard - source packet source address
				htons(0),						// wildcard - source packet source port
				htonl(m_DestRTCPIPv4Address),	// NewDestinationAddress
				htons(m_DestRTCPPort),			// NewDestinationPort
				htonl(m_OwnDestIPv4Address),	// NewSourceAddress
				htons(m_OwnDestSendRTCPPort)	// NewSourcePort
				);

			return E_FAIL;
		}
		else {
		
	        DebugF (_T("RTCP: 0x%x set up redirect for reverse RTCP stream: (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X).\n"),
                &GetCallBridge (),
                m_OwnDestIPv4Address,			
                m_OwnDestRecvRTCPPort,			
                m_OwnSourceIPv4Address,			
                m_OwnSourceSendRTCPPort,		
                m_SourceRTCPIPv4Address,		
                m_SourceRTCPPort);				
       }

	}

	return S_OK;
}


void
RTP_LOGICAL_CHANNEL::CloseNATMappings(
	)
{
	// if our current state is LC_STATE_OPEN_ACK_RCVD or 
	// LC_STATE_OPENED_CLOSE_RCVD, we have a forward RTP NAT mapping
	// we may also have to close the RTCP mappings
	if ( (LC_STATE_OPEN_ACK_RCVD	 == m_LogicalChannelState) ||
		 (LC_STATE_OPENED_CLOSE_RCVD == m_LogicalChannelState)  )
	{

        DebugF (_T ("RTP : 0x%x cancels forward RTP  redirect (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X).\n"),
            &GetCallBridge (),
			m_OwnSourceIPv4Address,	// source packet dest address (local)
			m_OwnSourceRecvRTPPort,		// source packet dest port (local)
			m_OwnDestIPv4Address,	// NewSourceAddress
			m_OwnDestSendRTPPort,	// NewSourcePort
			m_DestRTPIPv4Address,	// NewDestinationAddress
			m_DestRTPPort			// NewDestinationPort
			);
		// cancel forward RTP NAT mapping
		// ignore error code
		ULONG Win32ErrorCode = NO_ERROR;
		Win32ErrorCode = NatCancelRedirect(
                NatHandle,
				IPPROTO_UDP,					// UDP
				htonl(m_OwnSourceIPv4Address),	// source packet dest address (local)
				htons(m_OwnSourceRecvRTPPort),	// source packet dest port (local)
				htonl(0),						// wildcard - source packet source address
				htons(0),						// wildcard - source packet source port
				htonl(m_DestRTPIPv4Address),	// NewDestinationAddress
				htons(m_DestRTPPort),			// NewDestinationPort
				htonl(m_OwnDestIPv4Address),	// NewSourceAddress
				htons(m_OwnDestSendRTPPort)		// NewSourcePort
            );

		// if we don't have an associated logical channel or its in neither
		// LC_STATE_OPEN_ACK_RCVD nor LC_STATE_OPENED_CLOSE_RCVD, we
		// must close the forward and reverse RTCP NAT mappings
		if ( (NULL == m_pAssocLogicalChannel) ||
			 ( (LC_STATE_OPEN_ACK_RCVD	 != 
					m_pAssocLogicalChannel->m_LogicalChannelState) &&
			   (LC_STATE_OPENED_CLOSE_RCVD != 
					m_pAssocLogicalChannel->m_LogicalChannelState)  ) )
		{
            DebugF (_T ("RTCP: 0x%x cancels forward RTCP redirect (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X).\n"),
                &GetCallBridge (),
				m_OwnSourceIPv4Address,		// source packet dest address (local)
				m_OwnSourceRecvRTCPPort,	// source packet dest port (local)
				m_OwnDestIPv4Address,		// NewSourceAddress
				m_OwnDestSendRTCPPort, 		// NewSourcePort
				m_DestRTCPIPv4Address,		// NewDestinationAddress
				m_DestRTCPPort				// NewDestinationPort
				);
			// cancel forward RTCP NAT mapping
			// ignore error code
 			Win32ErrorCode = NatCancelRedirect(
                    NatHandle,
					IPPROTO_UDP,						// UDP
					htonl(m_OwnSourceIPv4Address),		// source packet dest address (local)
					htons(m_OwnSourceRecvRTCPPort),		// source packet dest port (local)
					htonl(0),							// wildcard - source packet source address
					htons(0),							// wildcard - source packet source port
					htonl(m_DestRTCPIPv4Address),		// NewDestinationAddress
					htons(m_DestRTCPPort),				// NewDestinationPort
					htonl(m_OwnDestIPv4Address),		// NewSourceAddress
					htons(m_OwnDestSendRTCPPort) 		// NewSourcePort
                );

            DebugF (_T ("RTCP: 0x%x cancels reverse RTCP redirect (*:* -> %08X:%04X) => (%08X:%04X -> %08X:%04X).\n"),
                &GetCallBridge (),
				m_OwnDestIPv4Address,		// source packet dest address (local)
				m_OwnDestRecvRTCPPort,		// source packet dest port (local)
				m_OwnSourceIPv4Address,		// NewSourceAddress
				m_OwnSourceSendRTCPPort,	// NewSourcePort
				m_SourceRTCPIPv4Address,	// NewDestinationAddress
				m_SourceRTCPPort			// NewDestinationPort
				);
			// close the reverse RTCP stream
			// ignore error code
			Win32ErrorCode = NatCancelRedirect(
                    NatHandle,
					IPPROTO_UDP,				// UDP
					htonl(m_OwnDestIPv4Address),	
						// source packet dest address (local)
					htons(m_OwnDestRecvRTCPPort),		
						// source packet dest port (local)
					htonl(0),		// wildcard - source packet source address
					htons(0),		// wildcard - source packet source port
					htonl(m_SourceRTCPIPv4Address),	// NewDestinationAddress
					htons(m_SourceRTCPPort),		// NewDestinationPort
					htonl(m_OwnSourceIPv4Address),	// NewSourceAddress
					htons(m_OwnSourceSendRTCPPort)	// NewSourcePort
                );
		}
	}
}



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


HRESULT
RTP_LOGICAL_CHANNEL::HandleOpenLogicalChannelPDU(
	IN H245_INFO							&H245Info,
    IN MEDIA_TYPE                           MediaType,
	IN DWORD								LocalIPv4Address,
	IN DWORD								RemoteIPv4Address,
	IN DWORD								OtherLocalIPv4Address,
	IN DWORD								OtherRemoteIPv4Address,
	IN WORD									LogicalChannelNumber,
	IN BYTE									SessionId,
	IN RTP_LOGICAL_CHANNEL					*pAssocLogicalChannel,
	IN DWORD								SourceRTCPIPv4Address,
	IN WORD									SourceRTCPPort,
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
/*++

Routine Description:

    
Arguments:
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
	// this should be the first call to this instance after its
	// created - hence, these fields must be as asserted
	_ASSERTE(LC_STATE_NOT_INIT == m_LogicalChannelState);
    _ASSERTE(NULL == m_pH245Info);
    _ASSERTE(NULL == m_pAssocLogicalChannel);

	HRESULT HResult = E_FAIL;

    m_pH245Info             = &H245Info;

    // the destructor will try to release associations, so assign the
    // associated logical channel now
    m_pAssocLogicalChannel = pAssocLogicalChannel;

	// set the local/remote addresses for our and the other h245 instance
	m_OwnSourceIPv4Address	= LocalIPv4Address;
	m_SourceIPv4Address		= RemoteIPv4Address;
	m_OwnDestIPv4Address	= OtherLocalIPv4Address;
	m_DestIPv4Address		= OtherRemoteIPv4Address;

    m_LogicalChannelNumber  = LogicalChannelNumber;
    m_SessionId             = SessionId;
    m_MediaType             = MediaType;  //  XXX

    m_SourceRTCPIPv4Address = SourceRTCPIPv4Address;
    m_SourceRTCPPort        = SourceRTCPPort;

	// set the rtp and rtcp ports on the source and dest side
	// if there is a logical channel, then, just the rtcp ports will be shared
	HResult = SetPorts();
	if (FAILED(HResult))
	{
        DebugF( _T("RTP_LOGICAL_CHANNEL::HandleOpenLogicalChannelPDU, ")
            _T("failed to set its ports, returning 0x%x\n"),
            HResult);
        return HResult;
    }
	//_ASSERTE(S_FALSE != HResult);


    OpenLogicalChannel &OlcPDU = 
        pH245pdu->u.request.u.openLogicalChannel;
    OpenLogicalChannel_forwardLogicalChannelParameters_multiplexParameters & MultiplexParams = 
        OlcPDU.forwardLogicalChannelParameters.multiplexParameters;
    H2250LogicalChannelParameters &H2250Params =
        MultiplexParams.u.h2250LogicalChannelParameters;

    // modify the OLC PDU by replacing the RTCP address/port
	// with the h245 address and RTCP port
	FillH245TransportAddress(
		m_OwnDestIPv4Address,
		m_OwnDestRecvRTCPPort,
		H2250Params.mediaControlChannel);

    // Should the part below be pushed into H245_INFO::HandleOpenLogicalChannelPDU ?????
    // let the other H245 instance process the PDU
    HResult = m_pH245Info->GetOtherH245Info().ProcessMessage(
                pH245pdu
                );
    if (FAILED(HResult))
    {
		DebugF(_T("RTP_LOGICAL_CHANNEL::HandleOpenLogicalChannelPDU: other H245 instance failed to process OLC PDU, returning 0x%x\n"), HResult);
        return HResult;
    }

	// start timer for a response
	// TO DO *** creating timers after queueing the send is sufficient.
	// change back earlier policy of creating these only after the send
	// callback (to be consistent). creating timers that way would be too
	// complex for logical channels
	HResult = CreateTimer(LC_POST_OPEN_TIMER_VALUE);
    if (FAILED(HResult))
    {
        DebugF (_T("RTP : 0x%x failed to create timer for duration %d milliseconds ('Open Logical Channel'). Error - %x.\n"),
             &GetCallBridge (), 
             LC_POST_OPEN_TIMER_VALUE,
             HResult);
        return HResult;
    }
    DebugF (_T("RTP : 0x%x created timer for duration %d milliseconds ('Open Logical Channel').\n"),
         &GetCallBridge (), 
         LC_POST_OPEN_TIMER_VALUE);

    // transition state to LC_STATE_OPEN_RCVD
    m_LogicalChannelState   = LC_STATE_OPEN_RCVD;

    return S_OK;
}


HRESULT
RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU(
    IN  MultimediaSystemControlMessage  &H245pdu,
    OUT BYTE                            &SessionId,
    OUT DWORD                           &DestRTPIPv4Address,
    OUT WORD                            &DestRTPPort,
    OUT DWORD                           &DestRTCPIPv4Address,
    OUT WORD                            &DestRTCPPort
    )
/*++

Routine Description:

    
Arguments:
    
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    // get the open logical channel ack PDU
    OpenLogicalChannelAck &OlcAckPDU = H245pdu.u.response.u.openLogicalChannelAck;

    // there shouldn't be reverse logical channel parameters
    if (OpenLogicalChannelAck_reverseLogicalChannelParameters_present &
            OlcAckPDU.bit_mask)
    {
        DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, has ")
            _T("reverse logical channel params, returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    // there shouldn't be a separate stack
    if (OpenLogicalChannelAck_separateStack_present &
            OlcAckPDU.bit_mask)
    {
        DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
            _T("has a separate stack, returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    // we should have forward multiplex ack params - these contain the
    // H245 params
    if ( !(forwardMultiplexAckParameters_present &
            OlcAckPDU.bit_mask) )
    {
        DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
                _T("doesn't have forward multiplex ack params,")
                _T(" returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    // we should have the H245 params
    if (h2250LogicalChannelAckParameters_chosen !=
            OlcAckPDU.forwardMultiplexAckParameters.choice)
    {
        DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
            _T("doesn't have H2250 ack params, returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    H2250LogicalChannelAckParameters &H2250Params =
        OlcAckPDU.forwardMultiplexAckParameters.\
        u.h2250LogicalChannelAckParameters;

    // it should have media channel info
    if ( !(H2250LogicalChannelAckParameters_mediaChannel_present &
            H2250Params.bit_mask) )
    {
        DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
            _T("doesn't have media channel info, returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    // it should have control channel info
    if ( !(H2250LogicalChannelAckParameters_mediaControlChannel_present &
            H2250Params.bit_mask) )
    {
        DebugF(_T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
                _T("doesn't have media control channel info,")
                _T(" returning E_INVALIDARG\n"));
        return E_INVALIDARG;
    }

    // save remote client RTP address/port
    HRESULT HResult = E_FAIL;
    HResult = GetH245TransportInfo(
                H2250Params.mediaChannel,
                DestRTPIPv4Address,
                DestRTPPort);

    if (FAILED(HResult))
    {
        DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
            _T("can't get media channel (RTP) address/port, returning 0x%x\n"),
            HResult);
        return HResult;
    }
    _ASSERTE(S_OK == HResult);

    // save remote client RTP address/port
    HResult = GetH245TransportInfo(
                H2250Params.mediaControlChannel,
                DestRTCPIPv4Address,
                DestRTCPPort);

    if (FAILED(HResult))
    {
        DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
            _T("can't get media control channel (RTCP) address/port, ")
            _T("returning 0x%x\n"),
            HResult);
        return HResult;
    }
    _ASSERTE(S_OK == HResult);

    // if there is a session id, save it
    if (sessionID_present & H2250Params.bit_mask)
    {
        // the PDU stores the session ID as an unsigned short
        // although the ITU spec requires it to be a BYTE value [0..255]
        // the cast to BYTE is intentional
        _ASSERTE(255 >= H2250Params.sessionID);
        SessionId = (BYTE)H2250Params.sessionID;

        // the session id must be non-zero
        if (0 == SessionId)
        {
            DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
                _T("has a session id of 0, returning E_INVALIDARG\n"));
            return E_INVALIDARG;
        }
    }
    else
    {
        // if no session id is supplied, the source must have supplied
        // a non-zero session id in OpenLogicalChannel
        if (0 == SessionId)
        {
            DebugF( _T("RTP_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ")
                _T("the source supplied a session id of 0 and the dest hasn't")
                _T("supplied one, returning E_INVALIDARG\n"));
            return E_INVALIDARG;
        }
    }

    return HResult;
}


HRESULT
RTP_LOGICAL_CHANNEL::ProcessOpenLogicalChannelAckPDU(
    IN      MultimediaSystemControlMessage   *pH245pdu
    )
/*++

Routine Description:

    
Arguments:
    
    pH245pdu - 
    
Return Values:

    S_OK on success.
    E_INVALIDARG if the PDU is invalid.

--*/
{
    HRESULT HResult = E_FAIL;
	switch(m_LogicalChannelState)
	{
	case LC_STATE_OPEN_RCVD:
		{
			HResult = CheckOpenLogicalChannelAckPDU(
						*pH245pdu,
						m_SessionId, 
						m_DestRTPIPv4Address, 
						m_DestRTPPort, 
						m_DestRTCPIPv4Address, 
						m_DestRTCPPort
						);
			if (FAILED(HResult))
			{
				DebugF( _T("RTP_LOGICAL_CHANNEL::ProcessOpenLogicalChannelAckPDU")
                        _T("(&%x), can't process OpenLogicalChannelAck, returning 0x%x\n"),
                        pH245pdu, HResult);
				return HResult;
			}
			_ASSERTE(S_OK == HResult);

			HResult = OpenNATMappings();
			if (FAILED(HResult))
			{
				DebugF( _T("RTP_LOGICAL_CHANNEL::ProcessOpenLogicalChannelAckPDU")
                        _T("(&%x), can't process OpenLogicalChannelAck, returning 0x%x\n"),
                        pH245pdu, HResult);
				return HResult;
			}
			_ASSERTE(S_OK == HResult);

			OpenLogicalChannelAck &OlcAckPDU =
                pH245pdu->u.response.u.openLogicalChannelAck;
			H2250LogicalChannelAckParameters &H2250Params =
				OlcAckPDU.forwardMultiplexAckParameters.u.h2250LogicalChannelAckParameters;

			// replace the RTP address/port
			// with the H.245 address and RTP port
			FillH245TransportAddress(
				m_OwnSourceIPv4Address,
				m_OwnSourceRecvRTPPort,
				H2250Params.mediaChannel
				);

			// replace the RTCP address/port
			// with the h245 address and RTCP port
			FillH245TransportAddress(
				m_OwnSourceIPv4Address,
				m_OwnSourceRecvRTCPPort,
				H2250Params.mediaControlChannel);

			// reset timer, we must have one (ignore error code if any)
			_ASSERTE(NULL != m_TimerHandle);
			TimprocCancelTimer();
            DebugF (_T("RTP : 0x%x cancelled timer.\n"),
                 &GetCallBridge ());

			// trasition to LC_STATE_OPEN_ACK_RCVD
			m_LogicalChannelState = LC_STATE_OPEN_ACK_RCVD;
		}
		break;

	case LC_STATE_CLOSE_RCVD:
		{
			// if we have received a close logical channel PDU, we must throw
			// OLC ACKs away and continue to wait
			DebugF( _T("RTP_LOGICAL_CHANNEL::ProcessOpenLogicalChannelAckPDU")
                    _T("(&%x), in close state %d, returning E_INVALIDARG\n"),
                    pH245pdu, m_LogicalChannelState);
			return E_INVALIDARG;
		}
		break;

	case LC_STATE_NOT_INIT:
	case LC_STATE_OPEN_ACK_RCVD:
	case LC_STATE_OPENED_CLOSE_RCVD:
	default:
		{
			DebugF( _T("RTP_LOGICAL_CHANNEL::ProcessOpenLogicalChannelAckPDU")
                    _T("(&%x), in state %d, returning E_UNEXPECTED"),
                    pH245pdu, m_LogicalChannelState);
            _ASSERTE(FALSE);
			return E_UNEXPECTED;
		}
		break;
	};

    return HResult;
}