cookies.cpp

linux下的一款播放器

        // no match
        goto cleanup;
    }
    else if (cDomainCopy.GetAt(0) != '.' && cHostCopy.GetLength() > cDomainCopy.GetLength() &&
                 cHostCopy.GetAt(cHostCopy.GetLength() - cDomainCopy.GetLength() - 1) != '.')
    {
       // no match
        goto cleanup;
    }
    bMatches = TRUE;

cleanup:
    return bMatches;
}


BOOL
HXCookies::IsCookieEnabled()
{
    BOOL	bResult = TRUE;
    IHXBuffer*	pBuffer = NULL;

    if (!m_pPreferences)
    {
	if (HXR_OK != m_pContext->QueryInterface(IID_IHXPreferences, (void**)&m_pPreferences))
	{
	    m_pPreferences = NULL;
	}
    }

    if (m_pPreferences &&
	m_pPreferences->ReadPref("CookiesEnabled", pBuffer) == HXR_OK)
    {
	if (strcmp((const char*)pBuffer->GetBuffer(), "0") == 0)
	{
	    bResult = FALSE;
	}

	HX_RELEASE(pBuffer);
    } 
    return bResult;
}

void	    
HXCookies::UpdateModificationTime(void)
{
#ifdef _OPENWAVE
    // XXXSAB implement this!!!
#else
    struct stat status;

    if (!m_pRMCookiesPath)
    {
	goto cleanup;
    }

#ifndef _VXWORKS
    if (0 == stat(m_pRMCookiesPath, &status))
    {
	m_lastModification = status.st_mtime;
    }
#endif /* _VXWORKS */

cleanup:

    return;
#endif
}

BOOL	    
HXCookies::IsCookieFileModified(void)
{
#ifdef _OPENWAVE
    // XXXSAB implement this!!!
    return FALSE;
#else
    BOOL	bResult = FALSE;
    struct stat	status;

    if (!m_pRMCookiesPath)
    {
	goto cleanup;
    }

#ifndef _VXWORKS
    if (0 == stat(m_pRMCookiesPath, &status) &&
	status.st_mtime != m_lastModification)
    {
	bResult = TRUE;
    }
#endif /* _VXWORKS */

cleanup:

    return bResult;
#endif
}

HX_RESULT
HXCookies::MergeCookieList(CHXSimpleList* pFromList, CHXSimpleList* pToList)
{
    HX_RESULT	    hr = HXR_OK;
    CookieStruct*   pCookie = NULL;
    CHXSimpleList::Iterator  i;

    if (!pFromList)
    {
	goto cleanup;
    }

    for (i = pFromList->Begin(); HXR_OK == hr && i != pFromList->End(); ++i)
    {
	pCookie = (CookieStruct*) (*i);
	
	if (pCookie->bMemoryOnly && !WasCookieAdded(pToList, pCookie))
	{
	    CookieStruct* pNewCookie = new CookieStruct;
	    pNewCookie->pPath = new CHXString(*pCookie->pPath);
	    pNewCookie->pHost = new CHXString(*pCookie->pHost);
	    pNewCookie->pCookieName = new CHXString(*pCookie->pCookieName);
	    pNewCookie->pCookieValue = new CHXString(*pCookie->pCookieValue);
	    pNewCookie->expires = pCookie->expires;
	    pNewCookie->bIsDomain = pCookie->bIsDomain;
	    pNewCookie->bMemoryOnly = pCookie->bMemoryOnly;
	    hr = AddCookie(pNewCookie, pToList);
	}
    }

cleanup:

    return hr;
}

HX_RESULT	
HXCookies::SyncRMCookies(BOOL bSave)
{
    HX_RESULT	    hr = HXR_OK;
    CHXSimpleList*  pNewRMCookies = NULL;
    CHXSimpleList::Iterator i;
    CookieStruct* pCookie = NULL;
    BOOL bCookieFileModified = FALSE;

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

    bCookieFileModified = IsCookieFileModified();
    if (bCookieFileModified)
    {
	if (HXR_OK == OpenCookies(m_pRMCookiesPath, TRUE, pNewRMCookies))
	{
	    if (m_bSaveCookies)
	    {
		MergeCookieList(m_pRMCookies, pNewRMCookies);
	    }		
	     
	    ResetCookies(m_pRMCookies);
	    HX_DELETE(m_pRMCookies);

	    m_pRMCookies = pNewRMCookies;
	}	    	    
    }

    if (bSave && m_bSaveCookies)
    {
	if(m_pRMCookies && bCookieFileModified && pNewRMCookies == NULL)
	{
	    //this means there are no more cookies on disk, and we need to look at what's in memory, and keep
	    //only cookies that have bMemoryOnly set
	    pNewRMCookies = new CHXSimpleList;

	    while (m_pRMCookies && m_pRMCookies->GetCount() > 0 && pNewRMCookies)
	    {
	    	pCookie = (CookieStruct*) m_pRMCookies->RemoveHead();
		if(pCookie->bMemoryOnly)
		{
		    CookieStruct* pNewCookie = new CookieStruct;
		    pNewCookie->pPath = new CHXString(*pCookie->pPath);
		    pNewCookie->pHost = new CHXString(*pCookie->pHost);
		    pNewCookie->pCookieName = new CHXString(*pCookie->pCookieName);
		    pNewCookie->pCookieValue = new CHXString(*pCookie->pCookieValue);
		    pNewCookie->expires = pCookie->expires;
		    pNewCookie->bIsDomain = pCookie->bIsDomain;
		    pNewCookie->bMemoryOnly = pCookie->bMemoryOnly;
		    AddCookie(pNewCookie, pNewRMCookies);
		}
	    	HX_DELETE(pCookie);
	    }
	    HX_DELETE(m_pRMCookies);
	    m_pRMCookies = pNewRMCookies;
	}
	hr = SaveCookies();
    }

cleanup:

    return hr;
}

#ifdef _TEST
void
HXCookies::DumpCookies(void)
{
    CHXSimpleList* pCookies = NULL;
    CookieStruct*  pCookie = NULL;
    CHXSimpleList::Iterator  i;

    for (int l = 0; l < 2; l++)
    {
	switch (l)
	{
	case 0:
	    pCookies = m_pNSCookies;
	    break;
	case 1:
	    pCookies = m_pRMCookies;
	    break;
	default:
	    break;
	}

	if (pCookies)
	{
	    printf("Total cookies: %lu\n", pCookies->GetCount());
    
	    for (i = pCookies->Begin(); i != pCookies->End(); ++i)
	    {
		pCookie = (CookieStruct*) (*i);
		
		printf("%s\t%s\t%s\n",
		       (const char*)*(pCookie->pHost),
		       (const char*)*(pCookie->pCookieName),
		       (const char*)*(pCookie->pCookieValue));
	    }
	}
    }

    return;
}
#endif // _TEST




//IRPCookies
STDMETHODIMP HXCookies::GetExpiredCookies(const char* pHost,
    				    const char*	       pPath,
    				    REF(IHXBuffer*)   pCookies)
{
    HX_RESULT	    hr = HXR_OK;
    char*	    cp = NULL;
    char*	    pComma = NULL;
    char*	    pEqualSign = NULL;
    char*	    pData = NULL;
    char*	    pURL = NULL;
    int		    l = 0;
    int		    host_length = 0;
    int		    path_length = 0;
    int		    domain_length = 0;
    BOOL	    bAdded = FALSE;
    UINT32	    dwSize = 0;    
    time_t	    cur_time = time(NULL);
    CookieStruct*   pTempCookie = NULL;
    CookieStruct*   pNewCookie = NULL;
    CHXSimpleList*  pCookiesFound1 = NULL;
    //CHXSimpleList*  pCookiesFound2 = NULL;
    CHXSimpleList*  pCookiesList = NULL;
    IHXValues*	    pValues = NULL;
    CHXSimpleList::Iterator  i;
    CHXString       cHostCopy;
    INT32           lColon;
    
    pCookies = NULL;

    if (!IsCookieEnabled())
    {
	goto cleanup;
    }

    if (!m_bInitialized)
    {
	hr = Initialize();

	if (HXR_OK != hr)
	{
	    goto cleanup;
	}
    }
    else
    {
	SyncRMCookies(FALSE);
    }

    if (!pHost || !m_pCookiesHelper)
    {
	hr = HXR_FAILED;
	goto cleanup;
    }

    // return string to build    
    if (!(pValues = new CHXHeader()))
    {
	hr = HXR_OUTOFMEMORY;
	goto cleanup;
    }

    pValues->AddRef();

    cHostCopy = pHost;
    lColon    = cHostCopy.Find(':');
    if (lColon >= 0)
    {
	cHostCopy = cHostCopy.Left(lColon);
    }
    cHostCopy.MakeLower();

    // search for all cookies(Netscape only for now)
    for (l = 0; l < 2; l++)
    {
	switch (l)
	{
	case 0:
	    pCookiesList = m_pRMCookies;
	    break;
	case 1:
	    pCookiesList = m_pNSCookies;
	    break;
	default:
	    break;
	}

	if (!pCookiesList)
	{
	    continue;
	}

	for (i = pCookiesList->Begin(); i != pCookiesList->End(); ++i)
	{
	    pTempCookie = (CookieStruct*) (*i);
    
	    if (!pTempCookie->pHost)
	    {
		continue;
	    }

	    // check the host or domain first
	    if(pTempCookie->bIsDomain)
	    {
		domain_length = pTempCookie->pHost->GetLength();

		CHXString cDomainCopy(*(pTempCookie->pHost));
		cDomainCopy.MakeLower();

		// Now we compare the domain (from the cookie itself) with
		// the rightmost characters of the host. For instance,
		// a domain of ".bar.com" would match with a host (passed in)
		// of "foo.bar.com", "www.bar.com", etc. but would NOT match
		// a host of "bar.com".
		CHXString cHostRight = cHostCopy.Right(cDomainCopy.GetLength());
		if (cHostRight != cDomainCopy)
		{
		    // no match
		    continue;
		}
	    }
	    else if(strcasecmp((const char*)*(pTempCookie->pHost), pHost))
	    {
		// hostname matchup failed.
		continue;
	    }

	    // shorter strings always come last so there can be no
	    // ambiquity						     	      
	    if(pTempCookie->pPath && 
	       !strncmp(pPath, (const char*)*(pTempCookie->pPath), pTempCookie->pPath->GetLength()))
	    {
		// check for expired cookies
		if(pTempCookie->expires && (pTempCookie->expires < cur_time))
		{
		    if (!pCookiesFound1)
		    {
		        pCookiesFound1 = new CHXSimpleList();
		    }
		    pCookiesFound1->AddTail(pTempCookie);
		}
	    }
	}
    }

#ifdef _WINDOWS
    if (!_pInternetGetCookie || m_bMemoryOnly)
    {
	goto cleanup;
    }

    host_length = strlen(pHost);

    if (pPath)
    {
	path_length = strlen(pPath);
    }

    pURL = new char[host_length + path_length + 8];
    sprintf(pURL, "http://%s%s", pHost, pPath); /* Flawfinder: ignore */

    if (_pInternetGetCookie(pURL, NULL, pData, &dwSize) && !pData && dwSize)
    {
	pData = new char[dwSize+1];

	if (!_pInternetGetCookie(pURL, NULL, pData, &dwSize))
	{
	    goto cleanup;
	}

	cp = pData;

	while (pComma = (char*) ::HXFindChar(cp, ';'))
	{
	    *pComma = '\0';
	    pComma++;

	    if (pEqualSign = (char*) ::HXFindChar(cp, '='))
	    {
		*pEqualSign = '\0';
		pEqualSign++;

		pNewCookie = new CookieStruct;
		bAdded = FALSE;

		// copy
		pNewCookie->pCookieValue = new CHXString(pEqualSign);
		pNewCookie->pCookieName = new CHXString(cp);
		pNewCookie->pPath = NULL;
		pNewCookie->pHost = NULL;
		pNewCookie->expires = 0;
		pNewCookie->bIsDomain = FALSE;
		pNewCookie->bMemoryOnly = FALSE;

		if (!WasCookieAdded(pCookiesFound1, pNewCookie))
		{
		    //if (!pCookiesFound2)
		    //{
		    //	pCookiesFound2 = new CHXSimpleList();
		    //	pCookiesFound2->AddTail(pNewCookie);
		    //	bAdded = TRUE;
		    //}
		    //else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
		    //{
		    //	pCookiesFound2->AddTail(pNewCookie);
		    //	bAdded = TRUE;
		    //}
		}
		
		if (!bAdded)
		{
		    HX_DELETE(pNewCookie);
		}
	    }

	    cp = pComma;
	}

	if (pEqualSign = (char*) ::HXFindChar(cp, '='))
	{
	    *pEqualSign = '\0';
	    pEqualSign++;

	    pNewCookie = new CookieStruct;
	    bAdded = FALSE;

	    // copy
	    pNewCookie->pCookieValue = new CHXString(pEqualSign);
	    pNewCookie->pCookieName = new CHXString(cp);
	    pNewCookie->pPath = NULL;
	    pNewCookie->pHost = NULL;
	    pNewCookie->expires = 0;
	    pNewCookie->bIsDomain = FALSE;
	    pNewCookie->bMemoryOnly = FALSE;

	    if (!WasCookieAdded(pCookiesFound1, pNewCookie))
	    {
		//if (!pCookiesFound2)
		//{
		//    pCookiesFound2 = new CHXSimpleList();
		//    pCookiesFound2->AddTail(pNewCookie);
		//    bAdded = TRUE;
		//}
		//else if (!WasCookieAdded(pCookiesFound2, pNewCookie))
		//{
		//    pCookiesFound2->AddTail(pNewCookie);
		//    bAdded = TRUE;
		//}
	    }

	    if (!bAdded)
	    {
		HX_DELETE(pNewCookie);
	    }
	}
    }
#endif /* _WINDOWS */

cleanup:

    if (pCookiesFound1)
    {
	for (i = pCookiesFound1->Begin(); i != pCookiesFound1->End(); ++i)
	{
	    pTempCookie = (CookieStruct*) (*i);

	    if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
	    {
		::SaveStringToHeader(pValues,
				     (const char*)*(pTempCookie->pCookieName),
				     (char*)(const char*)*(pTempCookie->pCookieValue));
	    }
	}
    }

    //if (pCookiesFound2)
    //{
    //	for (i = pCookiesFound2->Begin(); i != pCookiesFound2->End(); ++i)
    //	{
    //	    pTempCookie = (CookieStruct*) (*i);
    //
    //	    if(pTempCookie->pCookieName && pTempCookie->pCookieValue)
    //	    {
    //		::SaveStringToHeader(pValues,
    //				     (const char*)*(pTempCookie->pCookieName),
    //				     (char*)(const char*)*(pTempCookie->pCookieValue));
    //	    }
    //
    //	    HX_DELETE(pTempCookie);
    //	}
    //}

    if (m_pCookiesHelper)
    {
	hr = m_pCookiesHelper->UnPack(pValues, pCookies);
    }

    HX_DELETE(pCookiesFound1);
    //HX_DELETE(pCookiesFound2);
    HX_VECTOR_DELETE(pData);
    HX_VECTOR_DELETE(pURL);

    HX_RELEASE(pValues);
   
    return hr;
}

HX_RESULT HXCookies::SecureCookies()
{
    return HXR_OK;
}

HX_RESULT HXCookies::CheckCookies()
{
    return HXR_OK;
}