httpfsys.cpp

linux下的一款播放器

/////////////////////////////////////////////////////////////////////////
//  Method:
//	CHTTPFileSystem::RefreshCache
//
STDMETHODIMP 
CHTTPFileSystem::RefreshCache(void)
{
    LOGX ((szDbgTemp, "RefreshCache()"));
    
    if (g_pCacheEntry)
    {
        g_pCacheEntry->CleanCache(0, 0);
        
        delete g_pCacheEntry;
        g_pCacheEntry = NULL;
    }
    return HXR_OK;
}

/////////////////////////////////////////////////////////////////////////
//  Method:
//	CHTTPFileSystem::EmptyCache
//
STDMETHODIMP
CHTTPFileSystem::EmptyCache(void)
{
    LOGX ((szDbgTemp, "EmptyCache()"));
    
    if (g_pCacheEntry == NULL)
    {
	///XXXXXXXXXTHIS IS A TEMPORARY THING.  WE NEED TO MAKE CLEANCACHE A STATIC ROUTINE...
	// Get the location of the cache...
	IHXCommonClassFactory *commonClassFactory = NULL;
	IHXPreferences *preferences = NULL;
	IHXBuffer *buffer = NULL;
	m_pContext->QueryInterface(IID_IHXCommonClassFactory, (void **)(&commonClassFactory));
        m_pContext->QueryInterface(IID_IHXPreferences, (void **)(&preferences));
	if ((preferences != NULL) && (commonClassFactory != NULL))
	{
	    if (preferences->ReadPref("CacheFilename", buffer) != HXR_OK)
	    {
		if (HXR_OK == commonClassFactory->CreateInstance(CLSID_IHXBuffer, (void**)(&buffer)))
		{
#ifdef USE_TEMP_CACHE_LOCATION
		    SetBufferToCacheFilePath(buffer);
#else

		    char  szModule[MAX_CACHE_FILENAME + sizeof DEF_CACHE_DB + 4] = { 0 }; /* Flawfinder: ignore */
#ifdef _MACINTOSH
		    FSSpec fileSpec;
		    GetCurrentAppSpec(&fileSpec);
		    CHXString fullpath;
		    fullpath = fileSpec;
		    SafeStrCpy(szModule, fullpath, sizeof(szModule));
#elif defined(_WIN32)
                    GetModuleFileName(NULL, OS_STRING2(szModule,MAX_CACHE_FILENAME), MAX_CACHE_FILENAME);
#else
                    *szModule = '\0';
#endif

		    INT8* pFilename = ::strrchr(szModule, OS_SEPARATOR_CHAR);

		    if (pFilename == NULL)
		    {
			pFilename = ::strrchr(szModule, '/');
		    }

		    if (pFilename != NULL) // Found
		    {
			// module file name starts after the separator charactor
			*pFilename = '\0';
		    }
		    // Add on the cache database filename portion
		    ::strcat (szModule, OS_SEPARATOR_STRING); /* Flawfinder: ignore */
		    ::strcat (szModule, DEF_CACHE_DB); /* Flawfinder: ignore */
		    buffer->Set((UINT8*)szModule, strlen(szModule) + 1);
#endif // !USE_TEMP_CACHE_LOCATION
		}
	    }
	}

	// Get the max size of the cache...
	ULONG32 maxCacheSize = DEFAULT_MAX_CACHE_SIZE;
	IHXBuffer *pBuffer = NULL;
	if (preferences->ReadPref("CacheMaxSize", pBuffer) == HXR_OK)
	{
	    maxCacheSize = atoi((const char*)pBuffer->GetBuffer());

	    if (maxCacheSize < MININUM_MAX_CACHE_SIZE)
	    {
		maxCacheSize = MININUM_MAX_CACHE_SIZE;
	    }
	    HX_RELEASE(pBuffer);
	}
	HX_RELEASE(preferences);
	HX_RELEASE(commonClassFactory);

	// Create a new cache entry to use in a bit...
	g_pCacheEntry = new CCacheEntry ((char *)buffer->GetBuffer(), maxCacheSize, NULL);
	HX_RELEASE(buffer);
    }

    // We should have a cache now...
    HX_ASSERT(g_pCacheEntry != NULL);

    // Clean out the cache now...
    g_pCacheEntry->CleanCache(time(NULL), 0);

    delete g_pCacheEntry;
    g_pCacheEntry = NULL;
    return HXR_OK;
}
/////////////////////////////////////////////////////////////////////////
//  Method:
//	CHTTPFileSystem::MoveCache
//
//
STDMETHODIMP
CHTTPFileSystem::MoveCache(const char *path)
{
    LOGX ((szDbgTemp, "MoveCache()"));

    // We want to clean the cache first
    if (g_pCacheEntry)
    {
        g_pCacheEntry->CleanCache(0, 0);
        
        // Now move the directory sub-tree to the new location
        
        // Now re-open the database from the new location
	delete g_pCacheEntry;
	g_pCacheEntry = NULL;
    }
    
    return HXR_OK;
}


STDMETHODIMP_(void)
CHTTPFileSystem::SetDestinationFile( const char *pFilename )
{
    if( pFilename && ::strlen( pFilename ) )
    {
	m_bSaveNextStream = TRUE;
	m_SaveFileName = pFilename;
    }
    else
	m_bSaveNextStream = FALSE;
}


/*****************************************************************
 *
 * FileObject methods
 *
 *****************************************************************/

CHTTPFileObject* 
CHTTPFileObject::CreateObject()             
{                                                   
    LOGX ((szDbgTemp, "CreateObject()"));
    CHTTPFileObject* pNew = new CHTTPFileObject;
    if (pNew)                                       
    {                                               
        pNew->m_lCount = 1;                         
        HX_RESULT pnrRes = HXR_OK;//pNew->FinalConstruct();  
        pNew->m_lCount = 0;                         
        if (FAILED(pnrRes))                         
        {                                           
            delete pNew;                            
            return NULL;                            
        }                                           
    }          
    return pNew;                                    
}                                                   

STDMETHODIMP_(ULONG32) 
CHTTPFileObject::AddRef (THIS)
{
    return InterlockedIncrement(&m_lCount);
}

STDMETHODIMP_(ULONG32) 
CHTTPFileObject::Release (THIS)
{
    HX_ASSERT(m_lCount>=0);
    if (InterlockedDecrement(&m_lCount) > 0)
    {
        return m_lCount;
    }

    delete this;
    return 0;
}

STDMETHODIMP 
CHTTPFileObject::QueryInterface(REFIID riid, void** ppvObj)
{                                                           
    LOGX ((szDbgTemp, "QueryInterface(x0%08X)", riid));
    if (!ppvObj)                                            
        return HXR_POINTER;                                 
    if (IsEqualIID(IID_IUnknown, riid))                     
    {                                                       
        AddRef();                                           
        *ppvObj = (this);
        return HXR_OK;                                      
    }
    if (IsEqualIID(IID_IHXRequestHandler, riid))               
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXRequestHandler*)(this);          
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXFileObject, riid))           
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXFileObject*)(this);              
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXFileExists, riid))           
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXFileExists*)(this);              
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXFileStat, riid))             
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXFileStat*)(this);                
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXFileMimeMapper, riid))               
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXFileMimeMapper*)(this);          
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXGetFileFromSamePool, riid))          
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXGetFileFromSamePool*)(this);             
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXPendingStatus, riid))                
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXPendingStatus*)(this);           

        //FNH This is probably not needed
        ProcessCacheCompletions(FALSE);
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXRequestHandler, riid))               
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXRequestHandler*)(this);          
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXTimeoutSettings, riid))              
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXTimeoutSettings*)(this);         
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXClientAuthResponse, riid))           
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXClientAuthResponse*)(this);              
        return HXR_OK;                                  
    }
    if (IsEqualIID(IID_IHXHTTPRedirect, riid))           
    {                                                   
        AddRef();                                       
        *ppvObj = (IHXHTTPRedirect*)(this);              
        return HXR_OK;                                  
    }

    *ppvObj = NULL;                             
    return HXR_NOINTERFACE;                     
}

/*
BEGIN_INTERFACE_LIST(CHTTPFileObject)
    INTERFACE_LIST_ENTRY(IID_IHXRequestHandler, IHXRequestHandler)
    INTERFACE_LIST_ENTRY(IID_IHXFileObject, IHXFileObject)
    INTERFACE_LIST_ENTRY(IID_IHXFileExists, IHXFileExists)
    INTERFACE_LIST_ENTRY(IID_IHXFileStat, IHXFileStat)
    INTERFACE_LIST_ENTRY(IID_IHXFileMimeMapper, IHXFileMimeMapper)
    INTERFACE_LIST_ENTRY(IID_IHXGetFileFromSamePool, IHXGetFileFromSamePool)
    INTERFACE_LIST_ENTRY(IID_IHXPendingStatus, IHXPendingStatus)
    INTERFACE_LIST_ENTRY(IID_IHXTimeoutSettings, IHXTimeoutSettings)
    INTERFACE_LIST_ENTRY(IID_IHXClientAuthResponse, IHXClientAuthResponse)
    INTERFACE_LIST_ENTRY(IID_IHXRequestHandler, IHXRequestHandler)
END_INTERFACE_LIST
*/

CHTTPFileObject::CHTTPFileObject()
    : m_LastError (HXR_OK)

    , m_pCommonClassFactory(NULL)
    , m_pPreferences(NULL)
    , m_pScheduler(NULL)
    , m_pRegistry(NULL)
    , m_pContext(NULL)
    , m_pOptions(NULL)
    , m_pInterruptState(NULL)
#ifdef _MACINTOSH    
    , m_pReadDoneBuffer(NULL)
    , m_uReadDoneStatus(HXR_OK)
    , m_bReadDoneToBeProcessed(FALSE)
#endif        
    , m_pErrorMessages(NULL)

    , m_bMimeResponsePending(FALSE)
    , m_pMimeMapperResponse(NULL)

    , m_bFileExistsResponsePending(FALSE)
    , m_pFileExistsResponse(NULL)

    , m_bStatPending(FALSE)
    , m_pFileStatResponse(NULL)

    , m_bInitResponsePending(FALSE)
    , m_pFileResponse (NULL)

    , m_pFileSystem(NULL)

    , m_bTCPReadPending(FALSE)
    , m_pTCPResponse(NULL)

    , m_szBaseURL(NULL)

    , m_pFilename(NULL)
    , m_pPath(NULL)
    , m_pHost(NULL)

    , m_ulFlags(0)
    , m_pRequest(NULL)
    , m_pRequestHeadersOrig(NULL)
    , m_pParams(NULL)

    , m_pLanguage(NULL)

    , m_bAuthorized(FALSE)

    , m_pCallback(NULL)

    , m_bSeekPending (FALSE)
    , m_bInitPending (FALSE)
    , m_bGetProxyInfoPending(FALSE)

    , m_bInitialized(FALSE)
    , m_bInDestructor(FALSE)

    , m_ulCurrentReadPosition (0)

    , m_pDecoder(NULL)
    , m_pChunkyRes(NULL)

    , m_nPort(DEF_HTTP_PORT)

    , m_nRequestTime(0) // used to trigger request time-outs
    , m_bSocketReadTimeout(FALSE) // a socket read timeout has occurred
    , m_nConnTimeout(DEF_HTTP_CONNECT_TIMEOUT)
    , m_nServerTimeout(DEF_HTTP_SERVER_TIMEOUT)
    , m_bDisableConnectionTimeOut(FALSE)
    , m_bConnTimedOut(FALSE)
    , m_bMangleCookies(FALSE)
    , m_pMangledCookies(NULL)
    , m_bShoutcast(FALSE)
    , m_bConvertFailedSeeksToLinear(TRUE)

/**************************/
/* These member variables need to go in a struct
 * if we wanna keep HTTP connection and related downloaded
 * stuff live after the http object is destroyed.
 * This is needed in the case when the first ff plug-in realizes
 * that the file is not of its type and we then load the next
 * related plug-in which then connects to the same URL. We do not
 * want to start downloading from scratch and instead want to use data
 * that had been dowloaded during the lifetime of earlier plug-in
 */
    , m_pSocket(NULL)

    , m_bHTTP1_1(TRUE)

    , m_bConnectDone(FALSE)
    , m_bWriteDone(FALSE)
    , m_bReadHeaderDone(FALSE)
    , m_bReadContentsDone(FALSE)

    , m_bKnowContentSize(FALSE)
    , m_nContentSize(0)
    , m_bEncoded(FALSE)

    , m_bChunkedEncoding(FALSE)
    , m_pChunkedEncoding(NULL)

    , m_nContentRead(0)

    , m_nTotalRequestSize(0)
    , m_nRequestWritten(0)

    , m_nHeaderRead(0)

    , m_strHost()
    , m_strRequest()
    , m_strResource()
    , m_strMimeType()

    , m_bUseProxy(FALSE)
    , m_strProxyHost()
    , m_strProxyResource()
    , m_nProxyPort(DEF_HTTP_PORT)
    , m_uMaxRecursionLevel(MAX_RECURSION_LEVEL)
    , m_uRecursionCount(0)
    , m_bInReadDone(FALSE)
    , m_pCookies(NULL)
    , m_pCookies2(NULL)
    , m_pPAC(NULL)
    , m_pPACInfoList(NULL)
    , m_PACInfoPosition(0)
    , m_bOnServer(FALSE)
    , m_pCacheEntry(NULL)
    , m_pReadBuffer(NULL)
    , m_bCached(FALSE)
    , m_ulCreateTime(0)
    , m_ulExpiryTime(0)
    , m_ulLastModTime(0)
    , m_bReadPending(FALSE)
    , m_bCacheEnabled(TRUE)
    , m_ulCacheMaxSize(DEFAULT_MAX_CACHE_SIZE)
    , m_pCacheFile(NULL)
    , m_ulCutOffDate(0)
    , m_bMirroredServers(FALSE)
    , m_pRedirectResponse(NULL)
    , m_bSaveToFile( FALSE )
    , m_ulOffset(0)
    , m_nPostDataSize(0)
    , m_bPartialData(FALSE)
    , m_bUseHTTPS(FALSE)
    
#ifdef _IIS_HTTP_SERVER_NO_SEEK_SUPPORT_BUG
    , m_bSupportsByteRanges(FALSE)
    , m_bDisableByteRanges(TRUE)
#else  //_IIS_HTTP_SERVER_NO_SEEK_SUPPORT_BUG
    , m_bSupportsByteRanges(TRUE)
    , m_bDisableByteRanges(FALSE)
#endif //_IIS_HTTP_SERVER_NO_SEEK_SUPPORT_BUG
    , m_bExternalByteRangeRequests(FALSE)
    , m_uByteRangeSeekOffset(0)
    , m_bByteRangeSeekPending(FALSE)
    , m_bCheckingWhetherByteRangeWorks(FALSE)
    , m_bServerPresumablyWorksWithByteRangeRequests(TRUE)
    , m_bClosed(FALSE)
    , m_pLastHeader(NULL)
    , m_ulLastHeaderSize(0)
/*************************/
{
}

void