Example #1
0
void CWebCore::LoadListsFromXML ( bool bWhitelist, bool bBlacklist, bool bCustomLists )
{
    if ( !m_pXmlConfig )
        return;

    CXMLNode* pRootNode = m_pXmlConfig->GetRootNode ();
    if ( !pRootNode )
        return;

    if ( bWhitelist )
    {
        CXMLNode* pWhiteSubNode = pRootNode->FindSubNode ( "globalwhitelist" );
        if ( pWhiteSubNode )
        {
            for ( std::list<CXMLNode*>::iterator iter = pWhiteSubNode->ChildrenBegin (); iter != pWhiteSubNode->ChildrenEnd (); ++iter )
            {
                AddAllowedPage ( (*iter)->GetTagContent (), eWebFilterType::WEBFILTER_DYNAMIC );
            }
        }
    }
    
    if ( bBlacklist )
    {
        CXMLNode* pBlackSubNode = pRootNode->FindSubNode ( "globalblacklist" );
        if ( pBlackSubNode )
        {
            for ( std::list<CXMLNode*>::iterator iter = pBlackSubNode->ChildrenBegin (); iter != pBlackSubNode->ChildrenEnd (); ++iter )
            {
                AddBlockedPage ( (*iter)->GetTagContent (), eWebFilterType::WEBFILTER_DYNAMIC );
            }
        }
    }

    if ( bCustomLists )
    {
        CXMLNode* pBlackSubNode = pRootNode->FindSubNode ( "customblacklist" );
        if ( pBlackSubNode )
        {
            for ( std::list<CXMLNode*>::iterator iter = pBlackSubNode->ChildrenBegin (); iter != pBlackSubNode->ChildrenEnd (); ++iter )
            {
                AddBlockedPage ( (*iter)->GetTagContent (), eWebFilterType::WEBFILTER_USER );
            }
        }
        CXMLNode* pWhiteSubNode = pRootNode->FindSubNode ( "customwhitelist" );
        if ( pWhiteSubNode )
        {
            for ( std::list<CXMLNode*>::iterator iter = pWhiteSubNode->ChildrenBegin (); iter != pWhiteSubNode->ChildrenEnd (); ++iter )
            {
                AddAllowedPage ( (*iter)->GetTagContent (), eWebFilterType::WEBFILTER_USER );
            }
        }
    }
}
Example #2
0
void CWebCore::InitialiseWhiteAndBlacklist ( bool bAddHardcoded, bool bAddDynamic )
{
    if ( bAddDynamic )
    {
        // Hardcoded whitelist
        static SString whitelist[] = { 
            "google.com", "youtube.com", "www.youtube-nocookie.com", "vimeo.com", "player.vimeo.com", "code.jquery.com",
            "myvideo.com", "mtasa.com", "multitheftauto.com", "mtavc.com", "www.googleapis.com", "ajax.googleapis.com",
        };

        // Hardcoded blacklist
        static SString blacklist[] = { "nobrain.dk" };

        // Blacklist or whitelist URLs now
        for ( unsigned int i = 0; i < sizeof(whitelist) / sizeof(SString); ++i )
        {
            AddAllowedPage ( whitelist[i], eWebFilterType::WEBFILTER_HARDCODED );
        }
        for ( unsigned int i = 0; i < sizeof(blacklist) / sizeof(SString); ++i )
        {
            AddBlockedPage ( blacklist[i], eWebFilterType::WEBFILTER_HARDCODED );
        }
    }

    // Load dynamic and custom blacklist from XML config
    if ( bAddDynamic )
        LoadListsFromXML ( true, true, true );
}
Example #3
0
void CWebCore::AllowPendingPages ( bool bRemember )
{
    for ( const auto& request : m_PendingRequests )
    {
        AddAllowedPage ( request, !bRemember ? eWebFilterType::WEBFILTER_REQUEST : eWebFilterType::WEBFILTER_USER );
    }

    // Trigger an event now
    auto pCurrentMod = CModManager::GetSingleton ().GetCurrentMod ();
    if ( !pCurrentMod )
        return;

    pCurrentMod->WebsiteRequestResultHandler ( m_PendingRequests );
    m_PendingRequests.clear ();

    if ( bRemember )
    {
        std::vector<std::pair<SString, bool>> result; // Contains only allowed entries
        CCore::GetSingleton ().GetWebCore ()->GetFilterEntriesByType ( result, eWebFilterType::WEBFILTER_USER, eWebFilterState::WEBFILTER_ALLOWED );
        std::vector<SString> customWhitelist;
        for ( std::vector<std::pair<SString, bool>>::iterator iter = result.begin (); iter != result.end (); ++iter )
            customWhitelist.push_back ( iter->first );

        WriteCustomList ( "customwhitelist", customWhitelist, false );
    }
}
Example #4
0
std::unordered_set<SString> CWebCore::AllowPendingPages ( bool bRemember )
{
    for ( const auto& request : m_PendingRequests )
    {
        AddAllowedPage ( request, !bRemember ? eWebFilterType::WEBFILTER_REQUEST : eWebFilterType::WEBFILTER_USER );
    }

    // Trigger an event now
    auto pCurrentMod = g_pCore->GetModManager ()->GetCurrentMod ();
    if ( !pCurrentMod )
        return std::unordered_set<SString>();

    pCurrentMod->WebsiteRequestResultHandler ( m_PendingRequests );

    if ( bRemember )
    {
        std::vector<std::pair<SString, bool>> result; // Contains only allowed entries
        g_pCore->GetWebCore ()->GetFilterEntriesByType ( result, eWebFilterType::WEBFILTER_USER, eWebFilterState::WEBFILTER_ALLOWED );
        std::vector<SString> customWhitelist;
        for ( std::vector<std::pair<SString, bool>>::iterator iter = result.begin (); iter != result.end (); ++iter )
            customWhitelist.push_back ( iter->first );

        WriteCustomList ( "customwhitelist", customWhitelist, false );
    }

    auto allowedRequests(std::move(m_PendingRequests));
    m_PendingRequests.clear(); // MSVC's move constructor already clears the list which isn't specified by the C++ standard though

    return allowedRequests;
}