PKIFSupportsSynonymousSources.cpp

Go to the documentation of this file.

#include "PKIFdll.h"
#include "PKIFCertificateNodeEntry.h"
#include "PKIFCRLNodeEntry.h"
#include "IPKIFSupportsSynonymousSources.h"
#include "LDAP_URL_Header.h"

#include <cctype>

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

IPKIFSupportsSynonymousCRLSources::IPKIFSupportsSynonymousCRLSources()
{
}

IPKIFSupportsSynonymousCRLSources::~IPKIFSupportsSynonymousCRLSources()
{
}

IPKIFSupportsSynonymousCertSources::IPKIFSupportsSynonymousCertSources()
{
}

IPKIFSupportsSynonymousCertSources::~IPKIFSupportsSynonymousCertSources()
{
}

class UriMatch
{
public:
    bool operator()(const std::string& t)
    {
        if(t == m_rhs)
            return true;
        else
        {
            std::string copyOfT = t;
            std::transform(copyOfT.begin(), copyOfT.end(), copyOfT.begin(), (int(*)(int)) std::toupper);
            if(0 == copyOfT.find("LDAP") && 0 == m_rhs.find("LDAP"))
            {
                PKIFLDAP::LDAPURLDesc *ldapInfoUri = NULL;
                PKIFLDAP::ldap_url_parse(copyOfT.c_str(), &ldapInfoUri);

                PKIFLDAP::LDAPURLDesc *ldapInfoRhs = NULL;
                PKIFLDAP::ldap_url_parse(m_rhs.c_str(), &ldapInfoRhs);
                if(!ldapInfoRhs || !ldapInfoUri)
                    return false;

                bool retVal = true; 
                if(ldapInfoUri->lud_port != ldapInfoRhs->lud_port)
                    retVal = false;

                //need to account for URIs that begin ///
                if((ldapInfoUri->lud_host && !ldapInfoRhs->lud_host) || (!ldapInfoUri->lud_host && ldapInfoRhs->lud_host))
                    return false;

                if(0 != stricmp(ldapInfoUri->lud_host, ldapInfoRhs->lud_host))
                    retVal = false;

                if(0 != stricmp(ldapInfoUri->lud_dn, ldapInfoRhs->lud_dn))
                    retVal = false;
/*
                bool match = true;

                for(int ii = 0; NULL != ldapInfoRhs->lud_attrs[ii]; ++ii)
                {
                    for(int jj = 0; NULL != ldapInfoUri->lud_attrs[jj]; ++jj)
                    {
                        if(0 != stricmp(ldapInfoRhs->lud_attrs[ii], ldapInfoUri->lud_attrs[jj]))
                            match = false;
                        else
                        {
                            match = true;
                            break;
                        }
                    }
                    if(!match)
                        break;
                }

                retVal = match;
*/
                PKIFLDAP::ldap_free_urldesc( ldapInfoUri );
                PKIFLDAP::ldap_free_urldesc( ldapInfoRhs );
                return retVal;
            }
        }

        return false;
    }

    void SetRHS(const std::string& rhs) 
    {
        m_rhs = rhs;
        std::transform(m_rhs.begin(), m_rhs.end(), m_rhs.begin(), (int(*)(int)) std::toupper);
    }
private:
    std::string m_rhs;
};

bool UriAlreadyInList(CPKIFCrlSourceList& list, std::string& uri)
{
    CPKIFCrlSourceList::iterator pos;
    CPKIFCrlSourceList::iterator end = list.end();
    for(pos = list.begin(); pos != end; ++pos)
    {
        std::vector<std::string> sources;
        (*pos)->GetSources(sources);

        UriMatch uriMatch;
        uriMatch.SetRHS(uri);

        if(sources.end() != find_if(sources.begin(), sources.end(), uriMatch))
            return true;
    }
    return false;
}

bool UriAlreadyInList(CPKIFCertificateSourceList& list, std::string& uri)
{
    CPKIFCertificateSourceList::iterator pos;
    CPKIFCertificateSourceList::iterator end = list.end();
    for(pos = list.begin(); pos != end; ++pos)
    {
        std::vector<std::string> sources;
        (*pos)->GetSources(sources);

        UriMatch uriMatch;
        uriMatch.SetRHS(uri);

        if(sources.end() != find_if(sources.begin(), sources.end(), uriMatch))
            return true;
    }
    return false;
}