Name.cpp

Go to the documentation of this file.

#include "Name.h"
#include "Buffer.h"
#include "ASN1Helper.h"
#include "PKIX1Explicit88.h"
#include "ToolkitUtils.h"
#include "OID.h"
#include "DistributionPointName.h"


//NOTE - this definition is also copied into DistributionPointName.cpp to help with relToIssuer processing
struct CPKIFNameImpl
{
    CACX509V3Name* m_name;
    CPKIFStringPtr m_string;
    CPKIFBufferPtr m_encodedName; //added 8/26/2004
};


CPKIFName::CPKIFName()
:m_impl(new CPKIFNameImpl)
{
    LOG_STRING_DEBUG("CPKIFName::CPKIFName()", TOOLKIT_X509_ASN, 0, this);

    m_impl->m_name = NULL;
}
//CPKIFName::CPKIFName(
//  //![in] Reference to a CACX509V3Name structure containing information used to populate an instance of CPKIFName              
//  const CACX509V3Name& name)
//  :m_impl(new CPKIFNameImpl)
//{
//  LOG_STRING_DEBUG("CPKIFName::CPKIFName(const CACX509V3Name&)", TOOLKIT_X509_ASN, 0, this);
//
//  //if the name is empty set the m_impl->m_name to NULL and return
//  if(NULL == name.u.rdnSequence || 0 == name.t)
//  {
//      m_impl->m_name = NULL;
//      return;
//  }
//
//  //otherwise - create a copy of the name structure
//  m_impl->m_name = new CACX509V3Name;
//  m_impl->m_name->t = name.t;
//
//  m_impl->m_name->u.rdnSequence = new CACX509V3RDNSequence;
//  m_impl->m_name->u.rdnSequence->head = NULL; m_impl->m_name->u.rdnSequence->tail = NULL; //added this line 4/28/2004
//  m_impl->m_name->u.rdnSequence->count = 0;
//
//  DListNode* cur = NULL, *cur2 = name.u.rdnSequence->head;
//  ASN1OpenType* tmp = NULL, *tmp2 = NULL;
//  
//  //iterate over all of the RDN elements in the name passed as a parameter
//  for(unsigned int ii = 0; ii < name.u.rdnSequence->count; ++ii)
//  {
//      if(NULL == cur)
//      {
//          NEW_NODE(cur)
//      }
//      else
//      {
//          NEW_NEXT_AND_ADVANCE(cur)
//      }
//
//      //create an ASN1OpenType to hold the data
//      //use tmp2 as a temporary pointer to the actual value to copy
//      tmp = new ASN1OpenType;
//      tmp2 = (ASN1OpenType*)cur2->data;
//      
//      //save the length, allocate a buffer and copy the data
//      //throw bad_alloc
//      tmp->numocts = tmp2->numocts;
//      tmp->data = new unsigned char[tmp->numocts];
//      memcpy((void*)tmp->data, tmp2->data, tmp->numocts);
//
//      cur->data = tmp;
//      cur2 = cur2->next;
//
//      //if(0 == m_impl->m_name->u.rdnSequence->count)
//      
//      //CHANGED FROM ABOVE 4/28/2004
//      if(0 == m_impl->m_name->u.rdnSequence->head)
//      {
//          m_impl->m_name->u.rdnSequence->head = cur;
//          m_impl->m_name->u.rdnSequence->tail = cur;
//      }
//      else
//          m_impl->m_name->u.rdnSequence->tail = cur;
//      ++m_impl->m_name->u.rdnSequence->count;
//  }
CPKIFName::CPKIFName(
    const CPKIFBufferPtr& name)
    :m_impl(new CPKIFNameImpl)
{
    LOG_STRING_DEBUG("CPKIFName::CPKIFName(const CACX509V3Name&)", TOOLKIT_X509_ASN, 0, this);


    CACASNWRAPPER_CREATE(CACX509V3Name, objPDU);
    objPDU.Decode(name->GetBuffer(), name->GetLength());


    //if the name is empty set the m_impl->m_name to NULL and return
    if(NULL == objPDU->u.rdnSequence || 0 == objPDU->t)
    {
        m_impl->m_name = NULL;
        return;
    }

    //otherwise - create a copy of the name structure
    m_impl->m_name = new CACX509V3Name;
    m_impl->m_name->t = objPDU->t;

    m_impl->m_name->u.rdnSequence = new CACX509V3RDNSequence;
    m_impl->m_name->u.rdnSequence->head = NULL; m_impl->m_name->u.rdnSequence->tail = NULL; //added this line 4/28/2004
    m_impl->m_name->u.rdnSequence->count = 0;

    DListNode* cur = NULL, *cur2 = objPDU->u.rdnSequence->head;
    ASN1OpenType* tmp = NULL, *tmp2 = NULL;
    
    //iterate over all of the RDN elements in the name passed as a parameter
    for(unsigned int ii = 0; ii < objPDU->u.rdnSequence->count; ++ii)
    {
        if(NULL == cur)
        {
            NEW_NODE(cur)
        }
        else
        {
            NEW_NEXT_AND_ADVANCE(cur)
        }

        //create an ASN1OpenType to hold the data
        //use tmp2 as a temporary pointer to the actual value to copy
        tmp = new ASN1OpenType;
        tmp2 = (ASN1OpenType*)cur2->data;
        
        //save the length, allocate a buffer and copy the data
        //throw bad_alloc
        tmp->numocts = tmp2->numocts;
        tmp->data = new unsigned char[tmp->numocts];
        memcpy((void*)tmp->data, tmp2->data, tmp->numocts);

        cur->data = tmp;
        cur2 = cur2->next;

        //if(0 == m_impl->m_name->u.rdnSequence->count)
        
        //CHANGED FROM ABOVE 4/28/2004
        if(0 == m_impl->m_name->u.rdnSequence->head)
        {
            m_impl->m_name->u.rdnSequence->head = cur;
            m_impl->m_name->u.rdnSequence->tail = cur;
        }
        else
            m_impl->m_name->u.rdnSequence->tail = cur;
        ++m_impl->m_name->u.rdnSequence->count;
    }
}
//}
CPKIFName::~CPKIFName()
{
    LOG_STRING_DEBUG("CPKIFName::~CPKIFName()", TOOLKIT_X509_ASN, 0, this);
    if(m_impl) {
        if(NULL != m_impl->m_name)
        {
            DListNode* cur = m_impl->m_name->u.rdnSequence->head, *tmpCur = NULL;
            ASN1OpenType* tmp = NULL;
            for(unsigned int ii = 0; ii < m_impl->m_name->u.rdnSequence->count; ++ii)
            {
                tmp = (ASN1OpenType*)cur->data;
                delete[] tmp->data;
                delete tmp;

                tmpCur = cur->next;
                delete cur;

                cur = tmpCur;
            }

            delete m_impl->m_name->u.rdnSequence; m_impl->m_name->u.rdnSequence = NULL;
            delete m_impl->m_name; m_impl->m_name = NULL;
        }
        delete m_impl;
        m_impl = 0;
    }
}
CPKIFBufferPtr CPKIFName::Encoded()
{
    LOG_STRING_DEBUG("CPKIFName::Encoded()", TOOLKIT_X509_ASN, 0, this);
    
    if(NULL == m_impl->m_name)
    {
        CPKIFBufferPtr tmp;
        return tmp;
    }
    else
    {
        //added m_encodedName stuff 8/26/2004
        if(m_impl->m_encodedName == (CPKIFBuffer*)NULL)
        {
            CACASNWRAPPER_CREATE(CACX509V3Name, objPDU);
            ASN1OpenType* data1 = objPDU.Encode(m_impl->m_name);
            CPKIFBufferPtr tmp;
            if (data1 != NULL)
            {
                 tmp = CPKIFBufferPtr(new CPKIFBuffer(data1->data, data1->numocts));
                delete data1;
            }
            m_impl->m_encodedName = tmp;
            return tmp;
        }
        else
            return m_impl->m_encodedName;
    }
}
//CACX509V3Name* CPKIFName::rawName() 
//{
//  LOG_STRING_DEBUG("CPKIFName::rawName()", TOOLKIT_X509_ASN, 0, this);
//  return m_impl->m_name;
//}
CPKIFBufferPtr CPKIFName::rawName() 
{
    LOG_STRING_DEBUG("CPKIFName::rawName()", TOOLKIT_X509_ASN, 0, this);

    CACASNWRAPPER_CREATE(CACX509V3Name, objPDU2);
    ASN1OpenType* data1 = objPDU2.Encode(m_impl->m_name);

    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));

    if(data1 != NULL)
        delete data1;

    return tmp;
}

CPKIFOIDPtr g_oidCN(new CPKIFOID("2.5.4.3"));
CPKIFOIDPtr g_oidC(new CPKIFOID("2.5.4.6"));
CPKIFOIDPtr g_oidO(new CPKIFOID("2.5.4.10"));
CPKIFOIDPtr g_oidOU(new CPKIFOID("2.5.4.11"));
bool FindAttributeName(
    const CPKIFOIDPtr& oid,
    char* oidBuf)
{
    //NOTE: All string literals must be no greater than MAXOID in size.

    if(*oid == *g_oidCN)
        strcpy(oidBuf, "cn");
    else if(*oid == *g_oidC)
        strcpy(oidBuf, "c");
    else if(*oid == *g_oidO)
        strcpy(oidBuf, "o");
    else if(*oid == *g_oidOU)
        strcpy(oidBuf, "ou");
    else if(*oid == "2.5.4.7")
        strcpy(oidBuf, "l");
    else if(*oid == "1.2.840.113549.1.9.1")
        strcpy(oidBuf, "e"); //changed from emailAddress - 02/18/2003 CRW
    else if(*oid == "2.5.4.4")
        strcpy(oidBuf, "sn");
    else if(*oid == "2.5.4.5")
        strcpy(oidBuf, "serialNumber");
    else if(*oid == "2.5.4.8")
        strcpy(oidBuf, "st"); //changed 7/18/2003
    else if(*oid == "2.5.4.9")
        strcpy(oidBuf, "streetAddress");
    else if(*oid == "2.5.4.12")
        strcpy(oidBuf, "title");
    else if(*oid == "2.5.4.46") //added following items 7/18/2003
        strcpy(oidBuf, "dnQualifier");
    else if(*oid == "0.9.2342.19200300.100.1.25")
        strcpy(oidBuf, "dc");
    else if(*oid == "2.5.4.7")
        strcpy(oidBuf, "l");
    else if(*oid == "2.5.4.42")
        strcpy(oidBuf, "givenName");
    else if(*oid == "2.5.4.43")
        strcpy(oidBuf, "initials");
    else if(*oid == "2.5.4.12")
        strcpy(oidBuf, "title");
    else if(*oid == "2.5.4.44")
        strcpy(oidBuf, "generationQualifier");
    else
        return false;

    return true;
}
const char* CPKIFName::ToString()
{
    LOG_STRING_DEBUG("CPKIFName::string()", TOOLKIT_X509_ASN, 0, this);
    if(m_impl->m_string != NULL)
        return m_impl->m_string->c_str();

    std::string* s = new std::string;
    CPKIFStringPtr tmpStr(s);

    //iterate over all RDNs and build string
    DListNode* cur = m_impl->m_name->u.rdnSequence->tail;
    for(unsigned int ii = 0; ii < m_impl->m_name->u.rdnSequence->count; ++ii)
    {
        CACASNWRAPPER_CREATE(CACX509V3RelativeDistinguishedName, tmpPDU);
        CACX509V3RelativeDistinguishedName* tmpAttr = tmpPDU.Decode(*(ASN1OpenType*)cur->data);

        if(!tmpStr->empty())
            tmpStr->append(",");

        DListNode* curMultiRDN = tmpAttr->head;
        while(NULL != curMultiRDN)
        {
            CACX509V3AttributeTypeAndValue* attr99 = (CACX509V3AttributeTypeAndValue*)curMultiRDN->data;

            CACASNWRAPPER_CREATE(CACX509V3CACDirectoryString, objPDU3);

            CPKIFOIDPtr oid(new CPKIFOID(attr99->type.subid, attr99->type.numids));
            char oidBuf[MAXOID];
            if(FindAttributeName(oid, oidBuf))
                tmpStr->append(oidBuf);
            else
                tmpStr->append(oid->ToString());
            tmpStr->append("=");

            //added support for non-printable strings 12/9/2003
            CACX509V3CACDirectoryString* ds = NULL;
            try
            {
                ds = objPDU3.Decode(attr99->value);
            }
            catch(...)
            {
            }
            if(ds)
            {
                switch(ds->t)
                {
                case 1:
                    if(0 != strstr(ds->u.utf8String, ",") && 0 == strstr(ds->u.utf8String, "\""))
                    {
                        tmpStr->append("\"");
                        tmpStr->append(ds->u.utf8String);
                        tmpStr->append("\"");
                    }
                    else
                    {
                        tmpStr->append(ds->u.utf8String);
                    }
                    break;
                case 2:
                    if(0 != strstr(ds->u.printableString, ",") && 0 == strstr(ds->u.printableString, "\""))
                    {
                        tmpStr->append("\"");
                        tmpStr->append(ds->u.printableString);
                        tmpStr->append("\"");
                    }
                    else
                    {
                        tmpStr->append(ds->u.printableString);
                    }

                    break;
                case 3:
                    if(0 != strstr(ds->u.teletexString, ",") && 0 == strstr(ds->u.teletexString, "\""))
                    {
                        tmpStr->append("\"");
                        tmpStr->append(ds->u.teletexString);
                        tmpStr->append("\"");
                    }
                    else
                    {
                        tmpStr->append(ds->u.teletexString);
                    }
                    break;
                case 4:
                    if(0 != strstr(ds->u.ia5String, ",") && 0 == strstr(ds->u.ia5String, "\""))
                    {
                        tmpStr->append("\"");
                        tmpStr->append(ds->u.ia5String);
                        tmpStr->append("\"");
                    }
                    else
                    {
                        tmpStr->append(ds->u.ia5String);
                    }
                    break;
                case 5:
                    if(0 != strstr(ds->u.generalString, ",") && 0 == strstr(ds->u.generalString, "\""))
                    {
                        tmpStr->append("\"");
                        tmpStr->append(ds->u.generalString);
                        tmpStr->append("\"");
                    }
                    else
                    {
                        tmpStr->append(ds->u.generalString);
                    }
                    break;
                case 6://XXX-DEFER - string conversion for BMP and universal strings (added 6 and 7 semi-support 5/26/2004)
                    {
                    int tmpLen = ds->u.universalString.nchars + 1;
                    char* p = new char[tmpLen];
                    char* tmpP = p;
                    const char* tmpConstP = ucsToCStr(&ds->u.universalString, tmpP, tmpLen);
                    tmpStr->append(tmpConstP);
                    delete[] tmpP;
                    break;
                    }
                case 7:
                    {
                    int tmpLen = ds->u.bmpString.nchars + 1;
                    char* p = new char[tmpLen];
                    char* tmpP = p;
                    const char* tmpConstP = bmpToCStr(&ds->u.bmpString, tmpP, tmpLen);
                    tmpStr->append(tmpConstP);
                    delete[] tmpP;
                    break;
                    }
                default:
                    throw CPKIFException(TOOLKIT_ASN, -1, "Unsupported name form for string conversion");
                }
            }
            else
            {
                //case for funky DNs that do not have directory strings
                char* tmpUnusualRdnValue = new char[(attr99->value.numocts*2) + 1];
                btoa((const char*)attr99->value.data, tmpUnusualRdnValue, attr99->value.numocts);
                tmpStr->append(tmpUnusualRdnValue);
                delete[] tmpUnusualRdnValue;
            }

            curMultiRDN = curMultiRDN->next;
            if(NULL != curMultiRDN)
                tmpStr->append("+");
        }

        cur= cur->prev; 
    }

    m_impl->m_string = tmpStr;
    return m_impl->m_string->c_str();
} 

//
// Character type table for 0-0x7F range
//
#define _UPPER      0x1  // upper case letter
#define _LOWER      0x2  // lower case letter
#define _DIGIT      0x4  // digit[0-9]
#define _SPACE      0x8  // tab, carriage return, newline, vertical tab or form feed
#define _PUNCT      0x10 // punctuation character
#define _CONTROL    0x20 // control character
#define _BLANK      0x40 // space char
#define _HEX        0x80 // hexadecimal digit

char allSpaces[] = {0x09,0x0A,0x0B,0x0C,0x0D,0x20};
const int CharTableSize = 128;
static unsigned short CharTable[CharTableSize] = {
        _CONTROL,               // 00 (NUL)
        _CONTROL,               // 01 (SOH)
        _CONTROL,               // 02 (STX)
        _CONTROL,               // 03 (ETX)
        _CONTROL,               // 04 (EOT)
        _CONTROL,               // 05 (ENQ)
        _CONTROL,               // 06 (ACK)
        _CONTROL,               // 07 (BEL)
        _CONTROL,               // 08 (BS)
        _SPACE+_CONTROL,        // 09 (HT)
        _SPACE+_CONTROL,        // 0A (LF)
        _SPACE+_CONTROL,        // 0B (VT)
        _SPACE+_CONTROL,        // 0C (FF)
        _SPACE+_CONTROL,        // 0D (CR)
        _CONTROL,               // 0E (SI)
        _CONTROL,               // 0F (SO)
        _CONTROL,               // 10 (DLE)
        _CONTROL,               // 11 (DC1)
        _CONTROL,               // 12 (DC2)
        _CONTROL,               // 13 (DC3)
        _CONTROL,               // 14 (DC4)
        _CONTROL,               // 15 (NAK)
        _CONTROL,               // 16 (SYN)
        _CONTROL,               // 17 (ETB)
        _CONTROL,               // 18 (CAN)
        _CONTROL,               // 19 (EM)
        _CONTROL,               // 1A (SUB)
        _CONTROL,               // 1B (ESC)
        _CONTROL,               // 1C (FS)
        _CONTROL,               // 1D (GS)
        _CONTROL,               // 1E (RS)
        _CONTROL,               // 1F (US)
        _SPACE+_BLANK,          // 20 SPACE
        _PUNCT,                 // 21 !
        _PUNCT,                 // 22 "
        _PUNCT,                 // 23 #
        _PUNCT,                 // 24 $
        _PUNCT,                 // 25 %
        _PUNCT,                 // 26 &
        _PUNCT,                 // 27 '
        _PUNCT,                 // 28 (
        _PUNCT,                 // 29 )
        _PUNCT,                 // 2A *
        _PUNCT,                 // 2B +
        _PUNCT,                 // 2C ,
        _PUNCT,                 // 2D -
        _PUNCT,                 // 2E .
        _PUNCT,                 // 2F /
        _DIGIT+_HEX,            // 30 0
        _DIGIT+_HEX,            // 31 1
        _DIGIT+_HEX,            // 32 2
        _DIGIT+_HEX,            // 33 3
        _DIGIT+_HEX,            // 34 4
        _DIGIT+_HEX,            // 35 5
        _DIGIT+_HEX,            // 36 6
        _DIGIT+_HEX,            // 37 7
        _DIGIT+_HEX,            // 38 8
        _DIGIT+_HEX,            // 39 9
        _PUNCT,                 // 3A :
        _PUNCT,                 // 3B ;
        _PUNCT,                 // 3C <
        _PUNCT,                 // 3D =
        _PUNCT,                 // 3E >
        _PUNCT,                 // 3F ?
        _PUNCT,                 // 40 @
        _UPPER+_HEX,            // 41 A
        _UPPER+_HEX,            // 42 B
        _UPPER+_HEX,            // 43 C
        _UPPER+_HEX,            // 44 D
        _UPPER+_HEX,            // 45 E
        _UPPER+_HEX,            // 46 F
        _UPPER,                 // 47 G
        _UPPER,                 // 48 H
        _UPPER,                 // 49 I
        _UPPER,                 // 4A J
        _UPPER,                 // 4B K
        _UPPER,                 // 4C L
        _UPPER,                 // 4D M
        _UPPER,                 // 4E N
        _UPPER,                 // 4F O
        _UPPER,                 // 50 P
        _UPPER,                 // 51 Q
        _UPPER,                 // 52 R
        _UPPER,                 // 53 S
        _UPPER,                 // 54 T
        _UPPER,                 // 55 U
        _UPPER,                 // 56 V
        _UPPER,                 // 57 W
        _UPPER,                 // 58 X
        _UPPER,                 // 59 Y
        _UPPER,                 // 5A Z
        _PUNCT,                 // 5B [
        _PUNCT,                 // 5C \ (do not end the line with back slash)
        _PUNCT,                 // 5D ]
        _PUNCT,                 // 5E ^
        _PUNCT,                 // 5F _
        _PUNCT,                 // 60 `
        _LOWER+_HEX,            // 61 a
        _LOWER+_HEX,            // 62 b
        _LOWER+_HEX,            // 63 c
        _LOWER+_HEX,            // 64 d
        _LOWER+_HEX,            // 65 e
        _LOWER+_HEX,            // 66 f
        _LOWER,                 // 67 g
        _LOWER,                 // 68 h
        _LOWER,                 // 69 i
        _LOWER,                 // 6A j
        _LOWER,                 // 6B k
        _LOWER,                 // 6C l
        _LOWER,                 // 6D m
        _LOWER,                 // 6E n
        _LOWER,                 // 6F o
        _LOWER,                 // 70 p
        _LOWER,                 // 71 q
        _LOWER,                 // 72 r
        _LOWER,                 // 73 s
        _LOWER,                 // 74 t
        _LOWER,                 // 75 u
        _LOWER,                 // 76 v
        _LOWER,                 // 77 w
        _LOWER,                 // 78 x
        _LOWER,                 // 79 y
        _LOWER,                 // 7A z
        _PUNCT,                 // 7B {
        _PUNCT,                 // 7C |
        _PUNCT,                 // 7D }
        _PUNCT,                 // 7E ~
        _CONTROL                // 7F (DEL)
        // and the rest is filled with 0s...
};
bool CharIsSpace(
    char c)
{
    if( c < CharTableSize )
    {
        return ( 0 != (CharTable[c] & _SPACE) );
    }
    
    return false;
}

// trim_right() family.
inline std::string trim_right ( 
    const std::string & source ,
    const std::string & t = allSpaces )
{
       std::string str = source;
       return str.erase ( str.find_last_not_of ( t ) + 1 ) ; 
}

// trim_left() family.
inline std::string trim_left (
    const std::string & source , 
    const std::string & t = allSpaces )
{ 
       std::string str = source;
       return str.erase ( 0 , source.find_first_not_of ( t ) ) ; 
}

// trim() family.
inline std::string trim (
    const std::string & source ,
    const std::string & t = allSpaces )
{ 
       std::string str = source;
       return trim_left ( trim_right ( str , t ) , t ) ; 
}
bool CompareRDNStrings(
    const char* lhsStr, 
    const char* rhsStr)
{
    //build temp strings of each minus extra white space
    //std::string lhsTmp;
    //std::string rhsTmp;

    size_t len1 = strlen(lhsStr);
    size_t len2 = strlen(rhsStr);
    size_t count1 = 0;
    size_t count2 = 0;

    while(count1 < len1 && CharIsSpace(lhsStr[count1]))
            ++count1;
    while(count2 < len2 && CharIsSpace(rhsStr[count2]))
            ++count2;

    do
    {
        //if we've reached the end of both string - break and declare success
        if(count1 >= len1 && count2 >= len2)
            break;
        else if(count1 >= len1 || count2 >= len2) //one ended - not the other - no match
            return false;
        
        const char* t1 = &lhsStr[count1];
        const char* t2 = &rhsStr[count2];
        //reviewed 4/24 - length checks already performed
        if(0 == strnicmp(t1, t2, 1))
        {
            ++count1;
            ++count2;
        }
        else 
            return false;

        if( CharIsSpace(lhsStr[count1]))
        {
            while(count1 < len1 && (CharIsSpace(lhsStr[count1+1]) || count1+1 >= len1))
                ++count1;
            
        }
        if( CharIsSpace(rhsStr[count2]))
        {
            while(count2 < len2 && (CharIsSpace(rhsStr[count2+1]) || count2+1 >= len2))
                ++count2;
        }


    }while(1);
    /*
    int len = strlen(lhsStr);
    int spaceCount = 0;
    for(int ii = 0; ii < len; ++ii)
    {
        if( CharIsSpace(lhsStr[ii])) 
            ++spaceCount;
        else 
            spaceCount = 0;
        
        if( spaceCount <= 1) {
            lhsTmp.push_back( lhsStr[ii] );
        }
    }

    len = strlen(rhsStr);
    for(ii = 0; ii < len; ++ii)
    {
        if( CharIsSpace(rhsStr[ii])) 
            ++spaceCount;
        else 
            spaceCount = 0;
        
        if( spaceCount <= 1) {
            rhsTmp.push_back( rhsStr[ii] );
        }
    }

    //remove any leading or trailing white space
    lhsTmp = trim(lhsTmp);
    rhsTmp = trim(rhsTmp);

    if(0 == stricmp(lhsTmp.c_str(), rhsTmp.c_str()))
        return true;
    else
        return false;*/

    return true;
}

//added this to support reduction of OID conversion in RDNsMatch - 8/26/2004
bool CompareASN1OIDs(
    ASN1OBJID* lhs,
    ASN1OBJID* rhs)
{
    if(lhs->numids != rhs->numids)
        return false;

    //changed to start search at end of OID
    for(int ii = lhs->numids - 1; ii >= 0; --ii) 
        if(lhs->subid[ii] != rhs->subid[ii])
            return false;

    return true;
}
bool RDNsMatch(
    CACX509V3RelativeDistinguishedName* lhs,
    CACX509V3RelativeDistinguishedName* rhs)
{
    if(lhs->count != rhs->count)
        return false;

    DListNode* curLHS = lhs->head;
    DListNode* curRHS = rhs->head;
    for(unsigned int ii = 0; ii < lhs->count; ++ii)
    {
        CACX509V3AttributeTypeAndValue* dataLHS = (CACX509V3AttributeTypeAndValue*)curLHS->data;
        CACX509V3AttributeTypeAndValue* dataRHS = (CACX509V3AttributeTypeAndValue*)curRHS->data;

        //eliminate OID conversion - 8/26/2004
        //CPKIFOIDPtr lhsOID(new CPKIFOID(dataLHS->type));
        //CPKIFOIDPtr rhsOID(new CPKIFOID(dataRHS->type));
        //if(!(*lhsOID == *rhsOID))
        //  return false;

        if(!CompareASN1OIDs(&dataLHS->type, &dataRHS->type))
            return false;

        //added favor binary compare - 8/26/2004
        if(dataLHS->value.numocts != dataRHS->value.numocts ||
            0 != memcmp(dataLHS->value.data, dataRHS->value.data, dataLHS->value.numocts))
        {
            CACASNWRAPPER_CREATE(CACX509V3CACDirectoryString, objPDULHS);
            CACX509V3CACDirectoryString* dsLHS = objPDULHS.Decode(dataLHS->value);

            CACASNWRAPPER_CREATE(CACX509V3CACDirectoryString, objPDURHS);
            CACX509V3CACDirectoryString* dsRHS = objPDURHS.Decode(dataRHS->value);

            if(dsLHS->t != dsRHS->t)
            {
                //added 12/2/2003 to handle printablestring to utf8 rollover scenarios
                if((dsLHS->t == 1 || dsLHS->t == 2) && (dsRHS->t == 1 || dsRHS->t == 2))
                {
                    const char* lhsStr = NULL, *rhsStr = NULL;
                    size_t lhsLen = 0, rhsLen = 0;
                    if(dsLHS->t == 1)
                        lhsStr = dsLHS->u.utf8String;
                    else
                        lhsStr = dsLHS->u.printableString;
                    lhsLen = strlen(lhsStr);
                    if(dsRHS->t == 1)
                        rhsStr = dsRHS->u.utf8String;
                    else
                        rhsStr = dsRHS->u.printableString;
                    rhsLen = strlen(rhsStr);

                    if(!CompareRDNStrings(lhsStr, rhsStr))
                        return false;
                }
                else
                    return false;
            }
            else
            {
                const char* lhsStr = NULL, *rhsStr = NULL;
                size_t lhsLen = 0, rhsLen = 0;
                switch(dsLHS->t)
                {
                case 1://UTF8
                    lhsStr = dsLHS->u.utf8String; 
                    rhsStr = dsRHS->u.utf8String;
                    lhsLen = strlen(lhsStr);
                    rhsLen = strlen(rhsStr);
                    break;
                case 2://PrintableString
                    lhsStr = dsLHS->u.printableString;
                    rhsStr = dsRHS->u.printableString;
                    lhsLen = strlen(lhsStr);
                    rhsLen = strlen(rhsStr);
                    break;
                case 3://TeletexString
                    lhsStr = dsLHS->u.teletexString;
                    rhsStr = dsRHS->u.teletexString;
                    lhsLen = strlen(lhsStr);
                    rhsLen = strlen(rhsStr);
                    break;
                case 4://IA5String
                    lhsStr = dsLHS->u.ia5String;
                    rhsStr = dsRHS->u.ia5String;
                    lhsLen = strlen(lhsStr);
                    rhsLen = strlen(rhsStr);
                    break;
                case 5://GeneralString
                    lhsStr = dsLHS->u.generalString;
                    rhsStr = dsRHS->u.generalString;
                    lhsLen = strlen(lhsStr);
                    rhsLen = strlen(rhsStr);
                    break;
                case 6://UniversalString
                    lhsLen = dsLHS->u.universalString.nchars;
                    rhsLen = dsRHS->u.universalString.nchars;
                    break;
                case 7://BMPString
                    lhsLen = dsLHS->u.bmpString.nchars;
                    rhsLen = dsRHS->u.bmpString.nchars;
                    break;
                }

                if(6 != dsLHS->t && 7 != dsLHS->t)
                {
                    if(!CompareRDNStrings(lhsStr, rhsStr))
                        return false;
                }
                else
                {
                    //XXX***case insensitive?
                    if(lhsLen != rhsLen)
                        return false;
                    if(6 == dsLHS->t)
                    {
                        if(0 != memcmp(dsLHS->u.universalString.data, dsRHS->u.universalString.data, lhsLen))
                            return false;
                    }
                    else
                    {
                        if(0 != memcmp(dsLHS->u.bmpString.data, dsRHS->u.bmpString.data, lhsLen))
                            return false;
                    }
                }
            }
        }//end new condition 8/26/2004
        curLHS = curLHS->next; 
        curRHS = curRHS->next;
    }

    return true;
}
bool CPKIFName::operator==(
    const CPKIFName& rhs) const
{
    if(NULL == this->m_impl->m_name && NULL == rhs.m_impl->m_name)
        return true;

    if(this->m_impl->m_name->u.rdnSequence->count != rhs.m_impl->m_name->u.rdnSequence->count)
        return false;

    DListNode* curLHS = this->m_impl->m_name->u.rdnSequence->head;
    DListNode* curRHS = rhs.m_impl->m_name->u.rdnSequence->head;
    for(unsigned int ii = 0; ii < this->m_impl->m_name->u.rdnSequence->count; ++ii)
    {
        //added 8/26/2004
        ASN1OpenType* lhsP = (ASN1OpenType*)curLHS->data;
        ASN1OpenType* rhsP = (ASN1OpenType*)curRHS->data;
        if(lhsP->numocts != rhsP->numocts || 0 != memcmp(lhsP->data, rhsP->data, rhsP->numocts))
        {
            //parse and compare if binary equality fails - 8/26/2004
            CACASNWRAPPER_CREATE(CACX509V3RelativeDistinguishedName, tmpPDULHS);
            CACX509V3RelativeDistinguishedName* lhs = tmpPDULHS.Decode(*lhsP);

            CACASNWRAPPER_CREATE(CACX509V3RelativeDistinguishedName, tmpPDURHS);
            CACX509V3RelativeDistinguishedName* rhs = tmpPDURHS.Decode(*rhsP);

            if(!RDNsMatch(lhs, rhs))
                return false;
        }
        curLHS = curLHS->next; 
        curRHS = curRHS->next;
    }

    return true;
}

bool CPKIFName::DescendedFrom(
    const CPKIFName& rhs) const
{
    //if descendant has same or fewer rdns then it is not a descendant
    if( m_impl->m_name->u.rdnSequence->count >= rhs.m_impl->m_name->u.rdnSequence->count) 
        return false;

    DListNode* curLHS = this->m_impl->m_name->u.rdnSequence->head;
    DListNode* curRHS = rhs.m_impl->m_name->u.rdnSequence->head;
    for(unsigned int ii = 0; ii < this->m_impl->m_name->u.rdnSequence->count; ++ii)
    {
        CACASNWRAPPER_CREATE(CACX509V3RelativeDistinguishedName, tmpPDULHS);
        CACX509V3RelativeDistinguishedName* lhs = tmpPDULHS.Decode(*(ASN1OpenType*)curLHS->data);

        CACASNWRAPPER_CREATE(CACX509V3RelativeDistinguishedName, tmpPDURHS);
        CACX509V3RelativeDistinguishedName* rhs = tmpPDURHS.Decode(*(ASN1OpenType*)curRHS->data);

        if(!RDNsMatch(lhs, rhs))
            return false;

        curLHS = curLHS->next; 
        curRHS = curRHS->next;
    }

    return true;
}
int CPKIFName::RDNCount() const
{
    if(NULL == m_impl->m_name || NULL == m_impl->m_name->u.rdnSequence)
        return 0;
    else
        return m_impl->m_name->u.rdnSequence->count;
}

void CPKIFName::GetRDNs(std::vector<std::string>& rdns) const
{
    LOG_STRING_DEBUG("CPKIFName::string()", TOOLKIT_X509_ASN, 0, this);

    //iterate over all RDNs and populate vector
    DListNode* cur = m_impl->m_name->u.rdnSequence->tail;
    for(unsigned int ii = 0; ii < m_impl->m_name->u.rdnSequence->count; ++ii)
    {
        CACASNWRAPPER_CREATE(CACX509V3RelativeDistinguishedName, tmpPDU);
        CACX509V3RelativeDistinguishedName* tmpAttr = tmpPDU.Decode(*(ASN1OpenType*)cur->data);

        std::string rdnString;

        DListNode* curMultiRDN = tmpAttr->head;
        while(NULL != curMultiRDN)
        {
            CACX509V3AttributeTypeAndValue* attr99 = (CACX509V3AttributeTypeAndValue*)curMultiRDN->data;

            CACASNWRAPPER_CREATE(CACX509V3CACDirectoryString, objPDU3);
            CACX509V3CACDirectoryString* ds = objPDU3.Decode(attr99->value);

            CPKIFOIDPtr oid(new CPKIFOID(attr99->type.subid, attr99->type.numids));
            char oidBuf[MAXOID];
            if(FindAttributeName(oid, oidBuf))
                rdnString.append(oidBuf);
            else
                rdnString.append(oid->ToString());
            rdnString.append("=");

            //added support for non-printable strings 12/9/2003
            switch(ds->t)
            {
            case 1:
                if(0 != strstr(ds->u.utf8String, ","))
                    rdnString.append("\"");
                rdnString.append(ds->u.utf8String);
                if(0 != strstr(ds->u.utf8String, ","))
                    rdnString.append("\"");
                break;
            case 2:
                if(0 != strstr(ds->u.printableString, ","))
                    rdnString.append("\"");
                rdnString.append(ds->u.printableString);
                if(0 != strstr(ds->u.printableString, ","))
                    rdnString.append("\"");
                break;
            case 3:
                if(0 != strstr(ds->u.teletexString, ","))
                    rdnString.append("\"");
                rdnString.append(ds->u.teletexString);
                if(0 != strstr(ds->u.teletexString, ","))
                    rdnString.append("\"");
                break;
            case 4:
                if(0 != strstr(ds->u.ia5String, ","))
                    rdnString.append("\"");
                rdnString.append(ds->u.ia5String);
                if(0 != strstr(ds->u.ia5String, ","))
                    rdnString.append("\"");
                break;
            case 5:
                if(0 != strstr(ds->u.generalString, ","))
                    rdnString.append("\"");
                rdnString.append(ds->u.generalString);
                if(0 != strstr(ds->u.generalString, ","))
                    rdnString.append("\"");
                break;
            case 6://XXX-DEFER - string conversion for BMP and universal strings (added 6 and 7 semi-support 5/26/2004)
                {
                int tmpLen = ds->u.universalString.nchars + 1;
                char* p = new char[tmpLen];
                char* tmpP = p;
                const char* tmpConstP = ucsToCStr(&ds->u.universalString, tmpP, tmpLen);
                rdnString.append(tmpConstP);
                delete[] tmpP;
                break;
                }
            case 7:
                {
                int tmpLen = ds->u.bmpString.nchars + 1;
                char* p = new char[tmpLen];
                char* tmpP = p;
                const char* tmpConstP = bmpToCStr(&ds->u.bmpString, tmpP, tmpLen);
                rdnString.append(tmpConstP);
                delete[] tmpP;
                break;
                }
            default:
                throw CPKIFException(TOOLKIT_ASN, -1, "Unsupported name form for string conversion");
            }

            curMultiRDN = curMultiRDN->next;
            if(NULL != curMultiRDN)
                rdnString.append("+");
        }

        rdns.push_back(rdnString);
        cur= cur->prev; 
    }
}