windows-server-2003/enduser/netmeeting/av/h323/connobj.cpp

/*
 *  	File: connobj.cpp
 *
 *		implementation of Microsoft Network Audio connection object.
 *
 *		
 *
 *		Revision History:
 *
 *		05/05/96	mikev	created
 *	 	08/04/96	philf	added support for video
 *      09/22/96	mikev	dual call control protocols (H.323 & MSICCP)
 *      10/14/96	mikev	multiple channel support, property I/F
 */


#include "precomp.h"
#include "ctrlh323.h"
#include "strutil.h"


CREQ_RESPONSETYPE CConnection::FilterConnectionRequest(
    LPIControlChannel lpControlChannel,
     P_APP_CALL_SETUP_DATA pAppData)
{
	FX_ENTRY ("CConnection::FilterConnectionRequest");
	CREQ_RESPONSETYPE cr;
	// validate lpControlChannel - this implementation sets it inside
	// GetAcceptingObject()
	if(m_pControlChannel != lpControlChannel)
	{
		ERRORMESSAGE(("%s:bad param:my pChan:0x%08lX, param pChan:0x%08lX\r\n",
			_fx_, m_pControlChannel, lpControlChannel));
		hrLast = CADV_E_INVALID_PARAM;
		return CRR_ERROR;
	}	
	m_ConnectionState = CLS_Alerting;
	cr = m_pH323CallControl->FilterConnectionRequest(this, pAppData);
	switch (cr)
	{
		case CRR_ASYNC:
			// m_ConnectionState = CLS_Alerting; // stays in this state
		break;
		case CRR_ACCEPT:
			m_ConnectionState = CLS_Connecting;
		break;	

		// set summary codes in reject cases
		case CRR_BUSY:
			m_ConnectionState = CLS_Idle;
			SummaryCode(CCR_LOCAL_BUSY);
		break;
		case CRR_SECURITY_DENIED:
			m_ConnectionState = CLS_Idle;
			SummaryCode(CCR_LOCAL_SECURITY_DENIED);
		break;
		default:
		case CRR_REJECT:
			m_ConnectionState = CLS_Idle;
			SummaryCode(CCR_LOCAL_REJECT);
		break;
	}
	return(cr);
}


HRESULT CConnection::FindAcceptingObject(LPIControlChannel *lplpAcceptingObject,
		LPVOID lpvConfID)
{
	FX_ENTRY ("CConnection::FindAcceptingObject");
	HRESULT hr = H323CC_E_CONNECTION_NOT_FOUND;
	ULONG ulCount, uNumConnections;
	CConnection **ppConnections = NULL;;
	LPIControlChannel pCtlChan;
	CConnection *pConnection;

	if(!lplpAcceptingObject)
	{
		ERRORMESSAGE(("%s:null lplpAcceptingObject\r\n",_fx_));
		return CADV_E_INVALID_PARAM;
	}
	// zero out the output param
	*lplpAcceptingObject = NULL;
	hr = m_pH323CallControl->GetNumConnections(&uNumConnections);
	if(!HR_SUCCEEDED(hr))
		goto EXIT;
	if(!uNumConnections)
	{
		// initialized value hr = H323CC_E_CONNECTION_NOT_FOUND;
		goto EXIT;
	}
	ppConnections = (CConnection **)MemAlloc(uNumConnections * (sizeof(IH323Endpoint * *)));
	if(!ppConnections)
	{
		hr = H323CC_E_INSUFFICIENT_MEMORY;	
		goto EXIT;
	}
			
	// get list of connections and query each one for matching conference ID
	hr = m_pH323CallControl->GetConnobjArray(ppConnections, uNumConnections * (sizeof(IH323Endpoint * *)));
	if(!HR_SUCCEEDED(hr))
		goto EXIT;
	
	for(ulCount=0;ulCount <uNumConnections;ulCount++)
	{
		pConnection = ppConnections[ulCount];
		if(pConnection &&  (pCtlChan = pConnection->GetControlChannel())
			&& pCtlChan->IsAcceptingConference(lpvConfID))
		{
			*lplpAcceptingObject = pCtlChan;
			hr = hrSuccess;
			break;
		}
	}

EXIT:
	if(ppConnections)
		MemFree(ppConnections);

	return hr;

}


HRESULT CConnection::GetAcceptingObject(LPIControlChannel *lplpAcceptingObject,
	LPGUID pPID)
{
	FX_ENTRY ("CConnection::GetAcceptingObject");
	HRESULT hr;
	CConnection *pNewConnection;
	if(!lplpAcceptingObject)
	{
		ERRORMESSAGE(("%s:null lplpAcceptingObject\r\n",_fx_));
		return CADV_E_INVALID_PARAM;
	}
	// zero out the output param
	*lplpAcceptingObject = NULL;
	
	// create a connection object to accept the connection
	hr = m_pH323CallControl->CreateConnection(&pNewConnection, *pPID);
	if(HR_SUCCEEDED(hr))
	{
		*lplpAcceptingObject = pNewConnection->GetControlChannel();
	}
	else
	{
		ERRORMESSAGE(("%s:CreateConnection failed, hr=0x%08lx\r\n",_fx_, hr));
	}
	return hr;
}

//  This is called by a comm channel.  It is only called by a channel that is being 
//  opened, and only if that channel is not already associated with a control channel.
HRESULT CConnection::AddCommChannel (ICtrlCommChan *pChan)
{
    GUID mid;
	if(!m_fCapsReady)
    {
    	ASSERT(0);
		hrLast = CONN_E_NOT_INITIALIZED;	// need better error to indicate why 
							// (connection is not yet in a state to take new channels)
		goto EXIT;
    }
 	
	// re-initialize channel	
    hrLast = pChan->GetMediaType(&mid);
    
	ASSERT(m_pH323ConfAdvise != NULL);
	if(!pChan->Init(&mid, m_pH323ConfAdvise, TRUE))
	{
		hrLast = CONN_E_SYSTEM_ERROR;
		goto EXIT;
	}

	// non error case continues here
	if(m_pControlChannel)
	{
		m_ChannelList.AddTail(pChan);
		pChan->AddRef();
		hrLast = m_pControlChannel->AddChannel(pChan, m_pCapObject);
		if(!HR_SUCCEEDED(hrLast))
			goto EXIT;
	}
    
  EXIT:
    return hrLast;
}


HRESULT CConnection::CreateCommChannel(LPGUID pMediaGuid, ICommChannel **ppICommChannel,
	BOOL fSend)
{
	FX_ENTRY ("CConnection::CreateCommChannel");
	ICommChannel *pICommChannel = NULL;
	ICtrlCommChan *pICtrlCommChannel = NULL;
	
	if(!pMediaGuid || !ppICommChannel)
	{
		hrLast = CONN_E_INVALID_PARAM;
		goto EXIT;
	}

    DBG_SAVE_FILE_LINE
	if(*pMediaGuid == MEDIA_TYPE_H323_T120)
	{
		if(!(pICommChannel = (ICommChannel *)new ImpT120Chan))
		{
			hrLast = CONN_E_OUT_OF_MEMORY;
			goto EXIT;
		}
	}
	else if(!(pICommChannel = (ICommChannel *)new ImpICommChan))
	{
		hrLast = CONN_E_OUT_OF_MEMORY;
		goto EXIT;
	}
	
	hrLast = pICommChannel->QueryInterface(IID_ICtrlCommChannel, (void **)&pICtrlCommChannel);
	if(!HR_SUCCEEDED(hrLast))
	{
		goto EXIT;
	}

	ASSERT(m_pH323ConfAdvise != NULL);
	if(!pICtrlCommChannel->Init(pMediaGuid, m_pH323ConfAdvise, fSend))
	{
		hrLast = CONN_E_SYSTEM_ERROR;
		goto EXIT;
	}

	// it's created via this connection, now associate it and this connection
	if(m_pControlChannel)
	{
		m_ChannelList.AddTail(pICtrlCommChannel);
		hrLast = m_pControlChannel->AddChannel(pICtrlCommChannel, m_pCapObject);
		if(!HR_SUCCEEDED(hrLast))
			goto EXIT;
	}


	// in success case, the calling function gets the ICommChannel reference, and this
	// object gets the ICtrlCommChan reference
	*ppICommChannel = pICommChannel;
	pICommChannel = NULL;
	pICtrlCommChannel = NULL;

	EXIT:
	if(pICommChannel)
		pICommChannel->Release();
	if(pICtrlCommChannel)
		pICtrlCommChannel->Release();	
	return hrLast;
}

HRESULT CConnection:: ResolveFormats (LPGUID pMediaGuidArray, UINT uNumMedia, 
	    PRES_PAIR pResOutput)
{
	ASSERT(NULL !=m_pCapObject);
	return (m_pCapObject->ResolveFormats(pMediaGuidArray, uNumMedia, pResOutput));
}

HRESULT CConnection::GetVersionInfo(PCC_VENDORINFO *ppLocalVendorInfo,
									  PCC_VENDORINFO *ppRemoteVendorInfo)
{
	if(!m_pControlChannel)
		return CONN_E_NOT_INITIALIZED;
		
	return (m_pControlChannel->GetVersionInfo(ppLocalVendorInfo, ppRemoteVendorInfo));
}

VOID CConnection ::ReleaseAllChannels()
{
	ICtrlCommChan *pChan = NULL;
	while (!m_ChannelList.IsEmpty())
	{
		pChan = (ICtrlCommChan *) m_ChannelList.RemoveHead();
		if(pChan)
		{
			pChan->Release();
			pChan = NULL;
		}
	}
}

//
// Implementation of IConfAdvise::OnControlEvent
//
// CAUTION: because Release() can be called by the registered event handler,
// any code path that accesses class instance data after a call to m_pH323ConfAdvise->CallEvent
// must AddRef() before the call, and Release() after all class instance data access
// is done.  The DoControlNotification() helper method does this, but beware of
// cases where data is touched after a call to DoControlNotification();
//
HRESULT CConnection::OnControlEvent(DWORD dwEvent, LPVOID lpvData, 	LPIControlChannel lpControlObject)
{
	FX_ENTRY ("CConnection::OnControlEvent");
	DWORD dwStatus;
	BOOL fPost = FALSE;
	HRESULT hr=hrSuccess;

	AddRef();
	switch(dwEvent)
	{	
		case  CCEV_RINGING:
			fPost = TRUE;
			dwStatus = CONNECTION_PROCEEDING;
		break;
		case  CCEV_CONNECTED:
			fPost = TRUE;
			dwStatus = CONNECTION_CONNECTED;
			NewUserInfo((LPCTRL_USER_INFO)lpvData);
		break;
		case  CCEV_CALLER_ID:
			NewUserInfo((LPCTRL_USER_INFO)lpvData);
		break;
		case  CCEV_CAPABILITIES_READY:
			m_fCapsReady = TRUE;
		break;

		case  CCEV_CHANNEL_REQUEST:
		// another channel (besides the channels supplied by EnumChannels()) is being 
		// requested -  we can't handle arbitrary channels yet.
			ERRORMESSAGE(("%s, not handling CCEV_CHANNEL_REQUEST \r\n",_fx_));
			hr = CADV_E_NOT_SUPPORTED;
			goto out;
		break;
		
		case  CCEV_DISCONNECTING:
			//in the future architecture, this event will be the opportunity to
			//cleanup channels
			if(lpvData)
			{
				// keep summary code
				SummaryCode((HRESULT) *((HRESULT *)lpvData));
			}
			Disconnect(CCR_UNKNOWN);
			// IConnect doesn't yet define a "disconnecting" event, so don't propagate it
		break;			
		case  CCEV_REMOTE_DISCONNECTING:
			if(lpvData)
			{
				SummaryCode((HRESULT) *((HRESULT *)lpvData));
			}
			// do notification before calling back into Disconnect, so the event
			// notifications are posted in the correct order. This is one of
			// the cases where Ref count protection is required.
			AddRef();
			DoControlNotification(CONNECTION_RECEIVED_DISCONNECT);
			// opportunity to cleanup channels
			Disconnect(CCR_UNKNOWN);
			Release();
		break;			
		case  CCEV_DISCONNECTED:
			fPost = TRUE;
			m_ConnectionState = CLS_Idle;
			dwStatus = CONNECTION_DISCONNECTED;
			if(lpvData)
			{
				SummaryCode((HRESULT) *((HRESULT *)lpvData));
			}
		break;		
		case  CCEV_ALL_CHANNELS_READY:
		 	// all *mandatory* channels are open, but not necessarily
		 	// all channels
			m_ConnectionState = CLS_Inuse;
			dwStatus = CONNECTION_READY;
			fPost = TRUE;
		break;
		case CCEV_ACCEPT_INCOMPLETE:
			if(lpvData)
			{
			// known problem is that control channel has already
			// disconnected and may have notified of the disconnect first.
			// This could be fixed, but it's not an issue because an incomplete
			// accept is not made known to the UI, therefore the summary code
			// is dust anyway.
				SummaryCode((HRESULT) *((HRESULT *)lpvData));
			}
			if(lpControlObject && (m_pControlChannel == lpControlObject))
			{
				// remove interest in control channel events, then nuke it
				m_pControlChannel->DeInit((IConfAdvise *) this);
				m_pControlChannel->Release();
			}
			m_pControlChannel = NULL;
			if(m_pH323CallControl)
			{
				m_pH323CallControl->RemoveConnection(this);
			}
			Release();	// release self - this is by design
					
	 	break;		 	
		case  CCEV_CALL_INCOMPLETE:
			hr = OnCallIncomplete(lpControlObject, (lpvData)?  ((DWORD) *((DWORD *)lpvData)) :0);
			goto out;
		break;		

 	}
	if(fPost)
		DoControlNotification(dwStatus);

out:
	Release();
	return hr;
}

HRESULT CConnection::OnCallIncomplete (LPIControlChannel lpControlObject, HRESULT hIncompleteCode)
{
	FX_ENTRY ("CConnection::OnCallIncomplete ");
	// check the reason for incomplete call attempt (busy? rejected? nobody home?
	HRESULT hSummary;
	CloseAllChannels();

	// map the protocol-specific (h.323, msiccp, sip, etc) code to the 
	// connection interface code
	// test for gatekeeper admission reject
	// FACILITY_GKIADMISSION
	if(CUSTOM_FACILITY(hIncompleteCode) == FACILITY_GKIADMISSION)
	{
		// pass GK codes through intact
		hSummary = hIncompleteCode;
	}
	else
	{
		switch (hIncompleteCode)
		{
			case CCCI_GK_NO_RESOURCES:
				hSummary = CCR_GK_NO_RESOURCES;
			break;
			case CCCI_BUSY:
				hSummary = CCR_REMOTE_BUSY;
			break;
			case CCCI_SECURITY_DENIED:
				hSummary = CCR_REMOTE_SECURITY_DENIED;
			break;
			case CCCI_NO_ANSWER_TIMEOUT:
				hSummary = CCR_NO_ANSWER_TIMEOUT;
			break;
			case CCCI_REJECTED:
				hSummary = CCR_REMOTE_REJECTED;
			break;
			case CCCI_REMOTE_ERROR:
				hSummary = CCR_REMOTE_SYSTEM_ERROR;
			break;
			case CCCI_LOCAL_ERROR:
				hSummary = CCR_LOCAL_SYSTEM_ERROR;
			break;
			case CCCI_INCOMPATIBLE:
				hSummary = CCR_LOCAL_PROTOCOL_ERROR;
			break;
			case CCCI_UNKNOWN:
				hSummary = CCR_UNKNOWN;
			default:
				hSummary = CCR_UNKNOWN;
			break;
		}
	}

	DEBUGMSG(ZONE_CONN,("%s: incomplete code = 0x%08lX\r\n",
		_fx_, hIncompleteCode));
	SummaryCode(hSummary);
	return hrLast;
}

VOID CConnection::NewUserInfo(LPCTRL_USER_INFO lpNewUserInfo)
{
	FX_ENTRY ("CConnection::NewUserInfo");
	
	if(!lpNewUserInfo || !lpNewUserInfo->dwCallerIDSize || !lpNewUserInfo->lpvCallerIDData)
		return;

	if(m_pUserInfo)
	{
		DEBUGMSG(ZONE_CONN,("%s:uninitialized m_pUserInfo (0x%08lX) or multiple notification \r\n",
			_fx_, m_pUserInfo ));
		//
		if(!IsBadWritePtr((LPVOID)m_pUserInfo, m_pUserInfo->dwCallerIDSize + sizeof(CTRL_USER_INFO)))
		{
			// chances are it *is* a multiple notification and not an uninitialized
			// variable.  Ther may be some control channel protocols that *update* user
			// information after connection or accepting, but that is pure speculation.
			// the typical case is that caller ID is available before accepting, and
			// it is resupplied in the subsequent "connected" notification.  We're not
			// wasting time realloc'ing and recopying it.
			return;
		}
		// else fallout and overwrite it
	}
	// copy the structure and caller ID data
	m_pUserInfo = (LPCTRL_USER_INFO)MemAlloc(lpNewUserInfo->dwCallerIDSize + sizeof(CTRL_USER_INFO));		
	
	if(m_pUserInfo)
	{
		m_pUserInfo->lpvRemoteProtocolInfo = NULL;  // nothing touchess this later, but being safe anyway
		m_pUserInfo->lpvLocalProtocolInfo = NULL;
		
		m_pUserInfo->dwCallerIDSize = lpNewUserInfo->dwCallerIDSize;
		// point past the structure
		m_pUserInfo->lpvCallerIDData = ((BYTE *)m_pUserInfo) + sizeof(CTRL_USER_INFO);
		memcpy(m_pUserInfo->lpvCallerIDData,
			lpNewUserInfo->lpvCallerIDData,
			m_pUserInfo->dwCallerIDSize);
	}
	else
	{
		ERRORMESSAGE(("%s:allocation of m_pUserInfo failed\r\n",_fx_));
	}
}	

//
// Utility function for passing control channel events to the registered handler
// This is callable only by the control channel code running in the same thread
// as that which created the connection.
VOID CConnection::DoControlNotification(DWORD dwStatus)
{
	FX_ENTRY ("CConnection::DoControlNotification");
	// issue notification to registered entity
	if(m_pH323ConfAdvise)
	{
		AddRef();	// protect ourselves from calls back into methods that
					// wind up in Release().
		DEBUGMSG(ZONE_CONN,("%s:issuing notification 0x%08lX\r\n",_fx_, dwStatus));
        m_pH323ConfAdvise->CallEvent((IH323Endpoint *)&m_ImpConnection, dwStatus);
  		Release();

	}
}


CConnection::CConnection()
:m_pH323CallControl(NULL),
hrLast(hrSuccess),
next(NULL),
m_fCapsReady(FALSE),
m_ConnectionState(CLS_Idle),
m_pH323ConfAdvise(NULL),
m_pUserInfo(NULL),
m_pControlChannel(NULL),
m_pCapObject(NULL),
m_hSummaryCode(hrSuccess),
uRef(1)
{
	m_ImpConnection.Init(this);
}

CConnection::~CConnection()
{
	ReleaseAllChannels();
	if(m_pH323CallControl)
		m_pH323CallControl->RemoveConnection(this);
		
	if(m_pCapObject)
		m_pCapObject->Release();
	// we really don't allocate much
	if(m_pUserInfo)
		MemFree(m_pUserInfo);
	
}   

HRESULT CConnection::Init(CH323CallControl *pH323CallControl, GUID PIDofProtocolType)
{
	FX_ENTRY(("CConnection::Init"));
	hrLast = hrSuccess;
    BOOL     bAdvertise;
	m_pH323CallControl = pH323CallControl;
	GUID mid;

	if(!pH323CallControl)
		return CCO_E_INVALID_PARAM;
		
	if(m_pControlChannel)
	{
		ASSERT(0);
		// don't cleanup in this case
		return CONN_E_ALREADY_INITIALIZED;
	}
	
	if(PIDofProtocolType != PID_H323)
	{
		hrLast = CONN_E_INIT_FAILED;
		goto ERROR_CLEANUP;
	}
	
    DBG_SAVE_FILE_LINE
	if(!(m_pControlChannel = (LPIControlChannel) new CH323Ctrl))
	{
		hrLast = CONN_E_INIT_FAILED;
		goto ERROR_CLEANUP;
	}

    DBG_SAVE_FILE_LINE
	if(!m_pCapObject && !(m_pCapObject = new CapsCtl()))
	{
		ERRORMESSAGE(("%s:cannot create capability resolver\r\n",_fx_));
		hrLast = CONN_E_INIT_FAILED;
		goto ERROR_CLEANUP;;
	}
	if(!m_pCapObject->Init())
	{
		ERRORMESSAGE(("%s:cannot init capability resolver\r\n",_fx_));
		hrLast = CONN_E_INIT_FAILED;
		goto ERROR_CLEANUP;
	}

    bAdvertise = ((g_capFlags & CAPFLAGS_AV_STREAMS) != 0);
	mid = MEDIA_TYPE_H323AUDIO;
	hrLast = m_pCapObject->EnableMediaType(bAdvertise, &mid);
	if(!HR_SUCCEEDED(hrLast))
		goto ERROR_CLEANUP;

    bAdvertise = ((g_capFlags & CAPFLAGS_AV_STREAMS) != 0);
	mid = MEDIA_TYPE_H323VIDEO;
	hrLast = m_pCapObject->EnableMediaType(bAdvertise, &mid);
	if(!HR_SUCCEEDED(hrLast))
		goto ERROR_CLEANUP;

	hrLast = m_pControlChannel->Init((IConfAdvise *) this);
	if(!HR_SUCCEEDED(hrLast))
		goto ERROR_CLEANUP;

	return hrLast;

	ERROR_CLEANUP:
	ERRORMESSAGE(("%s:ERROR_CLEANUP\r\n",_fx_));
	
	if(m_pControlChannel)
		m_pControlChannel->Release();
	if(m_pCapObject)
		m_pCapObject->Release();
	m_pControlChannel = NULL;
	m_pCapObject = NULL;

	return hrLast;
}

BOOL CConnection::ListenOn(PORT port)
{
	if(!m_pControlChannel)
	{
		hrLast = H323CC_E_NOT_INITIALIZED;
		goto EXIT;
	}
	
	hrLast = m_pControlChannel->ListenOn(port);
EXIT:
	return((HR_SUCCEEDED(hrLast))?TRUE:FALSE);
}


// 	start the asynchronous stuff that will instantiate a control channel
HRESULT CConnection::PlaceCall (BOOL bUseGKResolution, PSOCKADDR_IN pCallAddr,		
        P_H323ALIASLIST pDestinationAliases, P_H323ALIASLIST pExtraAliases,  	
	    LPCWSTR pCalledPartyNumber, P_APP_CALL_SETUP_DATA pAppData)
{
	if(m_ConnectionState != CLS_Idle)
		return CONN_E_NOT_IDLE;
		
	m_fCapsReady = FALSE;
	// reset summary code
	m_hSummaryCode = CCR_INVALID_REASON;

	hrLast = m_pH323CallControl->GetGKCallPermission();
	if(!HR_SUCCEEDED(hrLast))
	{
		m_hSummaryCode = hrLast;
		return hrLast;
	}
	
	hrLast = m_pControlChannel->PlaceCall (bUseGKResolution, pCallAddr,		
        pDestinationAliases, pExtraAliases,  	
	    pCalledPartyNumber, pAppData);
	    
	if(HR_SUCCEEDED(hrLast))
		m_ConnectionState = CLS_Connecting;
	return hrLast;
}


HRESULT CConnection::AcceptRejectConnection(CREQ_RESPONSETYPE Response)
{
	if(Response == CRR_ACCEPT)
	{
		m_ConnectionState = CLS_Connecting;
		m_fCapsReady = FALSE;
		// reset summary code
		m_hSummaryCode = CCR_INVALID_REASON;
	}
	return m_pControlChannel->AsyncAcceptRejectCall(Response);
}	


HRESULT CConnection::SetAdviseInterface(IH323ConfAdvise *pH323ConfAdvise)
{
	ASSERT(pH323ConfAdvise != NULL);	
	if(!pH323ConfAdvise)
	{
		return CONN_E_INVALID_PARAM;
	}
	m_pH323ConfAdvise = pH323ConfAdvise;
	//EXIT:	
	return hrSuccess;
}

HRESULT CConnection::ClearAdviseInterface()
{
	m_pH323ConfAdvise = NULL;
	return hrSuccess;
}	


// LOOKLOOK - the H323 control channel needs to get the combined cap object
// implementation of IConfAdvise::GetCapResolver()
HRESULT CConnection::GetCapResolver(LPVOID *lplpCapObject, GUID CapType)
{
	if(!lplpCapObject)
		return CONN_E_INVALID_PARAM;

	if(!m_pH323CallControl || !m_pCapObject)
		return CONN_E_NOT_INITIALIZED;	
	
	if(CapType == OID_CAP_ACM_TO_H323)
	{
	   *lplpCapObject = m_pCapObject;
	}
	else
	{
		return CONN_E_INVALID_PARAM;
	}
	return hrSuccess;
}


HRESULT CConnection::GetState(ConnectStateType *pState)
{
	HRESULT hResult = hrSuccess;
	if(!pState)
	{
		hResult = CONN_E_INVALID_PARAM;
		goto EXIT;
	}
	
	*pState = m_ConnectionState;
	EXIT:	
	return hResult;
}



// IConfAdvise::GetUserDisplayName()
LPWSTR CConnection::GetUserDisplayName()
{
	if(!m_pH323CallControl)
		return NULL;	
	return m_pH323CallControl->GetUserDisplayName();
}
PCC_ALIASITEM CConnection::GetUserDisplayAlias()
{
	if(!m_pH323CallControl)
		return NULL;	
	return m_pH323CallControl->GetUserDisplayAlias();
}
PCC_ALIASNAMES CConnection:: GetUserAliases() 
{
	if(!m_pH323CallControl)
		return NULL;
	return m_pH323CallControl->GetUserAliases();
}
HRESULT CConnection::GetLocalPort(PORT *lpPort)
{
	if(!m_pControlChannel)
		return CONN_E_NOT_INITIALIZED;
		
	return m_pControlChannel->GetLocalPort(lpPort);	
}	
HRESULT CConnection::GetRemoteUserName(LPWSTR lpwszName, UINT uSize)
{
	
	if(!lpwszName)
	{
		hrLast = MakeResult(CONN_E_INVALID_PARAM);
		goto EXIT;
	}	
	if(!m_pUserInfo)
	{
	// LOOKLOOK - need CONN_E_UNAVAILABLE or something
		hrLast = MakeResult(CONN_E_INVALID_PARAM);
		goto EXIT;
	}
		
	LStrCpyNW((LPWSTR)lpwszName,(LPWSTR)m_pUserInfo->lpvCallerIDData, uSize);	
	hrLast = hrSuccess;	
	EXIT:	
	return hrLast;
}
HRESULT CConnection::GetRemoteUserAddr(PSOCKADDR_IN psinUser)
{
	PSOCKADDR_IN psin = NULL;
	if(!m_pControlChannel)
		return CONN_E_NOT_INITIALIZED;
	
	if(psinUser)
	{	// get ptr to address, then copy it
		hrLast = m_pControlChannel->GetRemoteAddress(&psin);
		if(HR_SUCCEEDED(hrLast) && psin)
		{
			*psinUser = *psin;
		}
	}
	else
	{
		hrLast = H323CC_E_INVALID_PARAM;
	}
	//EXIT:	
	return hrLast;
}


HRESULT CConnection ::Disconnect()
{
	SummaryCode(CCR_LOCAL_DISCONNECT);
	Disconnect(CCR_LOCAL_DISCONNECT);
	return hrSuccess;
}

HRESULT CConnection::CloseAllChannels()
{
	ICtrlCommChan *pChan = NULL;
	HRESULT hr;	// temp return value so error code does not get overwritten
	FX_ENTRY ("CConnection::CloseAllChannels");

	// This doesn't actually cause channel close PDU's to be sent. It only 
	// shuts off all streams associated with all channels.  
	while (!m_ChannelList.IsEmpty())
	{
		pChan = (ICtrlCommChan *) m_ChannelList.RemoveHead();
		if(pChan)
		{
			hr = pChan->OnChannelClose(CHANNEL_CLOSED);
			if(!HR_SUCCEEDED(hr))
				hrLast = hr;
			hr = pChan->EndControlSession();
			if(!HR_SUCCEEDED(hr))	
				hrLast = hr;
			pChan->Release();
		}
	}
	return hrLast;
}

VOID CConnection::Disconnect(DWORD dwResponse)
{
	AddRef();	// prevent releasing while handling disconnect events
	if(!m_pControlChannel)
	{
		m_ConnectionState = CLS_Idle;
		goto EXIT;
	}

	if((m_ConnectionState == CLS_Disconnecting)
		|| (m_ConnectionState == CLS_Idle))
	{
		goto EXIT;
	}
	m_ConnectionState = CLS_Disconnecting;

	// CloseAllChannels() forces the action that would be taken when all 
	// channels are closed via call control.  Anal channel cleanup is not 
	// implemented on disconnect- CloseAllChannels() turns off all streaming,
	//  then we just end the session.  It takes too long to go through the
	// protocol overhead of closing & acking channel close, and it's legal in  
	// H.323 to end the session.  Ending the session implies channel closure  
	// for all channels. 
	// 

	CloseAllChannels();
	
	// this call can result in callbacks to the UI, which can result in
	// calls back in, which results in releasing the object.  If we're
	// about to go in, we need to be sure we can get back out, so AddRef()
	m_pControlChannel->AddRef();
	m_pControlChannel->Disconnect(dwResponse);
	m_pControlChannel->Release();
EXIT:
	Release();
}




STDMETHODIMP CConnection::QueryInterface( REFIID iid,	void ** ppvObject)
{

	HRESULT hr = E_NOINTERFACE;
	if(!ppvObject)
		return hr;
		
	*ppvObject = 0;
	if((iid == IID_IPhoneConnection) 
	|| (iid == IID_IUnknown)) // satisfy symmetric property of QI
	{
		*ppvObject = this;
		hr = hrSuccess;
		AddRef();
	}
	else if(iid == IID_IConfAdvise)
	{
	    *ppvObject = (IConfAdvise *)this;
   		hr = hrSuccess;
    	AddRef();
	}
	else if((iid == IID_IAppAudioCap ) && m_pCapObject)
	{
	ASSERT(0);
		hr = m_pCapObject->QueryInterface(iid, ppvObject);
	}
	else if((iid == IID_IAppVidCap ) && m_pCapObject)
	{
///	ASSERT(0);  CVideoProp still uses this
		hr = m_pCapObject->QueryInterface(iid, ppvObject);
	}
	else if((iid == IID_IDualPubCap) && m_pCapObject)
	{
	ASSERT(0);
		hr = m_pCapObject->QueryInterface(iid, ppvObject);
	}
	return (hr);
}

ULONG CConnection::AddRef()
{
	FX_ENTRY ("CConnection::AddRef");
	uRef++;
	DEBUGMSG(ZONE_REFCOUNT,("%s:(0x%08lX)->AddRef() uRef = 0x%08lX\r\n",_fx_, this, uRef ));
	return uRef;
}

ULONG CConnection::Release()
{
	FX_ENTRY ("CConnection::Release");
	uRef--;
	if(uRef == 0)
	{
		DEBUGMSG(ZONE_CONN,("%s:(0x%08lX)->Releasing in state:%d\r\n",_fx_, this, m_ConnectionState));
		
		// remove our interest in the control channel
		if(m_pControlChannel)
		{
			hrLast = m_pControlChannel->DeInit((IConfAdvise *) this);
			m_pControlChannel->Release();
		}
		
		// m_pControlChannel = NULL;
		delete this;
		return 0;
	}
	else
	{
		DEBUGMSG(ZONE_REFCOUNT,("%s:(0x%08lX)->Release() uRef = 0x%08lX\r\n",_fx_, this, uRef ));
		return uRef;
	}

}


STDMETHODIMP CConnection::GetSummaryCode(VOID)
{
	return m_hSummaryCode;
}
VOID CConnection::SummaryCode(HRESULT hCode)
{
	// assign code only if it has not yet been assigned
	if(m_hSummaryCode != CCR_INVALID_REASON)
		return;
	m_hSummaryCode = hCode;
}