OID.cpp

Go to the documentation of this file.

#include "OID.h"
#include "components.h"
#include "ASN1Errors.h"
#include "PKIFException.h"
#include "ASN1Helper.h"

#include "boost/lexical_cast.hpp"

#include <iostream>
#include <sstream>

using namespace std;


struct CPKIFOIDImpl
{
  CPKIFStringPtr m_oidStr;
  ASN1OBJID* m_rawOID;
};


//@b Interface: Subsystem
//
//This is a helper function that extracts a string up to a delimeter
//
//@return None
//*/
//void stringtok( 
//  //![in] Input string           
//  std::string &input, 
//  //![in] String that contains the delimiters
//  const std::string &delims, 
//  //![out] String that contains the result
//  std::string &result)
//{
//    std::string::size_type split(input.find_first_of(delims));
//  if(std::string::npos != split)
//  {
//      result = input.substr(0, split);
//
//      std::string::size_type next(input.find_first_not_of(delims, split));
//      if(std::string::npos != next)
//          input.erase(0, next);
//  }
//  else
//  {
//      result = input;
//      input.clear();
//  }
//    //return result;
//}

//@b Interface: Subsystem
//
//This is a helper function that converts a string representation of an oid into ASN1OBJID object
//
//@return A pointer to ASN1OBJID object corresponding to the string form provided in the str parameter
//*/
//ASN1OBJID* ConvertStringToASN1OBJID(
//  //![in] This is a smart poiter to a CPKIFString object containing the dot form of OID that will be converted to ASN1OBJID object 
//  CPKIFStringPtr str)
//{
//  if(str == NULL || str->empty())
//      return NULL;
//
//  //get a copy of the string in a non-reference counted form (we will be modifying this copy)
//  std::string oidStr = *str;
//
//  //see if there;s any stuff in the str passed in that isn't valid for an OID
//  if(std::string::npos != oidStr.find_first_not_of("0123456789."))
//      return NULL;
//
//  //create a new OID...
//  ASN1OBJID* theOid = new ASN1OBJID;
//  int numIds = 0;
//  
//  //and fill it
//  std::string result;
//  
//  stringtok(oidStr, ".", result);
//  while (!result.empty())
//  {
//      theOid->subid[numIds] = atoi(result.c_str());
//      numIds++;
//      stringtok(oidStr, ".", result);
//  }
//
//  theOid->numids = numIds;
//  return theOid;
//}
CPKIFOID::CPKIFOID()
  :m_impl (new CPKIFOIDImpl)
{
    m_impl->m_rawOID = NULL;
}
//ASN1OBJID* CPKIFOID::raw() const 
//{
//  return m_impl->m_rawOID;
//}
CPKIFBufferPtr CPKIFOID::rawOID() const 
{
    CACASNWRAPPER_CREATE(CACX509V3CertPolicyId, objPDU);
    ASN1OpenType* data1 = objPDU.Encode(m_impl->m_rawOID);
    CPKIFBufferPtr tmp(new CPKIFBuffer(data1->data, data1->numocts));
    if(data1)
        delete data1;
    //CPKIFBufferPtr tmp;
    return tmp;
}
CPKIFOID::CPKIFOID(
    const unsigned int oid[],
    const unsigned int size)
  :m_impl (new CPKIFOIDImpl)
{
    //copy OID contents into new ASN1OBJID object
    m_impl->m_rawOID = new ASN1OBJID;
    m_impl->m_rawOID->numids = size;//oid.numids;
    for(unsigned int ii = 0; ii < size; ++ii)
        m_impl->m_rawOID->subid[ii] = oid[ii];
}
CPKIFOID::CPKIFOID(
    const CPKIFOID& alg)
  :m_impl (new CPKIFOIDImpl)
{
    if(NULL == alg.m_impl->m_rawOID)
    {
        m_impl->m_rawOID = NULL;

        if(alg.m_impl->m_oidStr != NULL)
            m_impl->m_rawOID = ConvertStringToASN1OBJID(alg.m_impl->m_oidStr);
    }
    else
    {
        m_impl->m_rawOID = new ASN1OBJID;
        m_impl->m_rawOID->numids = alg.m_impl->m_rawOID->numids;
        for(unsigned int ii = 0; ii < alg.m_impl->m_rawOID->numids; ++ii)
            m_impl->m_rawOID->subid[ii] = alg.m_impl->m_rawOID->subid[ii];
    }
}
CPKIFOID::CPKIFOID(
    const CPKIFStringPtr& oidStr)
  :m_impl (new CPKIFOIDImpl)
{
    m_impl->m_rawOID = ConvertStringToASN1OBJID(oidStr);

    if(!m_impl->m_rawOID)
    {
        //added 9/13/03
        throw CPKIFException(TOOLKIT_ASN, ASN1_INVALID_OID);
    }
}
CPKIFOID::CPKIFOID(
    const std::string& oidStr)
  :m_impl (new CPKIFOIDImpl)
{
    CPKIFStringPtr strPtr(new std::string(oidStr));
    m_impl->m_rawOID = ConvertStringToASN1OBJID(strPtr);
    if(!m_impl->m_rawOID)
    {
        //added 9/13/03
        throw CPKIFException(TOOLKIT_ASN, ASN1_INVALID_OID);
    }
}
CPKIFOID::CPKIFOID(
    const CPKIFBufferPtr& oidBuff)
  :m_impl (new CPKIFOIDImpl)
{
    CACASNWRAPPER_CREATE(CACX509V3CertPolicyId, objPDU);
    objPDU.Decode(oidBuff->GetBuffer(), oidBuff->GetLength());

    m_impl->m_rawOID = new ASN1OBJID;
    CopyOID(m_impl->m_rawOID, objPDU.data());

}
CPKIFOID::~CPKIFOID()
{
    if(m_impl)
    {
        if(NULL != m_impl->m_rawOID)
        {
            delete m_impl->m_rawOID; m_impl->m_rawOID = NULL;
        }

        delete m_impl;
        m_impl = 0;
    }
}
const char* CPKIFOID::ToString() const
{
    //if we've already produced a string version return it
    if(m_impl->m_oidStr != NULL)
        return m_impl->m_oidStr->c_str();

    //otherwise create a new one
    std::string* oidStr = new std::string();
    //char numbuf[25];
    
    //added check for NULL 7/12/2003
    if(NULL == m_impl->m_rawOID)
    {
        throw CPKIFException(TOOLKIT_ASN, ASN1_INVALID_OID);
    }

    ostringstream os;
    for (unsigned int curId = 0; curId < m_impl->m_rawOID->numids; ++curId)
    {
        
        if (curId == 0)
            os << m_impl->m_rawOID->subid[curId];
        else
        {
            os << "." << m_impl->m_rawOID->subid[curId];
        }
        
    }
    *oidStr = os.str();
    CPKIFStringPtr tmpOIDStr(oidStr);
    CPKIFOID* nonConstCACOID = const_cast<CPKIFOID*>(this);
    nonConstCACOID->m_impl->m_oidStr = tmpOIDStr;
    return m_impl->m_oidStr->c_str();
}
bool CPKIFOID::operator ==(
    const CPKIFOIDPtr& oid) const
{
    return *this == *oid;
}
bool CPKIFOID::operator ==(
    const char* strOID) const
{
    //added check to avoid conversion is a string is available - 8/26/2004
    if(m_impl->m_oidStr == (std::string*)NULL)
    {
        //CPKIFOID oid(std::string(strOID));
        std::string sOID(strOID);
        CPKIFOID rhs( (std::string(strOID)) );
        return *this == rhs;
    }
    else
    {
        return 0 == strcmp(m_impl->m_oidStr->c_str(), strOID);
    }
}
bool CPKIFOID::operator ==(
    const CPKIFOID& oid) const
{
    if(NULL == oid.m_impl->m_rawOID)
        return false;

    if(m_impl->m_rawOID->numids != oid.m_impl->m_rawOID->numids)
        return false;

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

    return true;
}
bool CPKIFOID::operator !=(
    const CPKIFOID& oid) const
{
    return !(this->operator ==(oid));
}

//changed to & - 7/28/2004
bool CPKIFOID::operator !=(
    CPKIFOIDPtr& oid) const
{
    return !(this->operator ==(oid));
}
bool CPKIFOID::operator !=(
    const char* strOID) const
{
    return !(this->operator ==(strOID));
}