HttpServerBlacklist.cpp

Go to the documentation of this file.

#include "PKIFdll.h"

#include "PKIFTime.h"
#include "Duration.h"
#include "HttpServerBlacklist.h"
#include <cctype>

#include "LDAP_URL_Header.h"

#include <vector>
#include <string>
#include <map>

#include <boost/numeric/conversion/cast.hpp>

using namespace std;

const int g_maxAutoHttpBlacklistEntries = 100;
const int g_numSecondsToLiveInHttpBlacklist = 300;
std::vector<std::string> g_blacklistedHttpServers;
std::map<std::string, CPKIFTimePtr> g_autoHttpBlacklistedServers;

void GetHostFromUri(const char* url_in, std::string& hostOut)
{
    hostOut.clear();

    int inLen = 0;
    try {
        inLen = boost::numeric_cast<int,size_t>(strlen(url_in));
    }catch(boost::numeric::bad_numeric_cast &){
        // malformed
        return;
    }
    char* name = new char[inLen];
    if(!name) return;
    char* path = new char[inLen];
    if(!path) return;
    char protostr[16];
    if((2 == sscanf(url_in, "%15[^:]:%[^\n]",
                  protostr,
                  path)) && 0 == stricmp(protostr, "file"))
    {
        //do nothing - file URI
    }
    else
    {
        if (2 > sscanf(url_in,
                       "%15[^\n:]://%[^\n/]%[^\n]",
                       protostr,
                       name, path)) 
        {
            //do nothing - malformed
        }
        else
        {
            hostOut = name;
        }
    }
    delete[] name;
    delete[] path;
}

void CAC_API PKIFHTTP::AddBlacklistedHttpServer(
    std::string& server, 
    bool bPermanent)
{
    if(server == "")
        return;
    std::string copyOfServer = server;
    std::transform(copyOfServer.begin(), copyOfServer.end(), copyOfServer.begin(), (int(*)(int)) std::toupper);
    if(bPermanent)
    {
        if(g_blacklistedHttpServers.end() == find(g_blacklistedHttpServers.begin(), g_blacklistedHttpServers.end(), copyOfServer))
            g_blacklistedHttpServers.push_back(copyOfServer);
    }
    else
    {
        if(g_maxAutoHttpBlacklistEntries < g_autoHttpBlacklistedServers.size())
        {
            CPKIFDuration d;
            d.setSeconds(g_numSecondsToLiveInHttpBlacklist);

            //first try removing old entries
            CPKIFTimePtr lowerThreshold = CPKIFTime::CurrentTime();
            *lowerThreshold -= d;

            std::map<std::string, CPKIFTimePtr >::iterator pos;
            std::map<std::string, CPKIFTimePtr >::iterator end = g_autoHttpBlacklistedServers.end();
            for(pos = g_autoHttpBlacklistedServers.begin(); pos != end; ++pos)
            {
                if(*lowerThreshold > *(*pos).second)
                    g_autoHttpBlacklistedServers.erase(pos);
            }

            if(g_maxAutoHttpBlacklistEntries < g_autoHttpBlacklistedServers.size())
            {
                //failing that, simply remove 10% of the store
                int numToRemove = g_maxAutoHttpBlacklistEntries/10;
                for(int ii = 0; ii < numToRemove; ++ii)
                {
                    std::string serverToErase = (*g_autoHttpBlacklistedServers.begin()).first;
                    g_autoHttpBlacklistedServers.erase(serverToErase);
                }   
            }
        }

        //If the server isn't in the map, add it.  If it is, update the time
        g_autoHttpBlacklistedServers[copyOfServer] = CPKIFTime::CurrentTime();
    }
}

void CAC_API PKIFHTTP::RemoveBlacklistedHttpServer(
    std::string& server)
{
    std::string copyOfServer = server;
    std::transform(copyOfServer.begin(), copyOfServer.end(), copyOfServer.begin(), (int(*)(int)) std::toupper);

    std::vector<std::string>::iterator found = find(g_blacklistedHttpServers.begin(),g_blacklistedHttpServers.end(),copyOfServer);
    if(g_blacklistedHttpServers.end() != found)
        g_blacklistedHttpServers.erase(found);

    g_autoHttpBlacklistedServers.erase(copyOfServer);
}

bool CAC_API PKIFHTTP::IsHttpServerBlacklisted(std::string& server)
{
    std::string copyOfServer = server;
    std::transform(copyOfServer.begin(), copyOfServer.end(), copyOfServer.begin(), (int(*)(int)) std::toupper);

    bool bTemporarilyBlacklisted = false;
    bool bPermanentlyBlacklisted = g_blacklistedHttpServers.end() != find(g_blacklistedHttpServers.begin(), g_blacklistedHttpServers.end(), copyOfServer);
    if(g_autoHttpBlacklistedServers.end() != g_autoHttpBlacklistedServers.find(copyOfServer))
    {
        CPKIFTimePtr time = g_autoHttpBlacklistedServers[copyOfServer];
        CPKIFDuration d;
        d.setSeconds(g_numSecondsToLiveInHttpBlacklist);

        CPKIFTimePtr curTime = CPKIFTime::CurrentTime();
        *curTime -= d;
        if(*time > *curTime)
            bTemporarilyBlacklisted = true;
        else
            g_autoHttpBlacklistedServers.erase(copyOfServer);
    }

    std::string host;
    GetHostFromUri(copyOfServer.c_str(), host);

    if(host == copyOfServer || host.empty())
        return bPermanentlyBlacklisted || bTemporarilyBlacklisted;
    else
        return IsHttpServerBlacklisted(host);
}

void CAC_API PKIFHTTP::ClearHttpServerBlacklist(void)
{
    g_blacklistedHttpServers.clear();
    g_autoHttpBlacklistedServers.clear();
}

void CAC_API PKIFHTTP::GetHttpServerBlacklist(std::vector<std::string> & bl)
{
    bl = g_blacklistedHttpServers;

    CPKIFDuration d;
    d.setSeconds(g_numSecondsToLiveInHttpBlacklist);

    CPKIFTimePtr curTime = CPKIFTime::CurrentTime();
    *curTime -= d;

    std::map<std::string, CPKIFTimePtr>::iterator pos;
    std::map<std::string, CPKIFTimePtr>::iterator end = g_autoHttpBlacklistedServers.end();
    for(pos = g_autoHttpBlacklistedServers.begin(); pos != end; ++pos)
    {
        if((*pos).second != (CPKIFTime*)NULL &&
            *(*pos).second > *curTime)
        {
            if(bl.end() == find(bl.begin(), bl.end(), (*pos).first))
                bl.push_back((*pos).first);
        }
    }
}