|
|
#include "stdafx.h"
#include "portmgmt.h"
#include "timerval.h"
#include "cbridge.h"
#include "main.h"
// destructor
// virtual
T120_LOGICAL_CHANNEL::~T120_LOGICAL_CHANNEL( ){ if ( INVALID_HANDLE_VALUE != m_DynamicRedirectHandle ) { NatCancelDynamicRedirect( m_DynamicRedirectHandle ); m_DynamicRedirectHandle = INVALID_HANDLE_VALUE; }
// Free the ports if they have been allocated
FreePorts();}
// All params in host order
HRESULTT120_LOGICAL_CHANNEL::SetPorts( DWORD T120ConnectToIPAddr, WORD T120ConnectToPort, DWORD T120ListenOnIPAddr, DWORD T120ConnectFromIPAddr ){ HRESULT HResult;
// CODEWORK: Decide on the maximum number of TCP/IP connections to
// to allow to the same port. CurtSm suggests 8. MaxM thinks 4 for
// NM3.0 and 5 in general - currently allow 5.
// Allocate m_T120ListenOnPort and m_T120ConnectFromPorts
// Note that I am using the same routine I use to reserve
// ports for RTP/RTCP. This call reserves a pair of ports.
// CODEWORK: The port pool should have functions which
// reserve more than 2 ports (6 ports).
HResult = PortPoolAllocRTPPort(&m_T120ListenOnPort); if (FAILED(HResult)) { return HResult; }
m_T120ConnectToIPAddr = T120ConnectToIPAddr; m_T120ConnectToPort = T120ConnectToPort;
m_T120ListenOnIPAddr = T120ListenOnIPAddr; m_T120ConnectFromIPAddr = T120ConnectFromIPAddr;
HResult = CreateNatRedirect(); if (FAILED(HResult)) { return HResult; } _ASSERTE(S_OK == HResult); return S_OK;}
HRESULTT120_LOGICAL_CHANNEL::FreePorts(){ HRESULT Result;
CancelNatRedirect(); if (m_T120ListenOnPort != 0) { Result = PortPoolFreeRTPPort(m_T120ListenOnPort); if (FAILED(Result)) { DebugF( _T("T120_LOGICAL_CHANNEL::FreePorts: PortPoolFreeRTPPort ") _T("failed error: 0x%x\n"), Result); } m_T120ListenOnPort = 0; }
return S_OK;}
///////////////////////////////////////////////////////////////////////////////
// //
// Routines for setting up and tearing down NAT Redirects //
// //
///////////////////////////////////////////////////////////////////////////////
// This is defined in rtplc.cpp
// This should not be required. But currently there is a bug in the API impl.
// Create the NAT redirect
HRESULTT120_LOGICAL_CHANNEL::CreateNatRedirect( ){ // XXX Actually so many checks are not needed
if (m_T120ConnectToIPAddr == INADDR_NONE || m_T120ConnectToPort == 0 || m_T120ListenOnPort == 0 ) { DebugF( _T("T120_LOGICAL_CHANNEL::CreateNatRedirect() Ports not set") _T("m_120ConnectToIPAddr: %d.%d.%d.%d\n"), BYTES0123(m_T120ConnectToIPAddr) ); // INVALID state or some such
return E_UNEXPECTED; }
ULONG Status; Status = NatCreateDynamicRedirect( NatRedirectFlagLoopback, IPPROTO_TCP, htonl(m_T120ListenOnIPAddr), htons(m_T120ListenOnPort), htonl(m_T120ConnectToIPAddr), htons(m_T120ConnectToPort), 0, 0, &m_DynamicRedirectHandle );
if (Status != STATUS_SUCCESS) { DebugF (_T ("T120: failed to set up dynamic redirect (*.* -> %08X:%04X) => (*.* -> %08X:%04X).\n"), m_T120ListenOnIPAddr, // source packet dest address (local)
m_T120ListenOnPort, // source packet dest port (local)
m_T120ConnectToIPAddr, // NewDestinationAddress
m_T120ConnectToPort); // NewDestinationPort
return (HRESULT) Status; } else { DebugF (_T ("T120: 0x%x set up dynamic redirect (*.* -> %08X:%04X) => (*.* -> %08X:%04X).\n"), &GetCallBridge (), m_T120ListenOnIPAddr, // source packet dest address (local)
m_T120ListenOnPort, // source packet dest port (local)
m_T120ConnectToIPAddr, // NewDestinationAddress
m_T120ConnectToPort); // NewDestinationPort
} return S_OK;}
voidT120_LOGICAL_CHANNEL::CancelNatRedirect( ){ // CODEWORK: CODEWORK:
// Note that this routine gets called every time the destructor
// gets called and this means that only half of the redirects could
// have been established or whatever. So we need to check whether
// each of the redirects has been established. For this purpose
// it is probably advisable to have one more field storing whether
// the redirect has been estd. so that we can appropriately clean
// it up. This field should also be useful in the WSP filter scenario
// where we don't actually store the ports.
// if our current state is LC_STATE_OPEN_ACK_RCVD or
// LC_STATE_OPENED_CLOSE_RCVD, we have a NAT mapping
ULONG Win32ErrorCode; DebugF (_T("T120: 0x%x cancels redirect (*:* -> %08X:%04X) => (*:* -> %08X:%04X).\n"), &GetCallBridge (), m_T120ListenOnIPAddr, // source packet dest address (local)
m_T120ListenOnPort, // source packet dest port (local)
// m_T120ConnectFromIPAddr, // NewSourceAddress
// m_T120ConnectFromPorts[i],
m_T120ConnectToIPAddr, // NewDestinationAddress
m_T120ConnectToPort); // NewDestinationPort
if ( INVALID_HANDLE_VALUE != m_DynamicRedirectHandle ) { Win32ErrorCode = NatCancelDynamicRedirect( m_DynamicRedirectHandle ); m_DynamicRedirectHandle = INVALID_HANDLE_VALUE; }
return;}
#define INADDR_PRIVATE_HOSTORDER 0xC0A80001
BOOL T120_LOGICAL_CHANNEL::IsT120RedirectNeeded( DWORD T120ConnectToIPAddr, DWORD T120ListenOnIPAddr, DWORD T120ConnectFromIPAddr ){ HRESULT hr; BOOL IsPrivateDestination; BOOL IsPrivateSource = FALSE; BOOL IsPrivateListen = FALSE;
BOOL fIsRedirectNeeded = TRUE;
hr = ::IsPrivateAddress( T120ConnectToIPAddr, &IsPrivateDestination ); ::IsPrivateAddress( T120ConnectToIPAddr, &IsPrivateSource ); ::IsPrivateAddress( T120ListenOnIPAddr, &IsPrivateListen );
DebugF( _T("Address %08X isPrivateDestionation %s\n"), T120ConnectToIPAddr, IsPrivateDestination ? _T("TRUE"):_T("FALSE") ); DebugF( _T("Address %08X isPrivateSource %s\n"), T120ConnectFromIPAddr, IsPrivateSource ? _T("TRUE"):_T("FALSE") ); DebugF( _T("Address %08X isPrivateSource %s\n"), T120ListenOnIPAddr, IsPrivateListen ? _T("TRUE"):_T("FALSE") );
if ( (INADDR_PRIVATE_HOSTORDER == T120ConnectToIPAddr) || (INADDR_PRIVATE_HOSTORDER == T120ListenOnIPAddr) ) { fIsRedirectNeeded = FALSE; } else if ( SUCCEEDED(hr) && ((FALSE == IsPrivateDestination) && (T120ListenOnIPAddr != T120ConnectToIPAddr)) ) { fIsRedirectNeeded = FALSE; }
if ( !fIsRedirectNeeded ) { DebugF( _T(" T120 Redirect is NOT needed %08X\n"), T120ConnectToIPAddr ); return FALSE; } return TRUE;}
///////////////////////////////////////////////////////////////////////////////
// //
// Routines for processing H.245 PDUs //
// //
///////////////////////////////////////////////////////////////////////////////
// all of these are available in the OPEN LOGICAL CHANNEL message
// it modifies the OLC PDU and passes it on to the other H245
// instance for forwarding ???
HRESULTT120_LOGICAL_CHANNEL::HandleOpenLogicalChannelPDU( IN H245_INFO &H245Info, IN MEDIA_TYPE MediaType, IN WORD LogicalChannelNumber, IN BYTE SessionId, IN DWORD T120ConnectToIPAddr, IN WORD T120ConnectToPort, IN OUT MultimediaSystemControlMessage *pH245pdu )/*++
Routine Description:
This routine handles a T120 OLC PDU. The T120_LOGICAL_CHANNEL is create by H245_INFO::HandleOpenLogicalChannelPDU(). If T120ConnectToIPAddr and Port are specified, then m_T120ListenOnPort and m_T120ConnectFromPorts are allocated and the listen address field in pH245pdu are replaced with an IP address and port on the other edge of the proxy. Arguments: H245Info - MediaType - LogicalChannelNumber - SessionId - T120ConnectToIPAddr - T120ConnectToPort - pH245pdu - If the T120ConnectToIPAddr and Port are specified then the listen address field in the H245 pdu is replaced with an IP address and port on the other edge of the proxy.
Return Values:
S_OK on success. E_INVALIDARG if the PDU is invalid.
--*/{
// CODEWORK: assert that we are dealing with a T120 PDU
// 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);
HRESULT HResult = E_FAIL;
m_pH245Info = &H245Info;
DWORD T120ListenOnIPAddr = ntohl (m_pH245Info->GetOtherH245Info().GetSocketInfo().LocalAddress.sin_addr.s_addr); DWORD T120ConnectFromIPAddr = ntohl (m_pH245Info->m_SocketInfo.LocalAddress.sin_addr.s_addr);
// If the IP address that we need to connect to is specified in the
// OLC PDU, then we need to allocate the port for listening on the
// other interface.
if ( (T120ConnectToIPAddr != INADDR_NONE) && IsT120RedirectNeeded(T120ConnectToIPAddr, T120ListenOnIPAddr, T120ConnectFromIPAddr) ) { HResult = SetPorts( T120ConnectToIPAddr, T120ConnectToPort, T120ListenOnIPAddr, // listen on other h245 local address
T120ConnectFromIPAddr // connect from our local address
); if (FAILED(HResult)) { DebugF( _T("T120_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; // modify the OLC PDU by replacing the RTCP address/port
// with the h245 address and RTCP port
FillH245TransportAddress( m_T120ListenOnIPAddr, m_T120ListenOnPort, OlcPDU.separateStack.networkAddress.u.localAreaAddress ); } else { m_T120ConnectToIPAddr = T120ConnectToIPAddr; m_T120ConnectToPort = T120ConnectToPort; m_T120ListenOnIPAddr = T120ListenOnIPAddr; m_T120ConnectFromIPAddr = T120ConnectFromIPAddr; }
// 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("T120_LOGICAL_CHANNEL::HandleOpenLogicalChannelPDU") _T("(&H245Info, %u, %u, %d.%d.%d.%d, %u, 0x%x, 0x%x)") _T("other H245 instance failed to process OLC PDU, returning 0x%x\n"), LogicalChannelNumber, SessionId, BYTES0123(T120ConnectToIPAddr), T120ConnectToPort, pH245pdu, 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("T120: 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("T120: 0x%x created timer for duration %d milliseconds ('Open Logical Channel').\n"), &GetCallBridge (), LC_POST_OPEN_TIMER_VALUE); //_ASSERTE(S_FALSE != HResult);
InitLogicalChannel(&H245Info, MediaType, LogicalChannelNumber, SessionId, LC_STATE_OPEN_RCVD);
// transition state to LC_STATE_OPEN_RCVD
m_LogicalChannelState = LC_STATE_OPEN_RCVD;
return S_OK;}
// If there is no T.120 Listen address in the PDU
// T120ConnectToIPAddr will contain INADDR_NONE
HRESULTT120_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU( IN OpenLogicalChannelAck &OlcAckPDU, OUT DWORD &T120ConnectToIPAddr, OUT WORD &T120ConnectToPort )/*++
Routine Description:
Arguments: OlcAckPDU - T120ConnectToIPAddr - T120ConnectToPort - Return Values:
S_OK on success. E_INVALIDARG if the PDU is invalid.
--*/{ HRESULT HResult = S_OK;
// These are the return values in case of a failure
// or if the address is not present in the PDU
T120ConnectToIPAddr = INADDR_NONE; T120ConnectToPort = 0; // there should be reverse logical channel parameters
if (!(OpenLogicalChannelAck_reverseLogicalChannelParameters_present & OlcAckPDU.bit_mask)) { DebugF( _T("T120_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, NO") _T("reverse logical channel params, returning E_INVALIDARG\n")); return E_INVALIDARG; }
// there should be a separate stack if we do not have
// a T.120 end point address to connect to (from the OLC PDU).
if (!(OpenLogicalChannelAck_separateStack_present & OlcAckPDU.bit_mask) && m_T120ConnectToIPAddr == INADDR_NONE) { DebugF( _T("T120_LOGICAL_CHANNEL::CheckOpenLogicalChannelAckPDU, ") _T("NO separate stack, returning E_INVALIDARG\n")); return E_INVALIDARG; }
if (OpenLogicalChannelAck_separateStack_present & OlcAckPDU.bit_mask) { HResult = GetT120ConnectToAddress( OlcAckPDU.separateStack, T120ConnectToIPAddr, T120ConnectToPort ); } return HResult;}
HRESULTT120_LOGICAL_CHANNEL::ProcessOpenLogicalChannelAckPDU( IN MultimediaSystemControlMessage *pH245pdu )/*++
Routine Description:
Arguments: pH245pdu - Return Values:
S_OK on success. E_INVALIDARG if the PDU is invalid.
--*/{ //The type of this pdu should be OLC Ack
_ASSERTE(pH245pdu->u.response.choice == openLogicalChannelAck_chosen); HRESULT HResult = E_FAIL; OpenLogicalChannelAck &OlcAckPDU = pH245pdu->u.response.u.openLogicalChannelAck;
switch(m_LogicalChannelState) { case LC_STATE_OPEN_RCVD: DWORD T120ConnectToIPAddr; WORD T120ConnectToPort; DWORD T120ListenOnIPAddr; DWORD T120ConnectFromIPAddr;
T120ConnectFromIPAddr = ntohl (m_pH245Info->GetOtherH245Info().GetSocketInfo().LocalAddress.sin_addr.s_addr); T120ListenOnIPAddr = ntohl (m_pH245Info->m_SocketInfo.LocalAddress.sin_addr.s_addr);
HResult = CheckOpenLogicalChannelAckPDU( OlcAckPDU, T120ConnectToIPAddr, T120ConnectToPort ); if (FAILED(HResult)) { return HResult; } _ASSERTE(S_OK == HResult);
if ( (T120ConnectToIPAddr != INADDR_NONE) && IsT120RedirectNeeded(T120ConnectToIPAddr, T120ListenOnIPAddr, T120ConnectFromIPAddr) ) { HResult = SetPorts( T120ConnectToIPAddr, T120ConnectToPort, T120ListenOnIPAddr, // listen on our local address
T120ConnectFromIPAddr // connect from other h245 local address
); if (FAILED(HResult)) { return HResult; }
// modify the OLC PDU by replacing the RTCP address/port
// with the h245 address and RTCP port
FillH245TransportAddress( m_T120ListenOnIPAddr, m_T120ListenOnPort, OlcAckPDU.separateStack.networkAddress.u.localAreaAddress ); } else { m_T120ConnectToIPAddr = T120ConnectToIPAddr; m_T120ConnectToPort = T120ConnectToPort;
m_T120ListenOnIPAddr = T120ListenOnIPAddr; m_T120ConnectFromIPAddr = T120ConnectFromIPAddr; }
// reset timer, we must have one (ignore error code if any)
//_ASSERTE(NULL != m_TimerHandle);
TimprocCancelTimer(); DebugF (_T("T120: 0x%x cancelled timer.\n"), &GetCallBridge ());
// transition 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("T120_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("T120_LOGICAL_CHANNEL::ProcessOpenLogicalChannelAckPDU") _T("(&%x), in state %d, returning E_UNEXPECTED\n"), pH245pdu, m_LogicalChannelState); _ASSERTE(FALSE); return E_UNEXPECTED; break; } // switch (m_LogicalChannelState)
return HResult;}
|
