CSingletonLDAPConnection.cpp

Go to the documentation of this file.

#include "CSingletonLDAPConnection.h"
#include "HttpServerBlacklist.h"
#include "LDAP_URL_Header.h"
#include "CLDAPConnectionInfo.h"
#include "PKIFTime.h"
#include "Duration.h"
#include <cctype>

#include <vector>
#include <string>
#include <map>
using namespace std;



const int g_maxAutoBlacklistEntries = 100;
const int g_numSecondsToLive = 300;
std::vector<std::string> g_blacklistedServers;
std::map<std::string, CPKIFTimePtr> g_autoBlacklistedServers;


void CAC_API PKIFLDAP::AddBlacklistedServer(
    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_blacklistedServers.end() == find(g_blacklistedServers.begin(), g_blacklistedServers.end(), copyOfServer))
            g_blacklistedServers.push_back(copyOfServer);
    }
    else
    {
        if(g_maxAutoBlacklistEntries < g_autoBlacklistedServers.size())
        {
            CPKIFDuration d;
            d.setSeconds(g_numSecondsToLive);

            //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_autoBlacklistedServers.end();
            for(pos = g_autoBlacklistedServers.begin(); pos != end; ++pos)
            {
                if(*lowerThreshold > *(*pos).second)
                    g_autoBlacklistedServers.erase(pos);
            }

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

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

void CAC_API PKIFLDAP::RemoveBlacklistedServer(
    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_blacklistedServers.begin(),g_blacklistedServers.end(),copyOfServer);
    if(g_blacklistedServers.end() != found)
        g_blacklistedServers.erase(found);

    g_autoBlacklistedServers.erase(copyOfServer);
}

bool CAC_API PKIFLDAP::IsBlacklisted(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_blacklistedServers.end() != find(g_blacklistedServers.begin(), g_blacklistedServers.end(), copyOfServer);
    if(g_autoBlacklistedServers.end() != g_autoBlacklistedServers.find(copyOfServer))
    {
        CPKIFTimePtr time = g_autoBlacklistedServers[copyOfServer];
        CPKIFDuration d;
        d.setSeconds(g_numSecondsToLive);

        CPKIFTimePtr curTime = CPKIFTime::CurrentTime();
        *curTime -= d;
        if(*time > *curTime)
            bTemporarilyBlacklisted = true;
        else
            g_autoBlacklistedServers.erase(copyOfServer);
    }
    
    std::string host;
    GetHostFromUri(copyOfServer.c_str(), host);

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

void CAC_API PKIFLDAP::ClearServerBlacklist(void)
{
    g_blacklistedServers.clear();
    g_autoBlacklistedServers.clear();
}

void CAC_API PKIFLDAP::GetServerBlacklist(std::vector<std::string> & bl)
{
    bl = g_blacklistedServers;

    CPKIFDuration d;
    d.setSeconds(g_numSecondsToLive);

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

    std::map<std::string, CPKIFTimePtr>::iterator pos;
    std::map<std::string, CPKIFTimePtr>::iterator end = g_autoBlacklistedServers.end();
    for(pos = g_autoBlacklistedServers.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);
        }
    }
}

CSingletonLDAPConnection::CSingletonLDAPConnection()
{
}
CSingletonLDAPConnection* CSingletonLDAPConnection::Instance()
{
    if(!m_instance)
    {
        m_instance = new CSingletonLDAPConnection();
    }

    return m_instance;
}
CSingletonLDAPConnection::~CSingletonLDAPConnection()
{
    std::vector<CLDAPConnectionInfo*>::iterator pos;
    std::vector<CLDAPConnectionInfo*>::iterator end = m_ldaps.end();

    for(pos = m_ldaps.begin(); pos != end; ++pos)
    {
        if(NULL != (*pos)->m_connection)
        ldap_unbind((*pos)->m_connection);
        delete *pos;
    }
    
}
void CSingletonLDAPConnection::PushConnection(
    std::string& host, 
    int port, 
    LDAP* ldap)
{
    std::vector<CLDAPConnectionInfo*>::iterator pos;
    std::vector<CLDAPConnectionInfo*>::iterator end = m_ldaps.end();

    for(pos = m_ldaps.begin(); pos != end; ++pos)
    {
        if(host == (*pos)->m_host && port == (*pos)->m_port)
            return;
    }

    CLDAPConnectionInfo* p = new CLDAPConnectionInfo();
    p->m_host = host;
    p->m_port = port;
    p->m_connection = ldap;
    m_ldaps.push_back(p);
}

LDAP* CSingletonLDAPConnection::GetConnection(
    std::string& host, 
    int port)
{
    std::vector<CLDAPConnectionInfo*>::iterator pos;
    std::vector<CLDAPConnectionInfo*>::iterator end = m_ldaps.end();
    for(pos = m_ldaps.begin(); pos != end; ++pos)
    {
        if(host == (*pos)->m_host && port == (*pos)->m_port)
            return (*pos)->m_connection;
    }
    return NULL;
}
void CSingletonLDAPConnection::CSingletonLDAPConnectionDestructor()
{
    if(m_instance) {
        delete m_instance;
        m_instance = 0;
    }
}

class CSingletonLDAPConnectionCleaner
{
    public:
        ~CSingletonLDAPConnectionCleaner()
        {
            CSingletonLDAPConnection::CSingletonLDAPConnectionDestructor();
        }
} CSingletonLDAPConnectionCleanerInstance;