/****************************************************************************\
 *
 *   RATINGS.CPP --Parses out the actual ratings from a site.
 *
 *   Created:   Ann McCurdy
 *     
\****************************************************************************/

/*Includes---------------------------------------------------------*/
#include "msrating.h"
#include "mslubase.h"
#include "debug.h"
#include <ratings.h>
#include <ratingsp.h>
#include "parselbl.h"
#include "picsrule.h"
#include "pleasdlg.h"       // CPleaseDialog
#include <convtime.h>
#include <contxids.h>
#include <shlwapip.h>


#include <wininet.h>

#include <mluisupp.h>

extern PICSRulesRatingSystem * g_pPRRS;
extern array<PICSRulesRatingSystem*> g_arrpPRRS;
extern PICSRulesRatingSystem * g_pApprovedPRRS;
extern PICSRulesRatingSystem * g_pApprovedPRRSPreApply;
extern array<PICSRulesRatingSystem*> g_arrpPICSRulesPRRSPreApply;

extern BOOL g_fPICSRulesEnforced,g_fApprovedSitesEnforced;

extern HMODULE g_hURLMON,g_hWININET;

extern char g_szLastURL[INTERNET_MAX_URL_LENGTH];

extern HINSTANCE g_hInstance;

HANDLE g_HandleGlobalCounter,g_ApprovedSitesHandleGlobalCounter;
long   g_lGlobalCounterValue,g_lApprovedSitesGlobalCounterValue;

DWORD g_dwDataSource;
BOOL  g_fInvalid;

PicsRatingSystemInfo *gPRSI = NULL;


//7c9c1e2a-4dcd-11d2-b972-0060b0c4834d
const GUID GUID_Ratings = { 0x7c9c1e2aL, 0x4dcd, 0x11d2, { 0xb9, 0x72, 0x00, 0x60, 0xb0, 0xc4, 0x83, 0x4d } };

//7c9c1e2b-4dcd-11d2-b972-0060b0c4834d
const GUID GUID_ApprovedSites = { 0x7c9c1e2bL, 0x4dcd, 0x11d2, { 0xb9, 0x72, 0x00, 0x60, 0xb0, 0xc4, 0x83, 0x4d } };


extern CustomRatingHelper *g_pCustomRatingHelperList;
BOOL g_fIsRunningUnderCustom = FALSE;

void TerminateRatings(BOOL bProcessDetach);

//+-----------------------------------------------------------------------
//
//  Function:  RatingsCustomInit
//
//  Synopsis:  Initialize the msrating dll for Custom
//
//  Arguments: bInit (Default TRUE) - TRUE: change into Custom Mode
//                                    FALSE: change out of Custom Mode
//
//  Returns:   S_OK if properly initialized, E_OUTOFMEMORY otherwise
//
//------------------------------------------------------------------------
HRESULT WINAPI RatingCustomInit(BOOL bInit)
{
    HRESULT hres = E_OUTOFMEMORY;

    ENTERCRITICAL;

    if (bInit)
    {
        if (NULL != gPRSI)
        {
            delete gPRSI;
        }
        gPRSI = new PicsRatingSystemInfo;
        if (gPRSI)
        {
            g_fIsRunningUnderCustom = TRUE;
            hres = S_OK;
        }
    }
    else
    {
        TerminateRatings(FALSE);
        RatingInit();
        g_fIsRunningUnderCustom = FALSE;
        hres = S_OK;
    }
    LEAVECRITICAL;

    return hres;
    
}

//+-----------------------------------------------------------------------
//
//  Function:  RatingCustomAddRatingSystem
//
//  Synopsis:  Hand the description of a PICS rating system file to msrating.
//             The description is simply the contents of an RAT file.
//
//  Arguments: pszRatingSystemBuffer : buffer containing the description
//             nBufferSize : the size of pszRatingSystemBuffer
//
//  Returns:   Success if rating system added
//             This function will not succeed if RatingCustomInit has
//             not been called.
//
//------------------------------------------------------------------------
STDAPI RatingCustomAddRatingSystem(LPSTR pszRatingSystemBuffer, UINT nBufferSize)
{
    HRESULT hres = E_OUTOFMEMORY;

    if(!pszRatingSystemBuffer || nBufferSize == 0)
    {
        return E_INVALIDARG;
    }

    if (g_fIsRunningUnderCustom)
    {
        PicsRatingSystem* pPRS = new PicsRatingSystem;
 
        if (pPRS)
        {
            hres = pPRS->Parse(NULL, pszRatingSystemBuffer);
            if (SUCCEEDED(hres))
            {
                pPRS->dwFlags |= PRS_ISVALID;
            }
        }
        
        if (SUCCEEDED(hres))
        {
            ENTERCRITICAL;
        
            gPRSI->arrpPRS.Append(pPRS);
            gPRSI->fRatingInstalled = TRUE;

            LEAVECRITICAL;
        }
        else
        {
            if(pPRS)
            {
                delete pPRS;
                pPRS = NULL;
            }
        }
    }
    else
    {
        hres = E_FAIL;
    }
    return hres;
}

//+-----------------------------------------------------------------------
//
//  Function:  RatingCustomSetUserOptions
//
//  Synopsis:  Set the user options for the msrating dll for this process
//
//  Arguments: pRSSetings : pointer to an array of rating system settings
//             cSettings : number of rating systems
//
//  Returns:   Success if user properly set
//             This function will not succeed if RatingCustomInit has
//             not been called.
//
//------------------------------------------------------------------------
HRESULT WINAPI RatingCustomSetUserOptions(RATINGSYSTEMSETTING* pRSSettings, UINT cSettings) {

    if (!pRSSettings || cSettings == 0)
    {
        return E_INVALIDARG;
    }
    ENTERCRITICAL;

    HRESULT hres = E_OUTOFMEMORY;
    UINT err, errTemp;

    if (g_fIsRunningUnderCustom)
    {
        if (gPRSI)
        {
            PicsUser* puser = new PicsUser;

            if (puser)
            {
                for (UINT i=0; i<cSettings; i++)
                {
                    UserRatingSystem* pURS = new UserRatingSystem;
                    if (!pURS)
                    {
                        err = ERROR_NOT_ENOUGH_MEMORY;
                        break;
                    }
                    if (errTemp = pURS->QueryError())
                    {
                        err = errTemp;
                        break;
                    }
                    RATINGSYSTEMSETTING* parss = &pRSSettings[i];
                    
                    pURS->SetName(parss->pszRatingSystemName);
                    pURS->m_pPRS = FindInstalledRatingSystem(parss->pszRatingSystemName);
                    
                    for (UINT j=0; j<parss->cCategories; j++)
                    {
                        UserRating* pUR = new UserRating;
                        if (pUR)
                        {
                            if (errTemp = pUR->QueryError())
                            {
                                err = errTemp;
                            }
                            else
                            {
                                RATINGCATEGORYSETTING* parcs = &parss->paRCS[j];
                                pUR->SetName(parcs->pszValueName);
                                pUR->m_nValue = parcs->nValue;
                                if (pURS->m_pPRS)
                                {
                                    pUR->m_pPC = FindInstalledCategory(pURS->m_pPRS->arrpPC, parcs->pszValueName);
                                }
                                err = pURS->AddRating(pUR);
                            }
                        }
                        else
                        {
                            err = ERROR_NOT_ENOUGH_MEMORY;
                        }
                        if (ERROR_SUCCESS != err)
                        {
                            if (pUR)
                            {
                                delete pUR;
                                pUR = NULL;
                            }
                            break;
                        }
                    }
                    if (ERROR_SUCCESS == err)
                    {
                        err = puser->AddRatingSystem(pURS);
                    }
                    if (ERROR_SUCCESS != err)
                    {
                        if (pURS)
                        {
                            delete pURS;
                            pURS = NULL;
                        }
                        break;
                    }
                }
                if (ERROR_SUCCESS == err)
                {
                    hres = NOERROR;
                    gPRSI->fSettingsValid = TRUE;
                    if (gPRSI->pUserObject)
                    {
                        delete gPRSI->pUserObject;
                    }
                    gPRSI->pUserObject = puser;
                }
            }
        }
        else
        {
            hres = E_UNEXPECTED;
        }
    }
    else
    {
        hres = E_FAIL;
    }
    LEAVECRITICAL;
    
    return hres;

}


//+-----------------------------------------------------------------------
//
//  Function:  RatingCustomAddRatingHelper
//
//  Synopsis:  Add a Custom ratings helper object
//
//  Arguments: pszLibraryName : name of the library to load the helper from
//             clsid : CLSID of the rating helper
//             dwSort : Sort order or priority of the helper
//
//  Returns:   Success if rating helper added properly set
//             This function will not succeed if RatingCustomInit has
//             not been called.
//
//------------------------------------------------------------------------
HRESULT WINAPI RatingCustomAddRatingHelper(LPCSTR pszLibraryName, CLSID clsid, DWORD dwSort)
{ 
    HRESULT hr = E_UNEXPECTED;

    if (g_fIsRunningUnderCustom)
    {
        CustomRatingHelper* pmrh = new CustomRatingHelper;

        if(NULL == pmrh)
        {
            hr = E_OUTOFMEMORY;
        }
        else
        {
            pmrh->hLibrary = LoadLibrary(pszLibraryName);
            if (pmrh->hLibrary)
            {
                pmrh->clsid = clsid;
                pmrh->dwSort = dwSort;

                ENTERCRITICAL;

                CustomRatingHelper* pmrhCurrent = g_pCustomRatingHelperList;
                CustomRatingHelper* pmrhPrev = NULL;

                while (pmrhCurrent && pmrhCurrent->dwSort < pmrh->dwSort)
                {
                    pmrhPrev = pmrhCurrent;
                    pmrhCurrent = pmrhCurrent->pNextHelper;
                }

                if (pmrhPrev)
                {
                    ASSERT(pmrhPrev->pNextHelper == pmrhCurrent);

                    pmrh->pNextHelper = pmrhCurrent;
                    pmrhPrev->pNextHelper = pmrh;
                }
                else
                {
                    ASSERT(pmrhCurrent == g_pCustomRatingHelperList);

                    pmrh->pNextHelper = g_pCustomRatingHelperList;
                    g_pCustomRatingHelperList = pmrh;
                }


                hr = S_OK;

                LEAVECRITICAL;
            
            } // if (pmrh->hLibrary)
            else
            {
                hr = E_FAIL;
            }
        }
    }
    else
    {
        hr = E_FAIL;
    }
    return hr;
}

//+-----------------------------------------------------------------------
//
//  Function:  RatingCustomRemoveRatingHelper
//
//  Synopsis:  Remove Custom rating helpers
//
//  Arguments: CLSID : CLSID of the helper to remove
//
//  Returns:   S_OK if rating helper removed, S_FALSE if not found
//             E_UNEXPECTED if the global custom helper list is corrupted.
//             This function will not succeed if RatingCustomInit has
//             not been called and will return E_FAIL
//
//------------------------------------------------------------------------
HRESULT WINAPI RatingCustomRemoveRatingHelper(CLSID clsid)
{
    CustomRatingHelper* pmrhCurrent = NULL;
    CustomRatingHelper* pmrhTemp = NULL;
    CustomRatingHelper* pmrhPrev = NULL;

    HRESULT hr = E_UNEXPECTED;

    if (g_fIsRunningUnderCustom)
    {
        if (NULL != g_pCustomRatingHelperList)
        {
            hr = S_FALSE;

            ENTERCRITICAL;
        
            pmrhCurrent = g_pCustomRatingHelperList;

            while (pmrhCurrent && pmrhCurrent->clsid != clsid)
            {
                pmrhPrev = pmrhCurrent;
                pmrhCurrent = pmrhCurrent->pNextHelper;
            }

            if (pmrhCurrent)
            {
                //
                // Snag copy of the node
                //
                pmrhTemp = pmrhCurrent;

                if (pmrhPrev)   // Not on first node
                {
                    //
                    // Unlink the deleted node
                    //
                    pmrhPrev->pNextHelper = pmrhCurrent->pNextHelper;
                }
                else            // First node -- adjust head pointer
                {
                    ASSERT(pmrhCurrent == g_pCustomRatingHelperList);

                    g_pCustomRatingHelperList = g_pCustomRatingHelperList->pNextHelper;
                }

                //
                // Wipe out the node
                //
                delete pmrhTemp;
                pmrhTemp = NULL;

                hr = S_OK;
            }

            LEAVECRITICAL;
        }
    }
    else
    {
        hr = E_FAIL;
    }
    return hr;
}

//+-----------------------------------------------------------------------
//
//  Function:  RatingCustomSetDefaultBureau
//
//  Synopsis:  Set the URL of the default rating bureau
//
//  Arguments: pszRatingBureau - URL of the rating bureau
//
//  Returns:   S_OK if success, E_FAIL if RatingCustomInit has not been
//             called, E_OUTOFMEMORY if unable to allocate memory
//             E_INVALIDARG if pszRatingBureau is NULL
//             This function will not succeed if RatingCustomInit has
//             not been called and return E_FAIL.
//
//------------------------------------------------------------------------
HRESULT WINAPI RatingCustomSetDefaultBureau(LPCSTR pszRatingBureau)
{
    HRESULT hr;

    if (pszRatingBureau)
    {
        if (g_fIsRunningUnderCustom)
        {
            LPSTR pszTemp = new char[strlenf(pszRatingBureau)+1];
            if (pszTemp)
            {
                strcpy(pszTemp, pszRatingBureau);
                gPRSI->etstrRatingBureau.SetTo(pszTemp);
                hr = S_OK;
            } // if (pszTemp)
            else
            {
                hr = E_OUTOFMEMORY;
            }
        } // if(g_fIsRunningUnderCustom)
        else
        {
            hr = E_FAIL;
        }
    }
    else
    {
        hr = E_INVALIDARG;
    }
    return hr;
}

HRESULT WINAPI RatingInit()
{
    DWORD                   dwNumSystems,dwCounter;
    HRESULT                 hRes;
    PICSRulesRatingSystem   * pPRRS=NULL;

    g_hURLMON=LoadLibrary("URLMON.DLL");

    if (g_hURLMON==NULL)
    {
        TraceMsg( TF_ERROR, "RatingInit() - Failed to Load URLMON!" );

        g_pPRRS=NULL;                   //we couldn't load URLMON

        hRes=E_UNEXPECTED;
    }

    g_hWININET=LoadLibrary("WININET.DLL");

    if (g_hWININET==NULL)
    {
        TraceMsg( TF_ERROR, "RatingInit() - Failed to Load WININET!" );

        g_pPRRS=NULL;                   //we couldn't load WININET

        hRes=E_UNEXPECTED;
    }

    g_HandleGlobalCounter=SHGlobalCounterCreate(GUID_Ratings);
    g_lGlobalCounterValue=SHGlobalCounterGetValue(g_HandleGlobalCounter);

    g_ApprovedSitesHandleGlobalCounter=SHGlobalCounterCreate(GUID_ApprovedSites);
    g_lApprovedSitesGlobalCounterValue=SHGlobalCounterGetValue(g_ApprovedSitesHandleGlobalCounter);

    gPRSI = new PicsRatingSystemInfo;
    if(gPRSI == NULL)
    {
        TraceMsg( TF_ERROR, "RatingInit() - gPRSI is NULL!" );
        return E_OUTOFMEMORY;
    }

    gPRSI->Init();

    hRes=PICSRulesReadFromRegistry(PICSRULES_APPROVEDSITES,&g_pApprovedPRRS);

    if (FAILED(hRes))
    {
        g_pApprovedPRRS=NULL;
    }

    hRes=PICSRulesGetNumSystems(&dwNumSystems);

    if (SUCCEEDED(hRes)) //we have PICSRules systems to inforce
    {
        for (dwCounter=PICSRULES_FIRSTSYSTEMINDEX;
            dwCounter<(dwNumSystems+PICSRULES_FIRSTSYSTEMINDEX);
            dwCounter++)
        {
            hRes=PICSRulesReadFromRegistry(dwCounter,&pPRRS);

            if (FAILED(hRes))
            {
                char    *lpszTitle,*lpszMessage;

                //we couldn't read in the systems, so don't inforce PICSRules,
                //and notify the user
                
                g_arrpPRRS.DeleteAll();

                lpszTitle=(char *) GlobalAlloc(GPTR,MAX_PATH);
                lpszMessage=(char *) GlobalAlloc(GPTR,MAX_PATH);

                MLLoadString(IDS_PICSRULES_TAMPEREDREADTITLE,(LPTSTR) lpszTitle,MAX_PATH);
                MLLoadString(IDS_PICSRULES_TAMPEREDREADMSG,(LPTSTR) lpszMessage,MAX_PATH);

                MessageBox(NULL,(LPCTSTR) lpszMessage,(LPCTSTR) lpszTitle,MB_OK|MB_ICONERROR);

                GlobalFree(lpszTitle);
                lpszTitle = NULL;
                GlobalFree(lpszMessage);
                lpszMessage = NULL;

                break;
            }
            else
            {
                g_arrpPRRS.Append(pPRRS);

                pPRRS=NULL;
            }
        }
    }

    return NOERROR; 
}

// YANGXU: 11/16/1999
// Actual rating term function that does the work
// bProcessDetach: pass in as true if terminating during
// ProcessDetach so libraries are not freed

void TerminateRatings(BOOL bProcessDetach)
{
    delete gPRSI;
    gPRSI = NULL;

    if (g_pApprovedPRRS != NULL)
    {
        delete g_pApprovedPRRS;
        g_pApprovedPRRS = NULL;
    }

    if (g_pApprovedPRRSPreApply != NULL)
    {
        delete g_pApprovedPRRSPreApply;
        g_pApprovedPRRSPreApply = NULL;
    }

    g_arrpPRRS.DeleteAll();
    g_arrpPICSRulesPRRSPreApply.DeleteAll();

    CloseHandle(g_HandleGlobalCounter);
    CloseHandle(g_ApprovedSitesHandleGlobalCounter);

    CustomRatingHelper  *pTemp;
    
    while (g_pCustomRatingHelperList)
    {
        pTemp = g_pCustomRatingHelperList;

        if (bProcessDetach)
        {
            // TRICKY: Can't FreeLibrary() during DLL_PROCESS_DETACH, so leak the HMODULE...
            //         (setting to NULL prevents the destructor from doing FreeLibrary()).
            //
            g_pCustomRatingHelperList->hLibrary = NULL;
        }
        
        g_pCustomRatingHelperList = g_pCustomRatingHelperList->pNextHelper;

        delete pTemp;
        pTemp = NULL;
    }

    if (bProcessDetach)
    {
        if ( g_hURLMON )
        {
            FreeLibrary(g_hURLMON);
            g_hURLMON = NULL;
        }

        if ( g_hWININET )
        {
            FreeLibrary(g_hWININET);
            g_hWININET = NULL;
        }
    }
}

void RatingTerm()
{
    TerminateRatings(TRUE);
}


HRESULT WINAPI RatingEnabledQuery()
{
    CheckGlobalInfoRev();

    // $BUG - If the Settings are not valid should we return E_FAIL?
    if (gPRSI && !gPRSI->fSettingsValid)
        return S_OK;

    if (gPRSI && gPRSI->fRatingInstalled) {
        PicsUser *pUser = ::GetUserObject();
        return (pUser && pUser->fEnabled) ? S_OK : S_FALSE;
    }
    else {
        return E_FAIL;
    }
}

// Store the Parsed Label List of Ratings Information to ppRatingDetails.
void StoreRatingDetails( CParsedLabelList * pParsed, LPVOID * ppRatingDetails )
{
    if (ppRatingDetails != NULL)
    {
        *ppRatingDetails = pParsed;
    }
    else
    {
        if ( pParsed )
        {
            FreeParsedLabelList(pParsed);
            pParsed = NULL;
        }
    }
}

HRESULT WINAPI RatingCheckUserAccess(LPCSTR pszUsername, LPCSTR pszURL,
                                     LPCSTR pszRatingInfo, LPBYTE pData,
                                     DWORD cbData, LPVOID *ppRatingDetails)
{
    HRESULT hRes;
    BOOL    fPassFail;

    g_fInvalid=FALSE;
    g_dwDataSource=cbData;
    g_fPICSRulesEnforced=FALSE;
    g_fApprovedSitesEnforced=FALSE;
    if (pszURL)
        lstrcpy(g_szLastURL,pszURL);

    CheckGlobalInfoRev();

    if (ppRatingDetails != NULL)
        *ppRatingDetails = NULL;

    if (!gPRSI->fSettingsValid)
        return ResultFromScode(S_FALSE);

    if (!gPRSI->fRatingInstalled)
        return ResultFromScode(S_OK);

    PicsUser *pUser = GetUserObject(pszUsername);
    if (pUser == NULL) {
        return HRESULT_FROM_WIN32(ERROR_BAD_USERNAME);
    }

    if (!pUser->fEnabled)
        return ResultFromScode(S_OK);

    //check Approved Sites list
    hRes=PICSRulesCheckApprovedSitesAccess(pszURL,&fPassFail);

    if (SUCCEEDED(hRes)&&!g_fIsRunningUnderCustom) //the list made a determination, skip if Custom
    {
        g_fApprovedSitesEnforced=TRUE;

        if (fPassFail==PR_PASSFAIL_PASS)
        {
            return ResultFromScode(S_OK);
        }
        else
        {
            return ResultFromScode(S_FALSE);
        }
    }

    CParsedLabelList *pParsed=NULL;

    //check PICSRules systems
    hRes=PICSRulesCheckAccess(pszURL,pszRatingInfo,&fPassFail,&pParsed);

    if (SUCCEEDED(hRes)&&!g_fIsRunningUnderCustom) //the list made a determination, skip if Custom
    {
        g_fPICSRulesEnforced=TRUE;

        if (ppRatingDetails != NULL)
            *ppRatingDetails = pParsed;
        else
            FreeParsedLabelList(pParsed);

        if (fPassFail==PR_PASSFAIL_PASS)
        {
            return ResultFromScode(S_OK);
        }
        else
        {
            return ResultFromScode(S_FALSE);
        }
    }

    if (pszRatingInfo == NULL)
    {
        if (pUser->fAllowUnknowns)
        {
            hRes = ResultFromScode(S_OK);
        }
        else
        {
            hRes = ResultFromScode(S_FALSE);
        }

        //Site is unrated.  Check if user can see unrated sites.
        /** Custom **/
        // if notification interface exists, put in the URL
        if ( ( g_fIsRunningUnderCustom || ( hRes != S_OK ) )
                && ( ppRatingDetails != NULL ) )
        {
            if (!pParsed)
            {
                pParsed = new CParsedLabelList;
            }
            if (pParsed)
            {
                ASSERT(!pParsed->m_pszURL);
                pParsed->m_pszURL = new char[strlenf(pszURL) + 1];
                if (pParsed->m_pszURL != NULL)
                {
                    strcpyf(pParsed->m_pszURL, pszURL);
                }

                pParsed->m_fNoRating = TRUE;
                *ppRatingDetails = pParsed;
            }
        }

        return hRes;
    }    
    else
    {
        if (pParsed!=NULL)
        {
            hRes = S_OK;
        }
        else
        {
            hRes = ParseLabelList(pszRatingInfo, &pParsed);
        }
    }

    if (SUCCEEDED(hRes))
    {
        BOOL fRated = FALSE;
        BOOL fDenied = FALSE;

        ASSERT(pParsed != NULL);
        /** Custom **/
        // if notification interface exists, put in the URL
        if (g_fIsRunningUnderCustom)
        {
            ASSERT(!pParsed->m_pszURL);
            pParsed->m_pszURL = new char[strlenf(pszURL) + 1];
            if (pParsed->m_pszURL != NULL)
            {
                strcpyf(pParsed->m_pszURL, pszURL);
            }
        }

        DWORD timeCurrent = GetCurrentNetDate();

        CParsedServiceInfo *psi = &pParsed->m_ServiceInfo;

        while (psi != NULL && !fDenied)
        {
            UserRatingSystem *pURS = pUser->FindRatingSystem(psi->m_pszServiceName);
            if (pURS != NULL && pURS->m_pPRS != NULL)
            {
                psi->m_fInstalled = TRUE;
                UINT cRatings = psi->aRatings.Length();
                for (UINT i=0; i<cRatings; i++)
                {
                    CParsedRating *pRating = &psi->aRatings[i];
                    // YANGXU: 11/17/1999
                    // Do not check the URL if under Custom mode
                    // Checking the URL causes inaccuracies
                    // when a label is returned for an URL on
                    // a page whose server can have two different
                    // DNS entries. We can't just not check because
                    // passing in the URL is part of the published API
                    if (!g_fIsRunningUnderCustom)
                    {
                        if (!pRating->pOptions->CheckURL(pszURL))
                        {
                            pParsed->m_pszURL = new char[strlenf(pszURL) + 1];
                            if (pParsed->m_pszURL != NULL)
                            {
                                strcpyf(pParsed->m_pszURL, pszURL);
                            }

                            continue;    /* this rating has expired or is for
                                         * another URL, ignore it
                                         */
                        }
                    }
                    if (!pRating->pOptions->CheckUntil(timeCurrent))
                        continue;

                    UserRating *pUR = pURS->FindRating(pRating->pszTransmitName);
                    if (pUR != NULL)
                    {
                        fRated = TRUE;
                        pRating->fFound = TRUE;
                        if ((*pUR).m_pPC!=NULL)
                        {
                            if ((pRating->nValue > (*((*pUR).m_pPC)).etnMax.Get())||
                                (pRating->nValue < (*((*pUR).m_pPC)).etnMin.Get()))
                            {
                                g_fInvalid = TRUE;
                                fDenied = TRUE;
                                pRating->fFailed = TRUE;
                            }
                        }
                        if (pRating->nValue > pUR->m_nValue)
                        {
                            fDenied = TRUE;
                            pRating->fFailed = TRUE;
                        }
                        else
                            pRating->fFailed = FALSE;
                    }
                    else
                    {
                        g_fInvalid = TRUE;
                        fDenied = TRUE;
                        pRating->fFailed = TRUE;
                    }
                }
            }
            else
            {
                psi->m_fInstalled = FALSE;
            }

            psi = psi->Next();
        }

        if (!fRated)
        {
            pParsed->m_fRated = FALSE;
            hRes = E_RATING_NOT_FOUND;
        }
        else
        {
            pParsed->m_fRated = TRUE;
            if (fDenied)
                hRes = ResultFromScode(S_FALSE);
        }
    }
    else
    {
        TraceMsg( TF_WARNING, "RatingCheckUserAccess() - ParseLabelList() Failed with hres=0x%x!", hRes );

        // Although the site has invalid PICS rules, the site should still be considered rated.
        hRes = ResultFromScode(S_FALSE);
    }

    StoreRatingDetails( pParsed, ppRatingDetails );

    return hRes;
}

//+-----------------------------------------------------------------------
//
//  Function:  RatingCustomDeleteCrackedData
//
//  Synopsis:  frees the memory of structure returned by RatingCustomCrackData
//
//  Arguments: prbInfo : pointer to RATINGBLOCKINGINFO to be deleted
//
//  Returns:   S_OK if delete successful, E_FAIL otherwise
//
//------------------------------------------------------------------------
HRESULT RatingCustomDeleteCrackedData(RATINGBLOCKINGINFO* prbInfo)
{
    HRESULT hres = E_FAIL;
    RATINGBLOCKINGLABELLIST* prblTemp = NULL;
    
    if (NULL != prbInfo)
    {
        if (prbInfo->pwszDeniedURL)
        {
            delete [] prbInfo->pwszDeniedURL;
            prbInfo->pwszDeniedURL = NULL;
        }
        if (prbInfo->prbLabelList)
        {
            for (UINT j = 0; j < prbInfo->cLabels; j++)
            {
                prblTemp = &prbInfo->prbLabelList[j];
                if (prblTemp->pwszRatingSystemName)
                {
                    delete [] prblTemp->pwszRatingSystemName;
                    prblTemp->pwszRatingSystemName = NULL;
                }
                if (prblTemp->paRBLS)
                {
                    for (UINT i = 0; i < prblTemp->cBlockingLabels; i++)
                    {
                        if (prblTemp->paRBLS[i].pwszCategoryName)
                        {
                            delete [] prblTemp->paRBLS[i].pwszCategoryName;
                            prblTemp->paRBLS[i].pwszCategoryName = NULL;
                        }
                        if (prblTemp->paRBLS[i].pwszTransmitName)
                        {
                            delete [] prblTemp->paRBLS[i].pwszTransmitName;
                            prblTemp->paRBLS[i].pwszTransmitName = NULL;
                        }
                        if (prblTemp->paRBLS[i].pwszValueName)
                        {
                            delete [] prblTemp->paRBLS[i].pwszValueName;
                            prblTemp->paRBLS[i].pwszValueName = NULL;
                        }
                    }

                    delete [] prblTemp->paRBLS;
                    prblTemp->paRBLS = NULL;
                }
            }

            delete [] prbInfo->prbLabelList;
            prbInfo->prbLabelList = NULL;
        }
        if (prbInfo->pwszRatingHelperName)
        {
            delete [] prbInfo->pwszRatingHelperName;
            prbInfo->pwszRatingHelperName = NULL;
        }

        hres = S_OK;
        if (prbInfo->pwszRatingHelperReason)
        {
            delete [] prbInfo->pwszRatingHelperReason;
            prbInfo->pwszRatingHelperReason = NULL;
        }

        delete prbInfo;
        prbInfo = NULL;
    }

    return hres;
}

HRESULT _CrackCategory(CParsedRating *pRating,
                       RATINGBLOCKINGCATEGORY *pRBLS,
                       UserRatingSystem* pURS)
{
    UserRating *pUR = pURS->FindRating(pRating->pszTransmitName);
    if (pUR)
    {
        //
        //  Mutated code from InitPleaseDialog, hope it works
        //
        PicsCategory* pPC = pUR->m_pPC;
        if (pPC)
        {
            pRBLS->nValue = pRating->nValue;

            Ansi2Unicode(&pRBLS->pwszTransmitName, pRating->pszTransmitName);
        
            LPCSTR pszCategory = NULL;

            if (pPC->etstrName.fIsInit())
            {
                pszCategory = pPC->etstrName.Get();
            }
            else if (pPC->etstrDesc.fIsInit())
            {
                pszCategory = pPC->etstrDesc.Get();
            }
            else
            {
                pszCategory = pRating->pszTransmitName;
            }

            Ansi2Unicode(&pRBLS->pwszCategoryName, pszCategory);

            UINT cValues = pPC->arrpPE.Length();
            PicsEnum *pPE;

            for (UINT iValue=0; iValue < cValues; iValue++)
            {
                pPE = pPC->arrpPE[iValue];
                if (pPE->etnValue.Get() == pRating->nValue)
                {
                    break;
                }
            }

            LPCSTR pszValue = NULL;
            if (iValue < cValues)
            {
                if (pPE->etstrName.fIsInit())
                {
                    pszValue = pPE->etstrName.Get();
                }
                else if (pPE->etstrDesc.fIsInit())
                {
                    pszValue = pPE->etstrDesc.Get();
                }

                Ansi2Unicode(&pRBLS->pwszValueName, pszValue);
            }
        }
    }
    
    return S_OK;
}

//+-----------------------------------------------------------------------
//
//  Function:  RatingCustomCrackData
//
//  Synopsis:  packages the persistent, opaque data describing why a site
//             was denied into readable form
//
//  Arguments: pszUsername : name of the user
//             pRatingDetails : pointer to the opaque data
//             pprbInfo : a RATINGBLOCKINGINFO representation of the data
//
//  Returns:   Success if data packaged
//
//------------------------------------------------------------------------
HRESULT RatingCustomCrackData(LPCSTR pszUsername, void* pvRatingDetails, RATINGBLOCKINGINFO** pprbInfo) {

    if(NULL != *pprbInfo)
    {
        return E_INVALIDARG;
    }

    RATINGBLOCKINGINFO* prbInfo = new RATINGBLOCKINGINFO;
    CParsedLabelList *pRatingDetails = (CParsedLabelList*)pvRatingDetails;
    if (!prbInfo)
    {
        return E_OUTOFMEMORY;
    }
    prbInfo->pwszDeniedURL = NULL;
    prbInfo->rbSource = RBS_ERROR;
    prbInfo->rbMethod = RBM_UNINIT;
    prbInfo->cLabels = 0;
    prbInfo->prbLabelList = NULL;
    prbInfo->pwszRatingHelperName = NULL;
    prbInfo->pwszRatingHelperReason = NULL;
    
    RATINGBLOCKINGLABELLIST* prblTemp = NULL;
    RATINGBLOCKINGLABELLIST* prblPrev = NULL;


    if (!g_fInvalid)
    {
        if (g_fIsRunningUnderCustom)
        {
            // pRatingDetails should not be NULL unless
            // we ran out of memory
            ASSERT(pRatingDetails);
            
            if (pRatingDetails->m_pszURL)
            {
                Ansi2Unicode(&prbInfo->pwszDeniedURL, pRatingDetails->m_pszURL);
            }
            if (pRatingDetails->m_fRated)
            {
                // The page can be rated or denied, but not both
                ASSERT(!pRatingDetails->m_fDenied);
                ASSERT(!pRatingDetails->m_fNoRating);
                
                prbInfo->rbMethod = RBM_LABEL;
                PicsUser* pPU = GetUserObject(pszUsername);
                if (pPU)
                {
                    // first find out how many systems there are
                    UINT cLabels =  0;
                    CParsedServiceInfo *ppsi = &pRatingDetails->m_ServiceInfo;
                    while (ppsi)
                    {
                        cLabels++;
                        ppsi = ppsi->Next();
                    }
                    // should have at least one label
                    ASSERT(cLabels > 0);
                    prbInfo->prbLabelList = new RATINGBLOCKINGLABELLIST[cLabels];

                    if (prbInfo->prbLabelList)
                    {
                        UINT iLabel = 0;
                        for (ppsi = &pRatingDetails->m_ServiceInfo;ppsi;ppsi = ppsi->Next())
                        {
                            if (!ppsi->m_fInstalled)
                            {
                                continue;
                            }
                            UserRatingSystem* pURS = pPU->FindRatingSystem(ppsi->m_pszServiceName);
                            if (NULL == pURS || NULL == pURS->m_pPRS)
                            {
                                continue;
                            }

                            prblTemp = &(prbInfo->prbLabelList[iLabel]);
                            
                            Ansi2Unicode(&prblTemp->pwszRatingSystemName, pURS->m_pPRS->etstrName.Get());
                            
                            UINT cRatings = ppsi->aRatings.Length();
                            prblTemp->paRBLS = new RATINGBLOCKINGCATEGORY[cRatings];
                            if (prblTemp->paRBLS == NULL)
                            {
                                RatingCustomDeleteCrackedData(prbInfo);
                                return E_OUTOFMEMORY;
                            } // if (prblTemp->paRBLS == NULL)
                            prblTemp->cBlockingLabels = cRatings;
                            
                            for (UINT i=0; i < cRatings; i++)
                            {
                                CParsedRating *pRating = &ppsi->aRatings[i];
                                RATINGBLOCKINGCATEGORY* pRBLS = &prblTemp->paRBLS[i];
                                _CrackCategory(pRating, pRBLS, pURS);
                            } // for (UINT i=0; i < cRatings; i++)

                            // at this point, we should have valid ratings for
                            // a system
                            iLabel++;
                        } // for (ppsi = &pRatingDetails->m_ServiceInfo;ppsi;ppsi = ppsi->Next())
                        prbInfo->cLabels = iLabel;
                    } // if (prbInfo->prbLabelList)
                    else
                    {
                        RatingCustomDeleteCrackedData(prbInfo);
                        return E_OUTOFMEMORY;
                    }
                    if (!pRatingDetails->m_fIsHelper)
                    {
                       prbInfo->rbSource = RBS_PAGE;
                    }
                    else
                    {
                        if (pRatingDetails->m_fIsCustomHelper)
                        {
                            prbInfo->rbSource = RBS_CUSTOM_RATING_HELPER;
                            if (pRatingDetails->m_pszRatingName)
                            {
                                Ansi2Unicode(&prbInfo->pwszRatingHelperName, pRatingDetails->m_pszRatingName);
                            }
                            if (pRatingDetails->m_pszRatingReason)
                            {
                                Ansi2Unicode(&prbInfo->pwszRatingHelperReason, pRatingDetails->m_pszRatingReason);
                            }
                        }
                        else
                        {
                            prbInfo->rbSource = RBS_RATING_HELPER;
                        }
                    }
                }
            } // if (pRatingDetails->m_fRated)
            else
            {
                if (pRatingDetails->m_fDenied)
                {
                    prbInfo->rbMethod = RBM_DENY;
                    if (!pRatingDetails->m_fIsHelper)
                    {
                       prbInfo->rbSource = RBS_PAGE;
                    }
                    else
                    {
                        if (pRatingDetails->m_fIsCustomHelper)
                        {
                            prbInfo->rbSource = RBS_CUSTOM_RATING_HELPER;
                        }
                        else
                        {
                            prbInfo->rbSource = RBS_RATING_HELPER;
                        }
                    }
                }
                else
                {
                    if (pRatingDetails->m_fNoRating)
                    {
                        prbInfo->rbSource = RBS_NO_RATINGS;
                    }
                }
            }
        } // if (g_fIsRunningUnderCustom)
        else
        {
            prbInfo->rbMethod = RBM_ERROR_NOT_IN_CUSTOM_MODE;
        }
    } // (!g_fInvalid)
    *pprbInfo = prbInfo;
    return S_OK;
}

HRESULT WINAPI RatingAccessDeniedDialog(HWND hDlg, LPCSTR pszUsername, LPCSTR pszContentDescription, LPVOID pRatingDetails)
{
    HRESULT hres;

    PleaseDlgData pdd;

    pdd.pszUsername = pszUsername;
    pdd.pPU = GetUserObject(pszUsername);
    if (pdd.pPU == NULL)
    {
        TraceMsg( TF_WARNING, "RatingAccessDeniedDialog() - Username is not valid!" );
        return HRESULT_FROM_WIN32(ERROR_BAD_USERNAME);
    }

    pdd.pszContentDescription = pszContentDescription;
    pdd.pLabelList = (CParsedLabelList *)pRatingDetails;
    pdd.hwndEC = NULL;
    pdd.dwFlags = 0;
    pdd.hwndDlg = NULL;
    pdd.hwndOwner = hDlg;
    pdd.cLabels = 0;

    CPleaseDialog           pleaseDialog( &pdd );

    if ( pleaseDialog.DoModal( hDlg ) )
    {
        hres = ResultFromScode(S_OK);
    }
    else
    {
        hres = ResultFromScode(S_FALSE);
    }

    for (UINT i=0; i<pdd.cLabels; i++)
    {
        delete pdd.apLabelStrings[i];
        pdd.apLabelStrings[i] = NULL;
    }
    
    return hres;
}

HRESULT WINAPI RatingAccessDeniedDialog2(HWND hwndParent, LPCSTR pszUsername, LPVOID pRatingDetails)
{
    PleaseDlgData *ppdd = (PleaseDlgData *)GetProp( hwndParent, szRatingsProp );
    if (ppdd == NULL)
    {
        return RatingAccessDeniedDialog( hwndParent, pszUsername, NULL, pRatingDetails );
    }

    HWND            hwndDialog = ppdd->hwndDlg;

    ASSERT( hwndDialog );

    ppdd->pLabelList = (CParsedLabelList *)pRatingDetails;

    SendMessage( hwndDialog, WM_NEWDIALOG, 0, (LPARAM)ppdd );

    // The ppdd is only valid during the RatingAccessDeniedDialog() scope!!
    ppdd = NULL;

    // $REVIEW - Should we use a Windows Hook instead of looping to wait for the
    //      modal dialog box to complete?
    // $CLEANUP - Use a CMessageLoop instead.

    // Property is removed once the modal dialog is toasted.
    while ( ::IsWindow( hwndParent ) && ::GetProp( hwndParent, szRatingsProp ) )
    {
        MSG msg;

        if ( PeekMessage( &msg, NULL, 0, 0, PM_NOREMOVE ) )
        {
            if ( GetMessage( &msg, NULL, 0, 0 ) > 0 )
//              && !IsDialogMessage(ppdd->hwndDlg, &msg)) {
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
        }
        else
        {
            ::Sleep( 100 );     // Empty message queue means check again in 100 msecs
        }
    }

    DWORD           dwFlags;

    dwFlags = ::IsWindow( hwndParent ) ? PtrToUlong( GetProp( hwndParent, szRatingsValue ) ) : PDD_DONE;

    TraceMsg( TF_ALWAYS, "RatingAccessDeniedDialog2() - Message Loop exited with dwFlags=%d", dwFlags );

    return ( dwFlags & PDD_ALLOW ) ? S_OK : S_FALSE;
}

HRESULT WINAPI RatingFreeDetails(LPVOID pRatingDetails)
{
    if (pRatingDetails)
    {
        FreeParsedLabelList((CParsedLabelList *)pRatingDetails);
    }

    return NOERROR;
}