PKIFSCVPMemoryHelper.cpp

Go to the documentation of this file.

#include "private/PKIFSCVPMemoryHelper.h"
#include "PKIFSCVP.h"
#include "SCVP.h"
#include "ToolkitUtils.h"
#include "components.h"

//*****************************************************************
//  Memory helper
//*****************************************************************

//declare these as non-member functions instead of private functions
//no need to make them visible beyond this file
void FreeValPolRequestMembers(ValPolRequest* pValPolRequest)
{
}
void FreeValPolResponseMembers(ValPolResponse* pValPolResponse)
{
    LOG_STRING_DEBUG("FreeValPolResponseMembers", TOOLKIT_SCVP_ASN, 0, NULL);

    if(!pValPolResponse)
        return;

    
    DListNode* cur = NULL, *tmp = NULL;
    DListNode* cur2 = NULL, *tmp2 = NULL;
    //deleting authPolicies
    if(pValPolResponse->authPolicies.count > 0)
    {
        cur = pValPolResponse->authPolicies.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //deleting supportedChecks
    if(pValPolResponse->supportedChecks.count > 0)
    {
        cur = pValPolResponse->supportedChecks.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //deleting supportedWantBacks
    if(pValPolResponse->supportedWantBacks.count > 0)
    {
        cur = pValPolResponse->supportedWantBacks.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //deleting validationPolicies
    if(pValPolResponse->validationPolicies.count > 0)
    {
        cur = pValPolResponse->validationPolicies.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }
    //deleting validationAlgs
    if(pValPolResponse->validationAlgs.count > 0)
    {
        cur = pValPolResponse->validationAlgs.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //deleting signatureGeneration
    if(pValPolResponse->signatureGeneration.count > 0)
    {
        cur = pValPolResponse->signatureGeneration.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //deleting signatureVerification
    if(pValPolResponse->signatureVerification.count > 0)
    {
        cur = pValPolResponse->signatureVerification.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //deleting hashAlgorithms
    if(pValPolResponse->hashAlgorithms.count > 0)
    {
        cur = pValPolResponse->hashAlgorithms.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //deleting serverPublicKeys
    if(pValPolResponse->serverPublicKeys.count > 0)
    {
        cur = pValPolResponse->serverPublicKeys.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //delete user policy set from defaultPolicyValues
    if(pValPolResponse->defaultPolicyValues.m.userPolicySetPresent)
    {
        if(0 < pValPolResponse->defaultPolicyValues.userPolicySet.count)
        {
            cur = pValPolResponse->defaultPolicyValues.userPolicySet.head;
            while(NULL != cur)
            {
                tmp = cur->next;

                if(NULL != cur && NULL != cur->data)
                    delete cur->data;

                delete cur;
                cur = tmp;
            }
        }
    }

    //delete TAs from defaultPolicyValues
    if(pValPolResponse->defaultPolicyValues.m.trustAnchorsPresent)
    {
        if(0 < pValPolResponse->defaultPolicyValues.trustAnchors.count)
        {
            cur = pValPolResponse->defaultPolicyValues.trustAnchors.head;
            while(NULL != cur)
            {
                PKCReference* tmpRef = NULL;
                if(NULL != cur->data)
                {
                    tmpRef = (PKCReference*)cur->data;

                    if(NULL != tmpRef)
                    {
                        if(tmpRef->t == T_PKCReference_pkcRef)
                        {
                            cur2 = tmpRef->u.pkcRef->issuerSerial.issuer.head;
                            while(NULL != cur2)
                            {
                                tmp2 = cur2->next;
                                if(NULL != cur2 && NULL != cur2->data)
                                    delete cur2->data;
                                delete cur2;
                                cur2 = tmp2;
                            }
                            
                            if(NULL != tmpRef->u.pkcRef)
                                delete tmpRef->u.pkcRef;
                        }
                        else if(tmpRef->t == T_PKCReference_cert)
                        {
                            if(NULL != tmpRef->u.cert)
                                delete tmpRef->u.cert;
                        }

                        
                        delete tmpRef;
                    }

                }
                tmp = cur->next;
                delete cur;
                cur = tmp;
            }
        }
    }
    //delete key usages from defaultPolicyValues
    if(pValPolResponse->defaultPolicyValues.m.keyUsagesPresent)
    {
        if(0 < pValPolResponse->defaultPolicyValues.keyUsages.count)
        {
            cur = pValPolResponse->defaultPolicyValues.keyUsages.head;
            while(NULL != cur)
            {
                tmp = cur->next;

                if(NULL != cur && NULL != cur->data)
                    delete cur->data;

                delete cur;
                cur = tmp;
            }
        }
    }
    //delete EKUs from defaultPolicyValues
    if(pValPolResponse->defaultPolicyValues.m.extendedKeyUsagesPresent)
    {
        if(0 < pValPolResponse->defaultPolicyValues.extendedKeyUsages.count)
        {
            cur = pValPolResponse->defaultPolicyValues.extendedKeyUsages.head;
            while(NULL != cur)
            {
                tmp = cur->next;
        
                if(NULL != cur && NULL != cur->data)
                    delete cur->data;
                
                delete cur;
                cur = tmp;
            }
        }
    }
    //delete SKUs from defaultPolicyValues
    if(pValPolResponse->defaultPolicyValues.m.specifiedKeyUsagesPresent)
    {
        if(0 < pValPolResponse->defaultPolicyValues.specifiedKeyUsages.count)
        {
            cur = pValPolResponse->defaultPolicyValues.specifiedKeyUsages.head;
            while(NULL != cur)
            {
                tmp = cur->next;
                
                if(NULL != cur && NULL != cur->data)
                    delete cur->data;
                
                delete cur;
                cur = tmp;
            }
        }
    }

    
    
}
void FreeRequestMembers(CVRequest* pRequest)
{
    LOG_STRING_DEBUG("FreeRequestMembers", TOOLKIT_SCVP_ASN, 0, NULL);

    if(!pRequest)
        return;

    //deleting requestor reference
    DListNode* cur = NULL, *tmp = NULL;
    DListNode* cur2 = NULL, *tmp2 = NULL;
    if(pRequest->m.requestorRefPresent)
    {
        cur = pRequest->requestorRef.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    if(pRequest->query.queriedCerts.t == T_CertReferences_pkcRefs)
    {
        cur = NULL; tmp = NULL;
        if(0 != pRequest->query.queriedCerts.u.pkcRefs->count)
        {
            cur = pRequest->query.queriedCerts.u.pkcRefs->head;
            while(NULL != cur)
            {
                PKCReference* tmpRef = NULL;
                
                if(NULL != cur->data)
                    tmpRef = (PKCReference*)cur->data;
                if(NULL != tmpRef)
                {
                    if(tmpRef->t == T_PKCReference_pkcRef)
                    {
                        cur2 = tmpRef->u.pkcRef->issuerSerial.issuer.head;
                        while(NULL != cur2)
                        {
                            tmp2 = cur2->next;

                            if(NULL != cur2 && NULL != cur2->data)
                                delete cur2->data;

                            delete cur2;
                            cur2 = tmp2;
                        }
                        
                        if(NULL != tmpRef->u.pkcRef)
                            delete tmpRef->u.pkcRef;
                    }
                    else if(tmpRef->t == T_PKCReference_cert)
                    {
                        if(NULL != tmpRef->u.cert)
                            delete tmpRef->u.cert;
                    }

                    
                }
                tmp = cur->next;
                delete cur;
                cur = tmp;
            }
        }
    }
    else if(pRequest->query.queriedCerts.t == T_CertReferences_acRefs)
    {
        cur = NULL; tmp = NULL;
        if(0 != pRequest->query.queriedCerts.u.acRefs->count)
        {
            cur = pRequest->query.queriedCerts.u.acRefs->head;
            while(NULL != cur)
            {
                ACReference* tmpRef = NULL;
                
                if(NULL != cur->data)
                    tmpRef = (ACReference*)cur->data;
                if(NULL != tmpRef)
                {
                    if(tmpRef->t == T_ACReference_acRef)
                    {
                        cur2 = tmpRef->u.acRef->issuerSerial.issuer.head;
                        while(NULL != cur2)
                        {
                            tmp2 = cur2->next;

                            if(NULL != cur2 && NULL != cur2->data)
                                delete cur2->data;

                            delete cur2;
                            cur2 = tmp2;
                        }
                        
                        if(NULL != tmpRef->u.acRef)
                            delete tmpRef->u.acRef;
                    }
                    else if(tmpRef->t == T_ACReference_attrCert)
                    {
                        if(NULL != tmpRef->u.attrCert)
                            delete tmpRef->u.attrCert;
                    }
                        
                }
                tmp = cur->next;
                delete cur;
                cur = tmp;
            }
        }
    }

    //delete query checks
    cur = NULL; tmp = NULL;
    if(0 < pRequest->query.checks.count)
    {
        cur = pRequest->query.checks.head;
        while(NULL != cur)
        {
            tmp = cur->next;
        
            if(NULL != cur && NULL != cur->data)
                delete cur->data;

            delete cur;
            cur = tmp;
        }
    }

    //delete wantbacks
    cur = NULL; tmp = NULL;
    if(pRequest->query.m.wantBackPresent)
    {
        if(0 < pRequest->query.wantBack.count)
        {
            cur = pRequest->query.wantBack.head;
            while(NULL != cur)
            {
                tmp = cur->next;
                
                if(NULL != cur && NULL != cur->data)
                    delete cur->data;

                delete cur;
                cur = tmp;
            }
        }
    }

    //delete intermidiate certs from query
    cur = NULL; tmp = NULL;
    if(pRequest->query.m.intermediateCertsPresent)
    {
        if(0 < pRequest->query.intermediateCerts.count)
        {
            cur = pRequest->query.intermediateCerts.head;
            while(NULL != cur)
            {
                tmp = cur->next;

                if(NULL != cur && NULL != cur->data)
                    delete cur->data;

                delete cur;
                cur = tmp;
            }
        }
    }

    //delete rev i info from query
    cur = NULL; tmp = NULL;
    if(pRequest->query.m.revInfosPresent)
    {
        if(0 < pRequest->query.revInfos.count)
        {
            cur = pRequest->query.revInfos.head;
            while(NULL != cur)
            {
                RevocationInfo* tmpRef = NULL;
                if(NULL != cur->data)
                {
                    tmpRef = (RevocationInfo*)cur->data;
                    
                    if(tmpRef->t == T_RevocationInfo_crl)
                    {
                        if(tmpRef->u.crl != NULL)
                            delete tmpRef->u.crl;
                    }
                    else if(tmpRef->t == T_RevocationInfo_delta_crl)
                    {
                        if(tmpRef->u.delta_crl != NULL)
                            delete tmpRef->u.delta_crl;
                    }
                    else if(tmpRef->t == T_RevocationInfo_ocsp)
                    {
                        if(tmpRef->u.ocsp != NULL)
                            delete tmpRef->u.ocsp;
                    }
                    else if(tmpRef->t == T_RevocationInfo_other)
                    {
                        if(tmpRef->u.other != NULL)
                            delete tmpRef->u.other;
                    }


                    delete tmpRef;
                }
                tmp = cur->next;
                delete cur;
                cur = tmp;
            }
        }
    }
    //delete user policy set from query.validationPolicy
    if(pRequest->query.validationPolicy.m.userPolicySetPresent)
    {
        if(0 < pRequest->query.validationPolicy.userPolicySet.count)
        {
            cur = pRequest->query.validationPolicy.userPolicySet.head;
            while(NULL != cur)
            {
                tmp = cur->next;

                if(NULL != cur && NULL != cur->data)
                    delete cur->data;

                delete cur;
                cur = tmp;
            }
        }
    }

    //delete TAs from query.validationPolicy
    if(pRequest->query.validationPolicy.m.trustAnchorsPresent)
    {
        if(0 < pRequest->query.validationPolicy.trustAnchors.count)
        {
            cur = pRequest->query.validationPolicy.trustAnchors.head;
            while(NULL != cur)
            {
                PKCReference* tmpRef = NULL;
                if(NULL != cur->data)
                {
                    tmpRef = (PKCReference*)cur->data;

                    if(NULL != tmpRef)
                    {
                        if(tmpRef->t == T_PKCReference_pkcRef)
                        {
                            cur2 = tmpRef->u.pkcRef->issuerSerial.issuer.head;
                            while(NULL != cur2)
                            {
                                tmp2 = cur2->next;
                                if(NULL != cur2 && NULL != cur2->data)
                                    delete cur2->data;
                                delete cur2;
                                cur2 = tmp2;
                            }
                            
                            if(NULL != tmpRef->u.pkcRef)
                                delete tmpRef->u.pkcRef;
                        }
                        else if(tmpRef->t == T_PKCReference_cert)
                        {
                            if(NULL != tmpRef->u.cert)
                                delete tmpRef->u.cert;
                        }

                        
                        delete tmpRef;
                    }

                }
                tmp = cur->next;
                delete cur;
                cur = tmp;
            }
        }
    }
    //delete key usages from query.validationPolicy
    if(pRequest->query.validationPolicy.m.keyUsagesPresent)
    {
        if(0 < pRequest->query.validationPolicy.keyUsages.count)
        {
            cur = pRequest->query.validationPolicy.keyUsages.head;
            while(NULL != cur)
            {
                tmp = cur->next;

                if(NULL != cur && NULL != cur->data)
                    delete cur->data;

                delete cur;
                cur = tmp;
            }
        }
    }
    //delete EKUs from query.validationPolicy
    if(pRequest->query.validationPolicy.m.extendedKeyUsagesPresent)
    {
        if(0 < pRequest->query.validationPolicy.extendedKeyUsages.count)
        {
            cur = pRequest->query.validationPolicy.extendedKeyUsages.head;
            while(NULL != cur)
            {
                tmp = cur->next;
        
                if(NULL != cur && NULL != cur->data)
                    delete cur->data;

                
                delete cur;
                cur = tmp;
            }
        }
    }
    //delete SKUs from query.validationPolicy
    if(pRequest->query.validationPolicy.m.specifiedKeyUsagesPresent)
    {
        if(0 < pRequest->query.validationPolicy.specifiedKeyUsages.count)
        {
            cur = pRequest->query.validationPolicy.specifiedKeyUsages.head;
            while(NULL != cur)
            {
                tmp = cur->next;
                
                if(NULL != cur && NULL != cur->data)
                    delete cur->data;
                
                delete cur;
                cur = tmp;
            }
        }
    }

    if(pRequest->requestorText != NULL)
    {
        delete pRequest->requestorText;
    }
}
void FreeResponseMembers(CVResponse* pResponse)
{
    LOG_STRING_DEBUG("FreeResponseMembers", TOOLKIT_SCVP_ASN, 0, NULL);

    if(!pResponse)
        return;

    
    DListNode* cur = NULL, *tmp = NULL;
    DListNode* cur2 = NULL, *tmp2 = NULL;


    //delete request ref
    if(pResponse->m.requestRefPresent)
    {
        if(pResponse->requestRef.t == T_RequestReference_fullRequest)
        {
            if(pResponse->requestRef.u.fullRequest != NULL)
                delete pResponse->requestRef.u.fullRequest;
        }
    }

    //delete requestor ref
    if(pResponse->m.requestorRefPresent)
    {
        cur = pResponse->requestorRef.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            RevocationInfo* tmpOther = (RevocationInfo*)cur->data;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }

    //delete requestor name
    if(pResponse->m.requestorNamePresent)
    {
        cur = pResponse->requestorName.head;
        while(NULL != cur)
        {
            tmp = cur->next;

            if(NULL != cur && NULL != cur->data)
                delete cur->data;
            delete cur;
            cur = tmp;
        }
    }
    
    if(pResponse->m.replyObjectsPresent)
    {
        cur = pResponse->replyObjects.head;
        while(NULL != cur)
        {
            CertReply* tmpRef = NULL;
            if(NULL != cur->data)
            {
                tmpRef = (CertReply*)cur->data;
                
                cur2 = NULL;
                if(0 < tmpRef->replyChecks.count)
                {
                    cur2 = tmpRef->replyChecks.head;
                    while(NULL != cur2)
                    {
                        tmp2 = cur2->next;

                        if(NULL != cur2 && NULL != cur2->data)
                            delete cur2->data;
                        delete cur2;
                        cur2 = tmp2;
                    }
                }

                cur2 = NULL;
                if(0 < tmpRef->replyWantBacks.count)
                {
                    cur2 = tmpRef->replyWantBacks.head;
                    while(NULL != cur2)
                    {
                        tmp2 = cur2->next;

                        if(NULL != cur2 && NULL != cur2->data)
                            delete cur2->data;
                        delete cur2;
                        cur2 = tmp2;
                    }
                }

                cur2 = NULL;
                if(tmpRef->m.validationErrorsPresent)
                {
                    if(0 < tmpRef->validationErrors.count)
                    {
                        cur2 = tmpRef->validationErrors.head;
                        while(NULL != cur2)
                        {
                            tmp2 = cur2->next;

                            if(NULL != cur2 && NULL != cur2->data)
                                delete cur2->data;
                            delete cur2;
                            cur2 = tmp2;
                        }
                    }
                }

                cur2 = NULL;
                if(tmpRef->cert.t == T_CertReference_pkc)
                {
                    if(tmpRef->cert.u.pkc->t == T_PKCReference_cert)
                    {
                        if(tmpRef->cert.u.pkc->u.cert != NULL)
                        {
                            delete tmpRef->cert.u.pkc->u.cert;
                        }
                    }
                    else if(tmpRef->cert.u.pkc->t == T_PKCReference_pkcRef)
                    {
                            
                        DListNode* cur3 = NULL, *tmp3 = NULL;
                        cur = tmpRef->cert.u.pkc->u.pkcRef->issuerSerial.issuer.head;
                        while(NULL != cur3)
                        {
                            tmp3 = cur3->next;
                            if(NULL != cur3 && NULL != cur3->data)
                                delete cur3->data;
                            delete cur3;
                            cur3 = tmp3;
                        }

                        if(tmpRef->cert.u.pkc->u.pkcRef->issuerSerial.serialNumber != NULL)
                            delete tmpRef->cert.u.pkc->u.pkcRef->issuerSerial.serialNumber;
                        delete tmpRef->cert.u.pkc->u.pkcRef;
                    }

                    delete tmpRef->cert.u.pkc;
                }
                if(tmpRef->cert.t == T_CertReference_ac)
                {
                    if(tmpRef->cert.u.ac->t == T_ACReference_attrCert)
                    {
                        if(tmpRef->cert.u.ac->u.attrCert != NULL)
                        {
                            delete tmpRef->cert.u.ac->u.attrCert;
                        }
                    }
                    else if(tmpRef->cert.u.ac->t == T_ACReference_acRef)
                    {
                        DListNode* cur3 = NULL, *tmp3 = NULL;
                        cur = tmpRef->cert.u.ac->u.acRef->issuerSerial.issuer.head;
                        while(NULL != cur3)
                        {
                            tmp3 = cur3->next;
                            if(NULL != cur3 && NULL != cur3->data)
                                delete cur3->data;
                            delete cur3;
                            cur3 = tmp3;
                        }

                        if(tmpRef->cert.u.ac->u.acRef->issuerSerial.serialNumber != NULL)
                            delete tmpRef->cert.u.ac->u.acRef->issuerSerial.serialNumber;
                        
                        delete tmpRef->cert.u.ac->u.acRef;
                    }

                    delete tmpRef->cert.u.ac;
                }

                delete tmpRef;

            }
            delete cur;
            cur = tmp;
        }
    }

    if(pResponse->m.respValidationPolicyPresent)
    {
        //delete user policy set from respValidationPolicy
        if(pResponse->respValidationPolicy.m.userPolicySetPresent)
        {
            if(0 < pResponse->respValidationPolicy.userPolicySet.count)
            {
                cur = pResponse->respValidationPolicy.userPolicySet.head;
                while(NULL != cur)
                {
                    tmp = cur->next;

                    if(NULL != cur && NULL != cur->data)
                        delete cur->data;

                    delete cur;
                    cur = tmp;
                }
            }
        }

        //delete TAs from respValidationPolicy
        if(pResponse->respValidationPolicy.m.trustAnchorsPresent)
        {
            if(0 < pResponse->respValidationPolicy.trustAnchors.count)
            {
                cur = pResponse->respValidationPolicy.trustAnchors.head;
                while(NULL != cur)
                {
                    PKCReference* tmpRef = NULL;
                    if(NULL != cur->data)
                    {
                        tmpRef = (PKCReference*)cur->data;

                        if(NULL != tmpRef)
                        {
                            if(tmpRef->t == T_PKCReference_pkcRef)
                            {
                                cur2 = tmpRef->u.pkcRef->issuerSerial.issuer.head;
                                while(NULL != cur2)
                                {
                                    tmp2 = cur2->next;
                                    if(NULL != cur2 && NULL != cur2->data)
                                        delete cur2->data;
                                    delete cur2;
                                    cur2 = tmp2;
                                }
                                
                                if(NULL != tmpRef->u.pkcRef)
                                    delete tmpRef->u.pkcRef;
                            }
                            else if(tmpRef->t == T_PKCReference_cert)
                            {
                                if(NULL != tmpRef->u.cert)
                                    delete tmpRef->u.cert;
                            }

                            
                            delete tmpRef;
                        }

                    }
                    tmp = cur->next;
                    delete cur;
                    cur = tmp;
                }
            }
        }
        //delete key usages from respValidationPolicy
        if(pResponse->respValidationPolicy.m.keyUsagesPresent)
        {
            if(0 < pResponse->respValidationPolicy.keyUsages.count)
            {
                cur = pResponse->respValidationPolicy.keyUsages.head;
                while(NULL != cur)
                {
                    tmp = cur->next;

                    if(NULL != cur && NULL != cur->data)
                        delete cur->data;

                    delete cur;
                    cur = tmp;
                }
            }
        }
        //delete EKUs from respValidationPolicy
        if(pResponse->respValidationPolicy.m.extendedKeyUsagesPresent)
        {
            if(0 < pResponse->respValidationPolicy.extendedKeyUsages.count)
            {
                cur = pResponse->respValidationPolicy.extendedKeyUsages.head;
                while(NULL != cur)
                {
                    tmp = cur->next;
            
                    if(NULL != cur && NULL != cur->data)
                        delete cur->data;

                    
                    delete cur;
                    cur = tmp;
                }
            }
        }
        //delete SKUs from respValidationPolicy
        if(pResponse->respValidationPolicy.m.specifiedKeyUsagesPresent)
        {
            if(0 < pResponse->respValidationPolicy.specifiedKeyUsages.count)
            {
                cur = pResponse->respValidationPolicy.specifiedKeyUsages.head;
                while(NULL != cur)
                {
                    tmp = cur->next;
                    
                    if(NULL != cur && NULL != cur->data)
                        delete cur->data;
                    
                    delete cur;
                    cur = tmp;
                }
            }
        }
    }

    if(pResponse->responseStatus.m.errorMessagePresent > 0 && pResponse->responseStatus.errorMessage != NULL)
    {
        delete pResponse->responseStatus.errorMessage;
    }

    if(pResponse->requestorText != NULL)
    {
        delete pResponse->requestorText;
    }
}
PKIFSCVPMemoryHelper::PKIFSCVPMemoryHelper()
{
    LOG_STRING_DEBUG("PKIFSCVPMemoryHelper::PKIFSCVPMemoryHelper()", TOOLKIT_SCVP_ASN, 0, this);

    pRequest = NULL;
    pResponse = NULL;
    pValPolRequest = NULL;
    pValPolResponse = NULL;
}
PKIFSCVPMemoryHelper::~PKIFSCVPMemoryHelper()
{
    LOG_STRING_DEBUG("PKIFSCVPMemoryHelper::~PKIFSCVPMemoryHelper()", TOOLKIT_SCVP_ASN, 0, this);

    if(NULL != pRequest)
    {
        FreeRequestMembers(pRequest);
        delete pRequest;
    }

    if(NULL != pResponse)
    {
        FreeResponseMembers(pResponse);
        delete pResponse;
    }

    if(NULL != pValPolResponse)
    {
        FreeValPolResponseMembers(pValPolResponse);
        delete pValPolResponse;
    }
    if(NULL != pValPolRequest)
    {
        FreeValPolRequestMembers(pValPolRequest);
        delete pValPolRequest;
    }
}