preftran.cpp

linux下的一款播放器

	    outString = inString.NthField('.', nFields - 2);
	    outString += ".";
	    outString += inString.NthField('.', nFields - 1);
	    outString += ".";
	    outString += inString.NthField('.', nFields);
	}
	
	pOutString = new CHXString(outString);
    }

    return pOutString;
}

TransportMode
HXPreferredTransportManager::GetTransportPreferred(HXPreferredTransport* pPrefTransport)
{
    TransportMode   transportMode = UnknownMode;
 
    if (PTC_INTERNAL == pPrefTransport->m_prefTransportClass)
    {
	if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
	{
	    transportMode = GetHigherTransport(m_rtspTransportTypeStartWith,
					       m_internalTransportType);
	}
	else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
	{
	    transportMode = GetHigherTransport(m_pnmTransportTypeStartWith,
					       m_internalTransportType);
	}
	else
	{
	    HX_ASSERT(FALSE);
	}
    }
    else if (PTC_EXTERNAL == pPrefTransport->m_prefTransportClass)
    {
	if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
	{
	    transportMode = m_rtspTransportTypeStartWith; 
//			    GetHigherTransport(m_rtspTransportTypeStartWith,
//					       m_externalTransportType);
	}
	else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
	{
	    transportMode = m_pnmTransportTypeStartWith;
//			    GetHigherTransport(m_pnmTransportTypeStartWith,
//					       m_externalTransportType);
	}
	else
	{
	    HX_ASSERT(FALSE);
	}
    }
 
    return transportMode;
}

TransportMode
HXPreferredTransportManager::GetHigherTransport(TransportMode mode1, TransportMode mode2)
{
    if (mode1 < mode2)
    {
	return mode2;
    }
    else
    {
	return mode1;
    }    
}
    
TransportMode
HXPreferredTransportManager::GetLowerTransport(TransportMode mode1, TransportMode mode2)
{
    if (mode1 > mode2)
    {
	return mode2;
    }
    else
    {
	return mode1;
    }    
}

PreferredTransportClass
HXPreferredTransportManager::GetTransportClass(const char* pszHostName, UINT32 ulHostAddress)
{
    HX_RESULT			rc = HXR_OK;
    PreferredTransportClass	prefTransportClass = PTC_EXTERNAL;

    // Internal server is defined as:
    // a. a media server on the same network subnet as the client, or
    // b. a media server on a network subnet that meets the "Peer Subnet" criteria 
    //    (either as an explicit entry or by meeting wildcard criteria), or
    // c. a media server that meets the "Proxy Exclude" criteria 
    //    (either as an explicit entry or by meeting wildcard criteria)
    if ((m_ulSubnetMask && m_ulSubnet && ((ulHostAddress & m_ulSubnetMask) == m_ulSubnet))  ||
	m_pSubnetManager->IsSubnet(pszHostName)						    
#if defined(HELIX_FEATURE_PROXYMGR)
	|| m_pProxyManager->IsExemptionHost((char*)pszHostName)
#endif /* HELIX_FEATURE_PROXYMGR */
	)
    {
	prefTransportClass = PTC_INTERNAL;
    }

    return prefTransportClass;
}

void
HXPreferredTransportManager::InitTransportTypeStartWith(UINT32		ulTransportMask, 
							 TransportMode&	transportStartWith)
{
    transportStartWith = UnknownMode;

    if (ulTransportMask & ATTEMPT_MULTICAST)
    {
	transportStartWith = MulticastMode;
    }
    else if (ulTransportMask & ATTEMPT_UDP)
    {
	transportStartWith = UDPMode;
    }
    else if (ulTransportMask & ATTEMPT_TCP)
    {
	transportStartWith = TCPMode;
    }
    else if (ulTransportMask & ATTEMPT_HTTPCLOAK)
    {
	transportStartWith = HTTPCloakMode;
    }
    else
    {
	HX_ASSERT(FALSE);
    }

    return;
}

HX_RESULT
HXPreferredTransportManager::OpenPrefTransport(void)
{
    HX_RESULT	    hr = HXR_OK;
    char*	    pszHostName = NULL;
    char*	    pszClass = NULL;
    char*	    pszProtocol = NULL;
    char*	    pszTransport = NULL; 
    char*	    pszTransportMask = NULL;
    char*	    pszCloakPort = NULL;
    char*	    pszExpires = NULL;
    char*	    pszHTTPNG = NULL;
    char*	    pszPlaybacks = NULL;
    char*	    pszUnknownField = NULL;
    char	    buffer[LINE_BUFFER_SIZE] = {0}; /* Flawfinder: ignore */
    UINT32	    ulBytesRead = 0;
    UINT32	    ulIAddress = 0;
    FILE*	    fp = NULL;
    HXPreferredTransport* pTransport = NULL;
    PreferredTransportClass transportClass = PTC_UNKNOWN;
 
    if (!m_pszFile)
    {
	hr = HXR_FAILED;
	goto cleanup;
    }

#ifdef _WINDOWS
    if (!m_pLock)
    {
#ifdef THREADS_SUPPORTED        
	HXEvent::MakeEvent(m_pLock, RM_PREFTRAN_FILE_LOCK, FALSE);
#else        
	HXEvent::MakeStubEvent(m_pLock, RM_PREFTRAN_FILE_LOCK, FALSE);
#endif
    }
    else
    {
	m_pLock->Wait();
    }
#endif /* _WINDOWS */

    if (!(fp = fopen(m_pszFile, "r+b")))
    {
	hr = HXR_FAILED;
	goto cleanup;
    }

#if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
    m_fileID = fileno(fp);    
    flock(m_fileID, LOCK_EX);
#endif /* _UNIX */

     /* line format is:
     *
     * hostname \t class \t protocol \t transport \t cloakport \t time
     *
     * hostname	    - string(null by default)
     * class	    - transport class(PTC_Internal by default)
     * protocol	    - protocol type(RTSP vs PNM)
     * transport    - preferred transport(UDPMode by default)
     * cloakport    - cloak port
     * time	    - time of last used or modified
     */
    while (HXR_OK == FileReadLine(fp, &buffer[0], LINE_BUFFER_SIZE, &ulBytesRead))
    {
	if (*buffer == '#' || *buffer == CR || *buffer == LF || *buffer == 0)
	{
	    continue;
	}

	pszHostName = buffer;
	    
	if(!(pszClass = strchr(pszHostName, '\t')))
	{
	    continue;
	}
	*pszClass++ = '\0';
	if(*pszClass == CR || *pszClass == LF || *pszClass == 0)
	{
	    continue;
	}

	if (0 == strcasecmp(pszHostName, "localhost"))
	{
	    transportClass = (PreferredTransportClass)atoi(pszClass);

	    if(!(pszTransport = strchr(pszClass, '\t')))
	    {
		continue;
	    }
	    *pszTransport++ = '\0';
	    if(*pszTransport == CR || *pszTransport == LF || *pszTransport == 0)
	    {
		continue;
	    }

	    if(!(pszProtocol = strchr(pszTransport, '\t')))
	    {
		continue;
	    }
	    *pszProtocol++ = '\0';
	    if(*pszProtocol == CR || *pszProtocol == LF || *pszProtocol == 0)
	    {
		continue;
	    }

	    if(!(pszTransportMask = strchr(pszProtocol, '\t')))
	    {
		continue;
	    }
	    *pszTransportMask++ = '\0';
	    if(*pszTransportMask == CR || *pszTransportMask == LF || *pszTransportMask == 0)
	    {
		continue;
	    }

	    if(!(pszExpires = strchr(pszTransportMask, '\t')))
	    {
		continue;
	    }
	    *pszExpires++ = '\0';
	    if(*pszExpires == CR || *pszExpires == LF || *pszExpires == 0)
	    {
		continue;
	    }

	    if (!(pszUnknownField = strchr(pszExpires, '\t')))
	    {
		// remove the '\n' from the end of the entry
		pszExpires = ::StripLine(pszExpires);
	    }
	    else
	    {
		*pszUnknownField++ = '\0';
	    }

	    if (PTC_INTERNAL == transportClass)
	    {
		m_internalTransportType = (TransportMode)atoi(pszTransport);
#ifdef _MACINTOSH
		m_ulRTSPTransportMask = atoi64(pszTransportMask);
		m_lastRTSPPreferencesModifiedTime = (time_t)atoi64(pszExpires);
#else
		m_ulRTSPTransportMask = atol(pszTransportMask);
		m_lastRTSPPreferencesModifiedTime = atol(pszExpires);
#endif
	    }
	    else if (PTC_EXTERNAL == transportClass)
	    {
		m_externalTransportType = (TransportMode)atoi(pszTransport);
#ifdef _MACINTOSH
		m_ulPNMTransportMask = atoi64(pszTransportMask);
		m_lastPNMPreferencesModifiedTime = (time_t)atoi64(pszExpires);
#else
		m_ulPNMTransportMask = atol(pszTransportMask);
		m_lastPNMPreferencesModifiedTime = atol(pszExpires);
#endif
	    }
	    else
	    {
		HX_ASSERT(FALSE);
	    }
	}
	else
	{
	    if(!(pszProtocol = strchr(pszClass, '\t')))
	    {
		continue;
	    }
	    *pszProtocol++ = '\0';
	    if(*pszProtocol == CR || *pszProtocol == LF || *pszProtocol == 0)
	    {
		continue;
	    }

	    if(!(pszTransport = strchr(pszProtocol, '\t')))
	    {
		continue;
	    }
	    *pszTransport++ = '\0';
	    if(*pszTransport == CR || *pszTransport == LF || *pszTransport == 0)
	    {
		continue;
	    }

	    if(!(pszCloakPort = strchr(pszTransport, '\t')))
	    {
		continue;
	    }
	    *pszCloakPort++ = '\0';
	    if(*pszCloakPort == CR || *pszCloakPort == LF || *pszCloakPort == 0)
	    {
		continue;
	    }

	    if(!(pszExpires = strchr(pszCloakPort, '\t')))
	    {
		continue;
	    }
	    *pszExpires++ = '\0';
	    if(*pszExpires == CR || *pszExpires == LF || *pszExpires == 0)
	    {
		continue;
	    }

	    if(!(pszHTTPNG = strchr(pszExpires, '\t')))
	    {
		continue;
	    }
	    *pszHTTPNG++ = '\0';
	    if(*pszHTTPNG == CR || *pszHTTPNG == LF || *pszHTTPNG == 0)
	    {
		continue;
	    }

	    if (!(pszPlaybacks = strchr(pszHTTPNG, '\t')))
	    {
		continue;
	    }
	    *pszPlaybacks++ = '\0';
	    if(*pszPlaybacks == CR || *pszPlaybacks == LF || *pszPlaybacks == 0)
	    {
		continue;
	    }
	    
	    if (!(pszUnknownField = strchr(pszPlaybacks, '\t')))
	    {
		// remove the '\n' from the end of the entry
		pszPlaybacks = ::StripLine(pszPlaybacks);
	    }
	    else
	    {
		*pszUnknownField++ = '\0';
	    }

	    // construct a new preferred transport struct
	    pTransport = new HXPreferredTransport(this);
	    pTransport->AddRef();

	    pTransport->m_pHost = new CHXString(pszHostName);
	    pTransport->m_prefTransportClass = (PreferredTransportClass)atoi(pszClass);
	    pTransport->m_prefTransportProtocol = (PreferredTransportProtocol)atoi(pszProtocol);
	    pTransport->m_prefTransportType = (TransportMode)atoi(pszTransport);
	    pTransport->m_uCloakPort = atoi(pszCloakPort);
#ifdef _MACINTOSH
	    pTransport->m_lastUsedTime = (time_t)atoi64(pszExpires);
#else
	    pTransport->m_lastUsedTime = atol(pszExpires);
#endif
	    pTransport->m_bHTTPNG = atoi(pszHTTPNG);
	    pTransport->m_uPlaybacks = atoi(pszPlaybacks);
	    pTransport->m_state = PTS_READY;

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

	    m_pPrefHostTransportList->AddTail(pTransport);
	}
    }

cleanup:

#if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
    flock(m_fileID, LOCK_UN);
#endif /* _UNIX */

    if (fp)
    {
	fclose(fp);
    }

#ifdef _WINDOWS
    if (m_pLock)
    {
	m_pLock->SignalEvent();
    }
#endif /* _WINDOWS */

    return hr;
}

HX_RESULT	
HXPreferredTransportManager::SavePrefTransport(void)
{
    HX_RESULT		    hr = HXR_OK;
    FILE*		    fp = NULL;
    UINT32		    ulTransportMask = 0;
    HXPreferredTransport*  pTransport = NULL;
    CHXSimpleList::Iterator  i;

    if (!m_pszFile)
    {
	goto cleanup;
    }

#ifdef _WINDOWS
    if (!m_pLock)
    {
#ifdef THREADS_SUPPORTED        
	HXEvent::MakeEvent(m_pLock, RM_PREFTRAN_FILE_LOCK, FALSE);
#else
	HXEvent::MakeStubEvent(m_pLock, RM_PREFTRAN_FILE_LOCK, FALSE);
#endif        
    }
    else
    {
	m_pLock->Wait();
    }
#endif /* _WINDOWS */

    if (!(fp = fopen(m_pszFile, "w")))
    {
	hr = HXR_FAILED;
	goto cleanup;
    }

#ifdef _UNIX
    //Make the permisions on the cookies file User read/write only.
    if( chmod( m_pszFile, S_IRUSR | S_IWUSR ) != 0 )
    {
        HX_ASSERT( "Can't change permision on cookies file." == NULL );
    }
    
#endif    

#if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
    m_fileID = fileno(fp);    
    flock(m_fileID, LOCK_EX);
#endif /* _UNIX */

    fwrite(RM_PREFTRAN_CAPTION, sizeof(char), strlen(RM_PREFTRAN_CAPTION), fp);

    // save preferred class information first
    FileWriteClass(fp, PTC_INTERNAL, m_internalTransportType, PTP_RTSP, m_ulRTSPTransportMask, m_lastRTSPPreferencesModifiedTime);
    FileWriteClass(fp, PTC_EXTERNAL, m_externalTransportType, PTP_PNM, m_ulPNMTransportMask, m_lastPNMPreferencesModifiedTime);

    // save preferred host information
    if (m_pPrefHostTransportList)
    {
	for (i = m_pPrefHostTransportList->Begin(); i != m_pPrefHostTransportList->End(); ++i)
	{
	    pTransport = (HXPreferredTransport*)(*i);
	    if (pTransport->m_pHost && PTS_READY == pTransport->m_state)
	    {
		FileWriteLine(fp, pTransport);
	    }
	}
    }

    m_bSave = FALSE;
    
cleanup:

#if defined (_UNIX) && !defined(_SUN) && !defined(_SCO_UW) && !defined(_HPUX) && !defined(_IRIX) && !defined(_AIX) && !defined(_OSF1)
    flock(m_fileID, LOCK_UN);
#endif /* _UNIX */

    if (fp)
    {
	fclose(fp);
    }

#ifdef _WINDOWS
    if (m_pLock)
    {
	m_pLock->SignalEvent();
    }
#endif /* _WINDOWS */

    return(hr);
}