preftran.cpp

linux下的一款播放器

			    , m_externalTransportType(MulticastMode)
			    , m_rtspTransportTypeStartWith(MulticastMode)
			    , m_pnmTransportTypeStartWith(MulticastMode)
			    , m_pPrefHostTransportList(NULL)
			    , m_pPrevPrefHostTransportList(NULL)
			    , m_pSubnetManager(NULL)
			    , m_pPreferences(NULL)
			    , m_pProxyManager(NULL)
			    , m_pHXNetInterface(NULL)
			    , m_bInitialized(FALSE)
#ifdef _WINDOWS
			    , m_pLock(NULL)
#elif _UNIX
			    , m_fileID(0)
#endif /* _WINDOWS */
{    
    if (pContext)
    {
	m_pContext = pContext;
	m_pContext->AddRef();
    }
}

HXPreferredTransportManager::~HXPreferredTransportManager()
{
    Close();
}

STDMETHODIMP
HXPreferredTransportManager::QueryInterface(REFIID riid, void**ppvObj)
{
    QInterfaceList qiList[] =
        {
            { GET_IIDHANDLE(IID_IHXPreferredTransportManager), (IHXPreferredTransportManager*)this },
            { GET_IIDHANDLE(IID_IUnknown), (IUnknown*)(IHXPreferredTransportManager*)this },
        };
    
    return ::QIFind(qiList, QILISTSIZE(qiList), riid, ppvObj);
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//	IUnknown::AddRef
//  Purpose:
//	Everyone usually implements this the same... feel free to use
//	this implementation.
//
STDMETHODIMP_(ULONG32) 
HXPreferredTransportManager::AddRef()
{
    return InterlockedIncrement(&m_lRefCount);
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//	IUnknown::Release
//  Purpose:
//	Everyone usually implements this the same... feel free to use
//	this implementation.
//
STDMETHODIMP_(ULONG32) 
HXPreferredTransportManager::Release()
{
    if (InterlockedDecrement(&m_lRefCount) > 0)
    {
        return m_lRefCount;
    }

    delete this;
    return 0;
}

HX_RESULT    
HXPreferredTransportManager::_Initialize(void)
{
    HX_RESULT	hr = HXR_OK;
    HXNetInterface* pHXNI = NULL;
    
    if (!m_pContext)
    {
	hr = HXR_FAILED;
	goto cleanup;
    }

    if (!m_pSubnetManager)
    {
	m_pSubnetManager = new HXSubnetManager((IUnknown*)m_pContext);
    }

#if defined(HELIX_FEATURE_PROXYMGR)
    if (!m_pProxyManager)
    {
	m_pContext->QueryInterface(IID_IHXProxyManager, (void**)&m_pProxyManager);
	HX_ASSERT(m_pProxyManager);
    }
#endif /* #if defined(HELIX_FEATURE_PROXYMGR) */

    CollectNetworkInfo();

    PrepPrefTransport();

    OpenPrefTransport();

    m_bInitialized = TRUE;

cleanup:

    return hr;
}

HX_RESULT
HXPreferredTransportManager::ReadPreferences(BOOL  bRTSPProtocol, UINT32& ulTransportMask)
{
    BOOL	bAutoTransport = TRUE;
    BOOL	bMulticast = FALSE;
    BOOL	bUDP = FALSE;
    BOOL	bTCP = FALSE;
    BOOL	bHTTPCloak = FALSE; 

    ulTransportMask = 0;

    ReadPrefBOOL(m_pPreferences, "AutoTransport", bAutoTransport);

    if (bAutoTransport)
    {
	ulTransportMask = ATTEMPT_AUTOTRANSPORT;
    }
    else
    {
        ReadPrefBOOL(m_pPreferences, bRTSPProtocol?"AttemptRTSPvMulticast":"AttemptPNAvMulticast", bMulticast);
        ReadPrefBOOL(m_pPreferences, bRTSPProtocol?"AttemptRTSPvUDP":"AttemptPNAvUDP", bUDP);
        ReadPrefBOOL(m_pPreferences, bRTSPProtocol?"AttemptRTSPvTCP":"AttemptPNAvTCP", bTCP);
        ReadPrefBOOL(m_pPreferences, bRTSPProtocol?"AttemptRTSPvHTTP":"AttemptPNAvHTTP", bHTTPCloak);

	if (bMulticast)
	{
	    ulTransportMask |= ATTEMPT_MULTICAST;
	}

	if (bUDP)
	{
	    ulTransportMask |= ATTEMPT_UDP;
	}

	if (bTCP)
	{
	    ulTransportMask |= ATTEMPT_TCP;
	}

	if (bHTTPCloak)
	{
	    ulTransportMask |= ATTEMPT_HTTPCLOAK;
	}
    }

    return HXR_OK;
}

void	
HXPreferredTransportManager::Close(void)
{
    if (m_bSave)
    {
	SavePrefTransport();
    }

    ResetPrefTransport(m_pPrevPrefHostTransportList);
    HX_DELETE(m_pPrevPrefHostTransportList);

    ResetPrefTransport(m_pPrefHostTransportList);
    HX_DELETE(m_pPrefHostTransportList);

    HX_DELETE(m_pSubnetManager);

    if (m_pHXNetInterface)
    {
	m_pHXNetInterface->RemoveAdviseSink((IHXNetInterfacesAdviseSink*)this);
	HX_RELEASE(m_pHXNetInterface);
    }

#if defined(HELIX_FEATURE_PROXYMGR)
    HX_RELEASE(m_pProxyManager);
#endif /* HELIX_FEATURE_PROXYMGR */

    HX_RELEASE(m_pPreferences);
    HX_RELEASE(m_pContext);

    HX_VECTOR_DELETE(m_pszFile);

    m_bInitialized = FALSE;

#ifdef _WINDOWS
    HX_DELETE(m_pLock);
#endif /* _WINDOWS */
}

void
HXPreferredTransportManager::TransportSet(HXPreferredTransport* pPreferredTransport,
					   BOOL bSave)
{
    if (PTC_INTERNAL == pPreferredTransport->m_prefTransportClass)
    {
	m_internalTransportType = pPreferredTransport->m_prefTransportType;
    }
    else if (PTC_EXTERNAL == pPreferredTransport->m_prefTransportClass)
    {
	m_externalTransportType = pPreferredTransport->m_prefTransportType;
    }
    else
    {
	HX_ASSERT(FALSE);
    }

    if (bSave)
    {
	m_bSave = TRUE;
    }
}
					      
/************************************************************************
 *	Method:
 *	    IHXPreferredTransportManager::Initialize
 *	Purpose:
 *	    Initialize the transport manager such as re-reading the preferences
 */
STDMETHODIMP
HXPreferredTransportManager::Initialize()
{
    HX_RESULT	rc = HXR_OK;
    BOOL	bPreferenceModified = FALSE;
    UINT32	ulRTSPTransportMask = ATTEMPT_AUTOTRANSPORT;
    UINT32	ulPNMTransportMask = ATTEMPT_AUTOTRANSPORT;

    if (!m_bInitialized)
    {
	rc = _Initialize();
    }

    HX_ASSERT(HXR_OK == rc);

    ResetPrefTransport(m_pPrevPrefHostTransportList);

    ReadPreferences(TRUE, ulRTSPTransportMask);
    ReadPreferences(FALSE, ulPNMTransportMask);

    if (ulRTSPTransportMask != m_ulRTSPTransportMask)
    {
	bPreferenceModified = TRUE;
	m_ulRTSPTransportMask = ulRTSPTransportMask;
	m_lastRTSPPreferencesModifiedTime = time(NULL);
    }

    if (ulPNMTransportMask != m_ulPNMTransportMask)
    {
	bPreferenceModified = TRUE;
	m_ulPNMTransportMask = ulPNMTransportMask;
	m_lastPNMPreferencesModifiedTime = time(NULL);
    }

    InitTransportTypeStartWith(m_ulRTSPTransportMask, m_rtspTransportTypeStartWith);
    InitTransportTypeStartWith(m_ulPNMTransportMask, m_pnmTransportTypeStartWith);

    // re-initialize internal/external transport type to its lowest start transport
    // type when we detect the transport preference has been changed
    if (bPreferenceModified)
    {
	m_externalTransportType = m_internalTransportType = GetLowerTransport(m_rtspTransportTypeStartWith,
									      m_pnmTransportTypeStartWith);
    }

    m_pSubnetManager->Initialize();

#if defined(HELIX_FEATURE_PROXYMGR)
    m_pProxyManager->Initialize(m_pContext);
#endif /* HELIX_FEATURE_PROXYMGR */

    m_ulPlaybacks++;

    return rc;
}

/************************************************************************
 *	Method:
 *	    IHXPreferredTransportManager::GetPrefTransport
 *	Purpose:
 *	    Get preferred host transport
 */
STDMETHODIMP
HXPreferredTransportManager::GetPrefTransport(const char*		    /* IN  */ pszHostName,
					      PreferredTransportProtocol    /* IN  */ prefTransportProtocol,
					      REF(IHXPreferredTransport*)   /* OUT */ pPrefTransport)
{
    HX_RESULT		    rc = HXR_OK;
    BOOL		    bFound = FALSE;
    UINT32		    ulIAddress = 0;
    UINT32		    ulHostAddress = 0;
    HXPreferredTransport*   pTransport = NULL;
    PreferredTransportClass prefTransportClass = PTC_EXTERNAL;
    CHXString*		    pDomainHost = NULL;
    CHXSimpleList::Iterator i;

    pPrefTransport = NULL;

    if (!m_bInitialized)
    {
	rc = _Initialize();
	if (HXR_OK != rc)
	{
	    goto cleanup;
	}
    }

    if (pszHostName)
    {
        if(IsNumericAddr(pszHostName, strlen(pszHostName)))
        {
	    ulIAddress = HXinet_addr(pszHostName);
	    ulHostAddress = DwToHost(ulIAddress);
	    pDomainHost = new CHXString(pszHostName);
        }
        else
        {
	    pDomainHost = GetMasterDomain(pszHostName);
        }

        prefTransportClass = GetTransportClass(pszHostName, ulHostAddress);

        if (m_pPrefHostTransportList)
        {
	    i = m_pPrefHostTransportList->Begin();
	    for (; i != m_pPrefHostTransportList->End(); ++i)
	    {
	        pTransport = (HXPreferredTransport*)*i;

	        // based on host name for now
	        if (pTransport->m_pHost &&
                    !pTransport->m_pHost->CompareNoCase((const char*)*pDomainHost)   &&
		    pTransport->m_prefTransportProtocol == prefTransportProtocol    &&
		    pTransport->m_prefTransportClass == prefTransportClass)
	        {
		    bFound = TRUE;
		    break;
	        }
	    }
        }
    }

    if (bFound)
    {
	// previous transport attempt is failed
	if (pTransport->m_state == PTS_UNKNOWN)
	{
	    pTransport->m_state = PTS_CREATE;
	}
	 
	pTransport->Initialize();
        pPrefTransport = pTransport;
	pPrefTransport->AddRef();
    }
    else
    {
	pTransport = new HXPreferredTransport(this);
	pTransport->AddRef();

	pTransport->m_pHost = pDomainHost;
	pTransport->m_ulHost = ulHostAddress;
	pTransport->m_prefTransportClass = prefTransportClass;
	pTransport->m_prefTransportProtocol = prefTransportProtocol; 	
	pTransport->m_state = PTS_CREATE;

	pTransport->Initialize();

        if (!m_pPrefHostTransportList)
        {
	    m_pPrefHostTransportList = new CHXSimpleList();
        }

	m_pPrefHostTransportList->AddTail(pTransport);
	rc = pTransport->QueryInterface(IID_IHXPreferredTransport, (void**)&pPrefTransport);
    }

    if (pTransport->m_state != PTS_READY)
    {
	m_bSave = TRUE;
    }

cleanup:

    return rc;
}

/************************************************************************
 *	Method:
 *	    IHXPreferredTransportManager::RemovePrefTransport
 *	Purpose:
 *	    Remove preferred host transport
 */
STDMETHODIMP
HXPreferredTransportManager::RemovePrefTransport(IHXPreferredTransport*   /* IN */ pPrefTransport)
{
    HX_RESULT		    rc = HXR_OK;
    HXPreferredTransport*  pTransport = NULL;
    LISTPOSITION	    lPos = NULL;

    if (!m_pPrefHostTransportList)
    {
	goto cleanup;
    }

    lPos = m_pPrefHostTransportList->GetHeadPosition();
    while (lPos && m_pPrefHostTransportList->GetCount())
    {	    
	pTransport = (HXPreferredTransport*)m_pPrefHostTransportList->GetAt(lPos);
	
	if (pTransport == pPrefTransport)
	{
	    HX_RELEASE(pTransport);
	    lPos = m_pPrefHostTransportList->RemoveAt(lPos);
	}
	else
	{
	    m_pPrefHostTransportList->GetNext(lPos);
	}
    }

cleanup:

    return rc;
}

/************************************************************************
 *	Method:
 *	    IHXPreferredTransportManager::GetTransportPreference
 *	Purpose:
 *	    Get transport preference set by the user
 */
STDMETHODIMP
HXPreferredTransportManager::GetTransportPreference(PreferredTransportProtocol	/* IN  */ prefTransportProtocol,
						     REF(UINT32)		/* OUT */ ulPreferenceMask)
{
    HX_RESULT	rc = HXR_OK;

    if (PTP_RTSP == prefTransportProtocol)
    {
	ulPreferenceMask = m_ulRTSPTransportMask;
    }
    else if (PTP_PNM == prefTransportProtocol)
    {
	ulPreferenceMask = m_ulPNMTransportMask;
    }
    else
    {
	rc = HXR_FAILED;
    }

    return rc;
}

/*
 *	IHXNetInterfacesAdviseSink methods
 */
STDMETHODIMP
HXPreferredTransportManager::NetInterfacesUpdated()
{

    HX_RESULT	rc = HXR_OK;

    if (m_bSave)
    {
	SavePrefTransport();
    }

    ResetPrefTransport(m_pPrevPrefHostTransportList);
    m_pPrevPrefHostTransportList = m_pPrefHostTransportList;
    m_pPrefHostTransportList = NULL;

    HX_VECTOR_DELETE(m_pszFile);

    m_bInitialized = FALSE;

    return rc;
}

HX_RESULT	    
HXPreferredTransportManager::CollectNetworkInfo(void)
{
    HX_RESULT	rc = HXR_FAILED;
    UINT16	i = 0;
    UINT32	uNI = 0;
    NIInfo*	pTempNIInfo = NULL;
    NIInfo*	pNIInfo = NULL;

    if (!m_pHXNetInterface)
    {
	if (HXR_OK != m_pContext->QueryInterface(IID_IHXNetInterfaces, (void**)&m_pHXNetInterface))
	{
	    goto cleanup;
	}
	m_pHXNetInterface->AddAdviseSink((IHXNetInterfacesAdviseSink*)this);
    }

    if (m_pHXNetInterface)
    {
	uNI = m_pHXNetInterface->GetNumOfNetInterfaces();

	for (i = 0; i < uNI; i++)
	{
	    if (HXR_OK == m_pHXNetInterface->GetNetInterfaces(i, pTempNIInfo))
	    {
		if (pTempNIInfo && pTempNIInfo->bActive)
		{		    
		    pNIInfo = pTempNIInfo;

		    if (POINTTOPOINT == pNIInfo->type)
		    {
			break;