preftran.cpp

linux下的一款播放器

		    }
		}
	    }
	}

	if (pNIInfo)
	{
	    m_ulLocalHost  = DwToHost(pNIInfo->ulNetAddress);
	    m_ulSubnetMask = DwToHost(pNIInfo->ulNetMask);
	    rc = HXR_OK;
	}
    }

#ifndef _WINCE
    HX_ASSERT(m_ulLocalHost);
    HX_ASSERT(m_ulSubnetMask);
#endif
    m_ulSubnet = m_ulLocalHost & m_ulSubnetMask;

cleanup:

    return rc;
}

HX_RESULT	    
HXPreferredTransportManager::PrepPrefTransport(void)
{
    HX_RESULT   hr = HXR_OK;
#ifndef _VXWORKS
    char        buffer[MAX_DISPLAY_NAME] = {0}; /* Flawfinder: ignore */
    const char* pszValue = NULL;
    IHXBuffer*  pBuffer = NULL;
    IHXBuffer*  pPrefBuffer = NULL;
    CHXString   strUserDataPath;

    if (!m_pPreferences &&  
        HXR_OK != m_pContext->QueryInterface(IID_IHXPreferences, (void**)&m_pPreferences))
    {
        hr = HXR_FAILED;
        goto cleanup;
    }

    if (HXR_OK == m_pPreferences->ReadPref("UserSDKDataPath", pBuffer) && pBuffer)
    {
        pszValue = (char*) pBuffer->GetBuffer();
    }

    if (!pszValue)
    {
        // construct base path
#ifdef _UNIX
        strUserDataPath = (const char*) getenv("HOME");
        strUserDataPath += OS_SEPARATOR_CHAR;
        strUserDataPath += ".helix";
        strUserDataPath += OS_SEPARATOR_CHAR;
        pszValue = (const char*) strUserDataPath;
#else
        pszValue = GetDLLAccessPath()->GetPath(DLLTYPE_COMMON);
#endif        
    }

    // determine whether preferred transport setting of this network configuration
    // has been saved
#ifdef _MAC_MACHO
	sprintf(buffer, "networkconfig_%lX.txt", m_ulSubnet);
#else
    i64toa(m_ulSubnet, buffer, 16);
    strcat(buffer, ".txt"); /* Flawfinder: ignore */
#endif
		   
    m_pszFile = new char[strlen(pszValue) + strlen(buffer) + 10];
    ::strcpy(m_pszFile, pszValue); /* Flawfinder: ignore */
    if (m_pszFile[::strlen(m_pszFile)-1] != OS_SEPARATOR_CHAR)
    {
        strcat(m_pszFile, OS_SEPARATOR_STRING); /* Flawfinder: ignore */
    }

    strcat(m_pszFile, buffer); /* Flawfinder: ignore */

#if !defined (__TCS__)
    // we maintain max # of preferred transport config files with
    // the least used file deleted
    m_pPreferences->ReadPref("PreferredTransportFiles", pPrefBuffer);

    ::AddFileToFileListWithCap(buffer, 0, pszValue, pPrefBuffer);
    m_pPreferences->WritePref("PreferredTransportFiles", pPrefBuffer);
#endif /* __TCS__ */

    HX_RELEASE(pPrefBuffer);
    HX_RELEASE(pBuffer);

#endif /* _VXWORKS */

  cleanup:

    return hr;
}

void
HXPreferredTransportManager::ResetPrefTransport(CHXSimpleList* pPrefHostTransportList)
{
    HXPreferredTransport*   pTransport = NULL;

    while (pPrefHostTransportList && pPrefHostTransportList->GetCount() > 0)
    {
	pTransport = (HXPreferredTransport*)pPrefHostTransportList->RemoveHead();
	pTransport->Close();
	HX_RELEASE(pTransport);
    }
}

HX_RESULT	
HXPreferredTransportManager::FileReadLine(FILE* fp, char* pLine, UINT32 ulLineBuf, UINT32* pBytesRead)
{
    HX_RESULT	hr = HXR_OK;
    UINT32	i = 0;
    UINT32	ulBytesRead = 0;
    char*	pTmpBuf = NULL;

    if (!fp)
    {
	hr = HXR_FAILED;
	goto cleanup;
    }

    if (ulLineBuf < 1) 
    {
        *pBytesRead = 0;
        goto cleanup;
    }

    ulBytesRead = fread(pLine, sizeof(char), ulLineBuf, fp);
    pTmpBuf = pLine;

    if (ulBytesRead)
    {
	while (i < ulBytesRead) 
	{
#ifdef _MACINTOSH
	    if (pTmpBuf[i] == 10 || pTmpBuf[i] == 13)
#else
	    if (pTmpBuf[i] == 10)
#endif
	    {   // LF
		if (pTmpBuf[i+1])
		{
		    pTmpBuf[i+1] = '\0';
		}

		// Back the file pointer up.
		fseek(fp, (long)((i + 1) - ulBytesRead), SEEK_CUR);
		*pBytesRead = i + 1;
		break;
	    }
	    i++;
	}
    }
    else
    {
	hr = HXR_FAILED;
    }
    
cleanup:

    return hr;
}

HX_RESULT
HXPreferredTransportManager::FileWriteLine(FILE* fp, HXPreferredTransport* pPrefTransport)
{
    HX_RESULT	rc = HXR_OK;
    UINT32	ulNetAddress = 0;
    char        buffer[36] = {0}; /* Flawfinder: ignore */
    char*	value = NULL;

    /* line format is:
     *
     * hostname \t class \t protocol \t transport \t cloakport \t lastRTSPmodifiedtime(internalclass) or
     *								  lastPNMModifiedtime(externalclass)
     *
     * 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	    - last used time
     * sameserverIP - cloak GET/POST w/ same serverIP
     * playbacks    - # of playbacks
     */
    if (pPrefTransport->m_pHost)
    {	    
	fwrite((const char*)*(pPrefTransport->m_pHost), sizeof(char), pPrefTransport->m_pHost->GetLength(), fp);
    }
    else
    {
        HX_ASSERT(FALSE);
    }
    fwrite("\t", sizeof(char), 1, fp);

    itoa(pPrefTransport->m_prefTransportClass, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);	
    fwrite("\t", sizeof(char), 1, fp);

    itoa(pPrefTransport->m_prefTransportProtocol, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);	
    fwrite("\t", sizeof(char), 1, fp);

    itoa(pPrefTransport->m_prefTransportType, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);
    fwrite("\t", sizeof(char), 1, fp);

    itoa(pPrefTransport->m_uCloakPort, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);
    fwrite("\t", sizeof(char), 1, fp);

    snprintf(buffer, 36, "%lu", pPrefTransport->m_lastUsedTime); /* Flawfinder: ignore */
    fwrite(buffer, sizeof(char), strlen(buffer), fp);
    fwrite("\t", sizeof(char), 1, fp);

    itoa(pPrefTransport->m_bHTTPNG, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);
    fwrite("\t", sizeof(char), 1, fp);

    itoa(pPrefTransport->m_uPlaybacks, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);

    fwrite(LINEBREAK, sizeof(char), LINEBREAK_LEN, fp);

    return rc;
}

HX_RESULT
HXPreferredTransportManager::FileWriteClass(FILE* fp, 
					     PreferredTransportClass prefTransportClass, 
					     TransportMode transportType,
					     PreferredTransportProtocol	protocol,
					     UINT32 ulTransportMask,
					     time_t lastModifiedTime)
{
    HX_RESULT	rc = HXR_OK;
    char        buffer[36] = {0}; /* Flawfinder: ignore */

    /* line format is:
     *
     * hostname \t class \t protocol \t transport \t cloakport \t lastusedtime
     *
     * hostname	    - string(null by default)
     * class	    - transport class(PTC_Internal by default)
     * transport    - preferred transport of this class
     * protocol	    - protocol type(RTSP vs PNM)
     * transportmask- mask for the transport preference
     * time	    - last RTSP/PNM preferences' modified time
     */
    fwrite("localhost", sizeof(char), 9, fp);
    fwrite("\t", sizeof(char), 1, fp);

    itoa(prefTransportClass, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);	
    fwrite("\t", sizeof(char), 1, fp);

    itoa(transportType, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);
    fwrite("\t", sizeof(char), 1, fp);

    itoa(protocol, buffer, 10);
    fwrite(buffer, sizeof(char), strlen(buffer), fp);
    fwrite("\t", sizeof(char), 1, fp);

    snprintf(buffer,36, "%lu", ulTransportMask); /* Flawfinder: ignore */
    fwrite(buffer, sizeof(char), strlen(buffer), fp);
    fwrite("\t", sizeof(char), 1, fp);

    snprintf(buffer,36, "%lu", lastModifiedTime); /* Flawfinder: ignore */
    fwrite(buffer, sizeof(char), strlen(buffer), fp);

    fwrite(LINEBREAK, sizeof(char), LINEBREAK_LEN, fp);

    return rc;
}

HX_RESULT
HXPreferredTransportManager::DownShiftTransport(HX_RESULT error, 
						 HXPreferredTransport* pPrefTransport,
						 REF(TransportMode) prefTransportType)
{
    HX_RESULT	rc = HXR_OK;
    UINT32	ulTransportMask = ATTEMPT_AUTOTRANSPORT;

    HX_ASSERT(UnknownMode != prefTransportType);

    // HTTPCloak is the last on the transport switching list
    if (HTTPCloakMode == prefTransportType)
    {
	prefTransportType = UnknownMode;
	goto cleanup;
    }

    if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
    {
	ulTransportMask = m_ulRTSPTransportMask;
    }
    else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
    {
	ulTransportMask = m_ulPNMTransportMask;
    }
    else
    {
	HX_ASSERT(FALSE);
    }

    // switch to HTTP Cloaking directly if the following list of network
    // errors have been occured
    if (error == HXR_NET_CONNECT	    ||
	error == HXR_DNR		    ||
	error == HXR_SERVER_DISCONNECTED    ||
	error == HXR_DOC_MISSING	    ||
	error == HXR_BAD_SERVER		    ||
	error == HXR_PROXY_NET_CONNECT)
    {
	if (ulTransportMask & ATTEMPT_HTTPCLOAK)
	{
	    prefTransportType = HTTPCloakMode;
	}
	else
	{
	    prefTransportType = UnknownMode;
	}
    }
    else
    {
	if (prefTransportType == MulticastMode ||
	    prefTransportType == UDPMode)
	{
	    if (ulTransportMask & ATTEMPT_TCP)
	    {
		prefTransportType = TCPMode;
		goto cleanup;
	    }
    	    else if (ulTransportMask & ATTEMPT_HTTPCLOAK)
	    {
		prefTransportType = HTTPCloakMode;
		goto cleanup;
	    }
	    else
	    {
		prefTransportType = UnknownMode;
		goto cleanup;
	    }
	}
	else if (prefTransportType == TCPMode)
	{	 
	    if (ulTransportMask & ATTEMPT_HTTPCLOAK)
	    {
		prefTransportType = HTTPCloakMode;
		goto cleanup;
	    }
	    else
	    {
		prefTransportType = UnknownMode;
		goto cleanup;
	    }
	}
    }

cleanup:

    return rc;
}

HX_RESULT
HXPreferredTransportManager::UpShiftTransport(HXPreferredTransport* pPrefTransport,
					       REF(TransportMode) prefTransportType)
{
    HX_RESULT	rc = HXR_OK;
    UINT32	ulTransportMask = ATTEMPT_AUTOTRANSPORT;

    HX_ASSERT(UnknownMode != prefTransportType);

    // MulticastMode/UDPMode is the toppest on the transport switching list
    if (MulticastMode == prefTransportType ||
	UDPMode == prefTransportType)
    {
	goto cleanup;
    }

    if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
    {
	ulTransportMask = m_ulRTSPTransportMask;
    }
    else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
    {
	ulTransportMask = m_ulPNMTransportMask;
    }
    else
    {
	HX_ASSERT(FALSE);
    }

    if (prefTransportType == HTTPCloakMode)
    {
        if (ulTransportMask & ATTEMPT_TCP)
        {
	    prefTransportType = TCPMode;
	    goto cleanup;
	}
	// this is intentional...since we always try UDP
	// when we try Multicast.
	else if (ulTransportMask & ATTEMPT_MULTICAST)
	{
	    prefTransportType = MulticastMode;
	}
	else if (ulTransportMask & ATTEMPT_UDP)
	{
	    prefTransportType = UDPMode;
	}
    }
    else if (prefTransportType == TCPMode)
    {
	// this is intentional...since we always try UDP
	// when we try Multicast.
	if (ulTransportMask & ATTEMPT_MULTICAST)
	{
	    prefTransportType = MulticastMode;
	}
	else if (ulTransportMask & ATTEMPT_UDP)
	{
	    prefTransportType = UDPMode;
	}
    }

cleanup:

    return rc;
}

BOOL
HXPreferredTransportManager::ValidateTransport(HXPreferredTransport* pPrefTransport,
						TransportMode prefTransportType)
{
    BOOL    bResult = TRUE;
    UINT32  ulTransportMask = ATTEMPT_AUTOTRANSPORT;

    if (PTP_RTSP == pPrefTransport->m_prefTransportProtocol)
    {
	ulTransportMask = m_ulRTSPTransportMask;
    }
    else if (PTP_PNM == pPrefTransport->m_prefTransportProtocol)
    {
	ulTransportMask = m_ulPNMTransportMask;
    }
    else
    {
	HX_ASSERT(FALSE);
    }

    switch (prefTransportType)
    {
    case MulticastMode:
	bResult = (ulTransportMask & ATTEMPT_MULTICAST);
	break;
    case UDPMode:
	bResult = (ulTransportMask & ATTEMPT_UDP);
	break;
    case TCPMode:
	bResult = (ulTransportMask & ATTEMPT_TCP);
	break;
    case HTTPCloakMode:
	bResult = (ulTransportMask & ATTEMPT_HTTPCLOAK);
	break;
    default:
	bResult = FALSE;
	break;
    }

    return bResult;
}

CHXString*
HXPreferredTransportManager::GetMasterDomain(const char* pszHostName)
{
    int		nFields = 0;
    CHXString*	pOutString = NULL;
    CHXString	inString;
    CHXString	outString;
    CHXString	domainExt;

    inString = pszHostName;
    
    nFields = inString.CountFields('.');

    // a valid master domain contains either one or two fields
    // such as "dingdong", "realguide.com" and "rbn.com"
    if (nFields <= 2)
    {
	pOutString = new CHXString(inString);
    }
    else
    {
	domainExt = inString.NthField('.', nFields);

	// distinguish between domestic domains and international domains
	if (!domainExt.CompareNoCase("com")	||
	    !domainExt.CompareNoCase("net")	||
	    !domainExt.CompareNoCase("org")	||
	    !domainExt.CompareNoCase("edu")	||
	    !domainExt.CompareNoCase("gov")	||
	    !domainExt.CompareNoCase("mil"))
	{
	    // save the last 2 nodes for domestic domains
	    outString = inString.NthField('.', nFields - 1);
	    outString += ".";
	    outString += inString.NthField('.', nFields);
	}
	else
	{
	    // save the last 3 nods for international domains