| Index: mozilla/security/nss/lib/libpkix/pkix_pl_nss/module/pkix_pl_colcertstore.c
 | 
| ===================================================================
 | 
| --- mozilla/security/nss/lib/libpkix/pkix_pl_nss/module/pkix_pl_colcertstore.c	(revision 191424)
 | 
| +++ mozilla/security/nss/lib/libpkix/pkix_pl_nss/module/pkix_pl_colcertstore.c	(working copy)
 | 
| @@ -1,1282 +0,0 @@
 | 
| -/* This Source Code Form is subject to the terms of the Mozilla Public
 | 
| - * License, v. 2.0. If a copy of the MPL was not distributed with this
 | 
| - * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 | 
| -/*
 | 
| - * pkix_pl_colcertstore.c
 | 
| - *
 | 
| - * CollectionCertStore Function Definitions
 | 
| - *
 | 
| - */
 | 
| -
 | 
| -#include "pkix_pl_colcertstore.h"
 | 
| -
 | 
| -/*
 | 
| - * This Object is going to be taken out from libpkix SOON. The following
 | 
| - * function is copied from nss/cmd library, but not supported by NSS as
 | 
| - * public API. We use it since ColCertStore are read in Cert/Crl from
 | 
| - * files and need this support.
 | 
| - */
 | 
| -
 | 
| -static SECStatus
 | 
| -SECU_FileToItem(SECItem *dst, PRFileDesc *src)
 | 
| -{
 | 
| -    PRFileInfo info;
 | 
| -    PRInt32 numBytes;
 | 
| -    PRStatus prStatus;
 | 
| -
 | 
| -    prStatus = PR_GetOpenFileInfo(src, &info);
 | 
| -
 | 
| -    if (prStatus != PR_SUCCESS) {
 | 
| -        PORT_SetError(SEC_ERROR_IO);
 | 
| -        return SECFailure;
 | 
| -    }
 | 
| -
 | 
| -    /* XXX workaround for 3.1, not all utils zero dst before sending */
 | 
| -    dst->data = 0;
 | 
| -    if (!SECITEM_AllocItem(NULL, dst, info.size))
 | 
| -        goto loser;
 | 
| -
 | 
| -    numBytes = PR_Read(src, dst->data, info.size);
 | 
| -    if (numBytes != info.size) {
 | 
| -        PORT_SetError(SEC_ERROR_IO);
 | 
| -        goto loser;
 | 
| -    }
 | 
| -
 | 
| -    return SECSuccess;
 | 
| -loser:
 | 
| -    SECITEM_FreeItem(dst, PR_FALSE);
 | 
| -    return SECFailure;
 | 
| -}
 | 
| -
 | 
| -static SECStatus
 | 
| -SECU_ReadDERFromFile(SECItem *der, PRFileDesc *inFile, PRBool ascii)
 | 
| -{
 | 
| -    SECStatus rv;
 | 
| -    if (ascii) {
 | 
| -        /* First convert ascii to binary */
 | 
| -        SECItem filedata;
 | 
| -        char *asc, *body;
 | 
| -
 | 
| -        /* Read in ascii data */
 | 
| -        rv = SECU_FileToItem(&filedata, inFile);
 | 
| -        asc = (char *)filedata.data;
 | 
| -        if (!asc) {
 | 
| -            fprintf(stderr, "unable to read data from input file\n");
 | 
| -            return SECFailure;
 | 
| -        }
 | 
| -
 | 
| -        /* check for headers and trailers and remove them */
 | 
| -        if ((body = strstr(asc, "-----BEGIN")) != NULL) {
 | 
| -            char *trailer = NULL;
 | 
| -            asc = body;
 | 
| -            body = PORT_Strchr(body, '\n');
 | 
| -            if (!body)
 | 
| -                body = PORT_Strchr(asc, '\r'); /* maybe this is a MAC file */
 | 
| -            if (body)
 | 
| -                trailer = strstr(++body, "-----END");
 | 
| -            if (trailer != NULL) {
 | 
| -                *trailer = '\0';
 | 
| -            } else {
 | 
| -                fprintf(stderr, "input has header but no trailer\n");
 | 
| -                PORT_Free(filedata.data);
 | 
| -                return SECFailure;
 | 
| -            }
 | 
| -        } else {
 | 
| -            body = asc;
 | 
| -        }
 | 
| -     
 | 
| -        /* Convert to binary */
 | 
| -        rv = ATOB_ConvertAsciiToItem(der, body);
 | 
| -        if (rv) {
 | 
| -            return SECFailure;
 | 
| -        }
 | 
| -
 | 
| -        PORT_Free(filedata.data);
 | 
| -    } else {
 | 
| -        /* Read in binary der */
 | 
| -        rv = SECU_FileToItem(der, inFile);
 | 
| -        if (rv) {
 | 
| -            return SECFailure;
 | 
| -        }
 | 
| -    }
 | 
| -    return SECSuccess;
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: PKIX_PL_CollectionCertStoreContext_Create
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Creates a new CollectionCertStoreContext using the String pointed to
 | 
| - *  by "storeDir" and stores it at "pColCertStoreContext".
 | 
| - *
 | 
| - * PARAMETERS:
 | 
| - *  "storeDir"
 | 
| - *      The absolute path where *.crl and *.crt files are located.
 | 
| - *  "pColCertStoreContext"
 | 
| - *      Address where object pointer will be stored. Must be non-NULL.
 | 
| - *  "plContext"
 | 
| - *      Platform-specific context pointer.
 | 
| - * THREAD SAFETY:
 | 
| - *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CollectionCertStoreContext Error if the function fails in
 | 
| - *      a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_Create(
 | 
| -        PKIX_PL_String *storeDir,
 | 
| -        PKIX_PL_CollectionCertStoreContext **pColCertStoreContext,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_CollectionCertStoreContext *colCertStoreContext = NULL;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_Create");
 | 
| -        PKIX_NULLCHECK_TWO(storeDir, pColCertStoreContext);
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_PL_Object_Alloc
 | 
| -                    (PKIX_COLLECTIONCERTSTORECONTEXT_TYPE,
 | 
| -                    sizeof (PKIX_PL_CollectionCertStoreContext),
 | 
| -                    (PKIX_PL_Object **)&colCertStoreContext,
 | 
| -                    plContext),
 | 
| -                    PKIX_COULDNOTCREATECOLLECTIONCERTSTORECONTEXTOBJECT);
 | 
| -
 | 
| -        PKIX_INCREF(storeDir);
 | 
| -        colCertStoreContext->storeDir = storeDir;
 | 
| -
 | 
| -        colCertStoreContext->crlList = NULL;
 | 
| -        colCertStoreContext->certList = NULL;
 | 
| -
 | 
| -        *pColCertStoreContext = colCertStoreContext;
 | 
| -        colCertStoreContext = NULL;
 | 
| -
 | 
| -cleanup:
 | 
| -
 | 
| -        PKIX_DECREF(colCertStoreContext);
 | 
| -
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_Destroy
 | 
| - * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_Destroy(
 | 
| -        PKIX_PL_Object *object,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_CollectionCertStoreContext *colCertStoreContext = NULL;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_Destroy");
 | 
| -        PKIX_NULLCHECK_ONE(object);
 | 
| -
 | 
| -        PKIX_CHECK(pkix_CheckType
 | 
| -                    (object, PKIX_COLLECTIONCERTSTORECONTEXT_TYPE, plContext),
 | 
| -                    PKIX_OBJECTNOTCOLLECTIONCERTSTORECONTEXT);
 | 
| -
 | 
| -        colCertStoreContext = (PKIX_PL_CollectionCertStoreContext *)object;
 | 
| -
 | 
| -        PKIX_DECREF(colCertStoreContext->storeDir);
 | 
| -        PKIX_DECREF(colCertStoreContext->crlList);
 | 
| -        PKIX_DECREF(colCertStoreContext->certList);
 | 
| -
 | 
| -cleanup:
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_Hashcode
 | 
| - * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_Hashcode(
 | 
| -        PKIX_PL_Object *object,
 | 
| -        PKIX_UInt32 *pHashcode,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_CollectionCertStoreContext *collectionCSContext = NULL;
 | 
| -        PKIX_UInt32 tempHash = 0;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_Hashcode");
 | 
| -        PKIX_NULLCHECK_TWO(object, pHashcode);
 | 
| -
 | 
| -        PKIX_CHECK(pkix_CheckType
 | 
| -                    (object,
 | 
| -                    PKIX_COLLECTIONCERTSTORECONTEXT_TYPE,
 | 
| -                    plContext),
 | 
| -                    PKIX_OBJECTNOTCOLLECTIONCERTSTORECONTEXT);
 | 
| -
 | 
| -        collectionCSContext = (PKIX_PL_CollectionCertStoreContext *)object;
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_PL_Object_Hashcode
 | 
| -                    ((PKIX_PL_Object *) collectionCSContext->storeDir,
 | 
| -                    &tempHash,
 | 
| -                    plContext),
 | 
| -                   PKIX_STRINGHASHCODEFAILED);
 | 
| -
 | 
| -        *pHashcode = tempHash << 7;
 | 
| -
 | 
| -        /* should not hash on crlList and certList, values are dynamic */
 | 
| -
 | 
| -cleanup:
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_Equals
 | 
| - * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_Equals(
 | 
| -        PKIX_PL_Object *firstObject,
 | 
| -        PKIX_PL_Object *secondObject,
 | 
| -        PKIX_Int32 *pResult,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_CollectionCertStoreContext *firstCCSContext = NULL;
 | 
| -        PKIX_PL_CollectionCertStoreContext *secondCCSContext = NULL;
 | 
| -        PKIX_Boolean cmpResult = 0;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_Equals");
 | 
| -        PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
 | 
| -
 | 
| -        PKIX_CHECK(pkix_CheckTypes
 | 
| -                    (firstObject,
 | 
| -                    secondObject,
 | 
| -                    PKIX_COLLECTIONCERTSTORECONTEXT_TYPE,
 | 
| -                    plContext),
 | 
| -                    PKIX_OBJECTNOTCOLLECTIONCERTSTORECONTEXT);
 | 
| -
 | 
| -        firstCCSContext = (PKIX_PL_CollectionCertStoreContext *)firstObject;
 | 
| -        secondCCSContext = (PKIX_PL_CollectionCertStoreContext *)secondObject;
 | 
| -
 | 
| -        if (firstCCSContext->storeDir == secondCCSContext->storeDir) {
 | 
| -
 | 
| -                cmpResult = PKIX_TRUE;
 | 
| -
 | 
| -        } else {
 | 
| -
 | 
| -                PKIX_CHECK(PKIX_PL_Object_Equals
 | 
| -                    ((PKIX_PL_Object *) firstCCSContext->storeDir,
 | 
| -                    (PKIX_PL_Object *) secondCCSContext->storeDir,
 | 
| -                    &cmpResult,
 | 
| -                    plContext),
 | 
| -                    PKIX_STRINGEQUALSFAILED);
 | 
| -        }
 | 
| -
 | 
| -        *pResult = cmpResult;
 | 
| -
 | 
| -        /* should not check equal on crlList and certList, data are dynamic */
 | 
| -
 | 
| -cleanup:
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStore_CheckTrust
 | 
| - * DESCRIPTION:
 | 
| - * This function checks the trust status of this "cert" that was retrieved
 | 
| - * from the CertStore "store" and returns its trust status at "pTrusted".
 | 
| - *
 | 
| - * PARAMETERS:
 | 
| - * "store"
 | 
| - *      Address of the CertStore. Must be non-NULL.
 | 
| - * "cert"
 | 
| - *      Address of the Cert. Must be non-NULL.
 | 
| - * "pTrusted"
 | 
| - *      Address of PKIX_Boolean where the "cert" trust status is returned.
 | 
| - *      Must be non-NULL.
 | 
| - * "plContext"
 | 
| - *      Platform-specific context pointer
 | 
| - * THREAD SAFETY:
 | 
| - *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CertStore Error if the function fails in a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStore_CheckTrust(
 | 
| -        PKIX_CertStore *store,
 | 
| -        PKIX_PL_Cert *cert,
 | 
| -        PKIX_Boolean *pTrusted,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_ENTER(CERTSTORE, "pkix_pl_CollectionCertStore_CheckTrust");
 | 
| -        PKIX_NULLCHECK_THREE(store, cert, pTrusted);
 | 
| -
 | 
| -        *pTrusted = PKIX_TRUE;
 | 
| -
 | 
| -        PKIX_RETURN(CERTSTORE);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_CreateCert
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Creates Cert using data file path name pointed to by "certFileName" and
 | 
| - *  stores it at "pCert". If the Cert can not be decoded, NULL is stored
 | 
| - *  at "pCert".
 | 
| - *
 | 
| - * PARAMETERS
 | 
| - *  "certFileName" - Address of Cert data file path name. Must be non-NULL.
 | 
| - *  "pCert" - Address where object pointer will be stored. Must be non-NULL.
 | 
| - *  "plContext" - Platform-specific context pointer.
 | 
| - * THREAD SAFETY:
 | 
| - *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CollectionCertStoreContext Error if the function fails in
 | 
| - *              a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_CreateCert(
 | 
| -        const char *certFileName,
 | 
| -        PKIX_PL_Cert **pCert,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_ByteArray *byteArray = NULL;
 | 
| -        PKIX_PL_Cert *cert = NULL;
 | 
| -        PRFileDesc *inFile = NULL;
 | 
| -        SECItem certDER;
 | 
| -        void *buf = NULL;
 | 
| -        PKIX_UInt32 len;
 | 
| -        SECStatus rv;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_CreateCert");
 | 
| -        PKIX_NULLCHECK_TWO(certFileName, pCert);
 | 
| -
 | 
| -        *pCert = NULL;
 | 
| -        certDER.data = NULL;
 | 
| -
 | 
| -        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_Open.\n");
 | 
| -        inFile = PR_Open(certFileName, PR_RDONLY, 0);
 | 
| -
 | 
| -        if (!inFile){
 | 
| -                PKIX_ERROR(PKIX_UNABLETOOPENCERTFILE);
 | 
| -        } else {
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling SECU_ReadDerFromFile.\n");
 | 
| -                rv = SECU_ReadDERFromFile(&certDER, inFile, PR_FALSE);
 | 
| -                if (!rv){
 | 
| -                        buf = (void *)certDER.data;
 | 
| -                        len = certDER.len;
 | 
| -
 | 
| -                        PKIX_CHECK(PKIX_PL_ByteArray_Create
 | 
| -                                    (buf, len, &byteArray, plContext),
 | 
| -                                    PKIX_BYTEARRAYCREATEFAILED);
 | 
| -
 | 
| -                        PKIX_CHECK(PKIX_PL_Cert_Create
 | 
| -                                    (byteArray, &cert, plContext),
 | 
| -                                    PKIX_CERTCREATEFAILED);
 | 
| -
 | 
| -                        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                                ("\t\t Calling SECITEM_FreeItem.\n");
 | 
| -                        SECITEM_FreeItem(&certDER, PR_FALSE);
 | 
| -
 | 
| -                } else {
 | 
| -                        PKIX_ERROR(PKIX_UNABLETOREADDERFROMCERTFILE);
 | 
| -                }
 | 
| -        }
 | 
| -
 | 
| -        *pCert = cert;
 | 
| -
 | 
| -cleanup:
 | 
| -        if (inFile){
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_CloseDir.\n");
 | 
| -                PR_Close(inFile);
 | 
| -        }
 | 
| -
 | 
| -        if (PKIX_ERROR_RECEIVED){
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling SECITEM_FreeItem).\n");
 | 
| -                SECITEM_FreeItem(&certDER, PR_FALSE);
 | 
| -
 | 
| -                PKIX_DECREF(cert);
 | 
| -        }
 | 
| -        PKIX_DECREF(byteArray);
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_CreateCRL
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Creates CRL using data file path name pointed to by "crlFileName" and
 | 
| - *  stores it at "pCrl". If the CRL can not be decoded, NULL is stored
 | 
| - *  at "pCrl".
 | 
| - *
 | 
| - * PARAMETERS
 | 
| - *  "crlFileName" - Address of CRL data file path name. Must be non-NULL.
 | 
| - *  "pCrl" - Address where object pointer will be stored. Must be non-NULL.
 | 
| - *  "plContext" - Platform-specific context pointer.
 | 
| - * THREAD SAFETY:
 | 
| - *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CollectionCertStoreContext Error if the function fails in
 | 
| - *              a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_CreateCRL(
 | 
| -        const char *crlFileName,
 | 
| -        PKIX_PL_CRL **pCrl,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_ByteArray *byteArray = NULL;
 | 
| -        PKIX_PL_CRL *crl = NULL;
 | 
| -        PRFileDesc *inFile = NULL;
 | 
| -        SECItem crlDER;
 | 
| -        void *buf = NULL;
 | 
| -        PKIX_UInt32 len;
 | 
| -        SECStatus rv;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_CreateCRL");
 | 
| -        PKIX_NULLCHECK_TWO(crlFileName, pCrl);
 | 
| -
 | 
| -        *pCrl = NULL;
 | 
| -        crlDER.data = NULL;
 | 
| -
 | 
| -        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_Open.\n");
 | 
| -        inFile = PR_Open(crlFileName, PR_RDONLY, 0);
 | 
| -
 | 
| -        if (!inFile){
 | 
| -                PKIX_ERROR(PKIX_UNABLETOOPENCRLFILE);
 | 
| -        } else {
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling SECU_ReadDerFromFile.\n");
 | 
| -                rv = SECU_ReadDERFromFile(&crlDER, inFile, PR_FALSE);
 | 
| -                if (!rv){
 | 
| -                        buf = (void *)crlDER.data;
 | 
| -                        len = crlDER.len;
 | 
| -
 | 
| -                        PKIX_CHECK(PKIX_PL_ByteArray_Create
 | 
| -                                (buf, len, &byteArray, plContext),
 | 
| -                                PKIX_BYTEARRAYCREATEFAILED);
 | 
| -
 | 
| -                        PKIX_CHECK(PKIX_PL_CRL_Create
 | 
| -                                (byteArray, &crl, plContext),
 | 
| -                                PKIX_CRLCREATEFAILED);
 | 
| -
 | 
| -                        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                                ("\t\t Calling SECITEM_FreeItem.\n");
 | 
| -                        SECITEM_FreeItem(&crlDER, PR_FALSE);
 | 
| -
 | 
| -                } else {
 | 
| -                        PKIX_ERROR(PKIX_UNABLETOREADDERFROMCRLFILE);
 | 
| -                }
 | 
| -        }
 | 
| -
 | 
| -        *pCrl = crl;
 | 
| -
 | 
| -cleanup:
 | 
| -        if (inFile){
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_CloseDir.\n");
 | 
| -                PR_Close(inFile);
 | 
| -        }
 | 
| -
 | 
| -        if (PKIX_ERROR_RECEIVED){
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling SECITEM_FreeItem).\n");
 | 
| -                SECITEM_FreeItem(&crlDER, PR_FALSE);
 | 
| -
 | 
| -                PKIX_DECREF(crl);
 | 
| -                if (crlDER.data != NULL) {
 | 
| -                        SECITEM_FreeItem(&crlDER, PR_FALSE);
 | 
| -                }
 | 
| -        }
 | 
| -
 | 
| -        PKIX_DECREF(byteArray);
 | 
| -
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_PopulateCert
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Create list of Certs from *.crt files at directory specified in dirName,
 | 
| - *  Not recursive to sub-directory. Also assume the directory contents are
 | 
| - *  not changed dynamically.
 | 
| - *
 | 
| - * PARAMETERS
 | 
| - *  "colCertStoreContext" - Address of CollectionCertStoreContext
 | 
| - *              where the dirName is specified and where the return
 | 
| - *              Certs are stored as a list. Must be non-NULL.
 | 
| - *  "plContext" - Platform-specific context pointer.
 | 
| - *
 | 
| - * THREAD SAFETY:
 | 
| - *  Not Thread Safe - A lock at top level is required.
 | 
| - *
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CollectionCertStoreContext Error if the function fails in
 | 
| - *              a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_PopulateCert(
 | 
| -        PKIX_PL_CollectionCertStoreContext *colCertStoreContext,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_List *certList = NULL;
 | 
| -        PKIX_PL_Cert *certItem = NULL;
 | 
| -        char *dirName = NULL;
 | 
| -        char *pathName = NULL;
 | 
| -        PKIX_UInt32 dirNameLen = 0;
 | 
| -        PRErrorCode prError = 0;
 | 
| -        PRDir *dir = NULL;
 | 
| -        PRDirEntry *dirEntry = NULL;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_PopulateCert");
 | 
| -        PKIX_NULLCHECK_ONE(colCertStoreContext);
 | 
| -
 | 
| -        /* convert directory to ascii */
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_PL_String_GetEncoded
 | 
| -                    (colCertStoreContext->storeDir,
 | 
| -                    PKIX_ESCASCII,
 | 
| -                    (void **)&dirName,
 | 
| -                    &dirNameLen,
 | 
| -                    plContext),
 | 
| -                    PKIX_STRINGGETENCODEDFAILED);
 | 
| -
 | 
| -        /* create cert list, if no cert file, should return an empty list */
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_List_Create(&certList, plContext),
 | 
| -                    PKIX_LISTCREATEFAILED);
 | 
| -
 | 
| -        /* open directory and read in .crt files */
 | 
| -
 | 
| -        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_OpenDir.\n");
 | 
| -        dir = PR_OpenDir(dirName);
 | 
| -
 | 
| -        if (!dir) {
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG_ARG
 | 
| -                        ("\t\t Directory Name:%s\n", dirName);
 | 
| -                PKIX_ERROR(PKIX_CANNOTOPENCOLLECTIONCERTSTORECONTEXTDIRECTORY);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_ReadDir.\n");
 | 
| -        dirEntry = PR_ReadDir(dir, PR_SKIP_HIDDEN | PR_SKIP_BOTH);
 | 
| -
 | 
| -        if (!dirEntry) {
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Empty directory.\n");
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_GetError.\n");
 | 
| -                prError = PR_GetError();
 | 
| -        }
 | 
| -
 | 
| -        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_SetError.\n");
 | 
| -        PR_SetError(0, 0);
 | 
| -
 | 
| -        while (dirEntry != NULL && prError == 0) {
 | 
| -                if (PL_strrstr(dirEntry->name, ".crt") ==
 | 
| -                    dirEntry->name + PL_strlen(dirEntry->name) - 4) {
 | 
| -
 | 
| -                        PKIX_CHECK_ONLY_FATAL
 | 
| -                                (PKIX_PL_Malloc
 | 
| -                                (dirNameLen + PL_strlen(dirEntry->name) + 2,
 | 
| -                                (void **)&pathName,
 | 
| -                                plContext),
 | 
| -                                PKIX_MALLOCFAILED);
 | 
| -
 | 
| -                        if ((!PKIX_ERROR_RECEIVED) && (pathName != NULL)){
 | 
| -
 | 
| -                                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                                    ("\t\t Calling PL_strcpy for dirName.\n");
 | 
| -                                PL_strcpy(pathName, dirName);
 | 
| -                                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                                    ("\t\t Calling PL_strcat for dirName.\n");
 | 
| -                                PL_strcat(pathName, "/");
 | 
| -                                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                                        ("\t\t Calling PL_strcat for /.\n");
 | 
| -                                PL_strcat(pathName, dirEntry->name);
 | 
| -
 | 
| -                                PKIX_CHECK_ONLY_FATAL
 | 
| -                                (pkix_pl_CollectionCertStoreContext_CreateCert
 | 
| -                                    (pathName, &certItem, plContext),
 | 
| -                              PKIX_COLLECTIONCERTSTORECONTEXTCREATECERTFAILED);
 | 
| -
 | 
| -                                if (!PKIX_ERROR_RECEIVED){
 | 
| -                                        PKIX_CHECK_ONLY_FATAL
 | 
| -                                                (PKIX_List_AppendItem
 | 
| -                                                (certList,
 | 
| -                                                (PKIX_PL_Object *)certItem,
 | 
| -                                                plContext),
 | 
| -                                                PKIX_LISTAPPENDITEMFAILED);
 | 
| -                                }
 | 
| -                        }
 | 
| -
 | 
| -                        PKIX_DECREF(certItem);
 | 
| -                        PKIX_FREE(pathName);
 | 
| -                }
 | 
| -
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_SetError.\n");
 | 
| -                PR_SetError(0, 0);
 | 
| -
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_ReadDir.\n");
 | 
| -                dirEntry = PR_ReadDir(dir, PR_SKIP_HIDDEN | PR_SKIP_BOTH);
 | 
| -
 | 
| -                if (!dirEntry) {
 | 
| -                    PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_GetError.\n");
 | 
| -                    prError = PR_GetError();
 | 
| -                }
 | 
| -        }
 | 
| -
 | 
| -        if ((prError != 0) && (prError != PR_NO_MORE_FILES_ERROR)) {
 | 
| -                PKIX_ERROR(PKIX_COLLECTIONCERTSTOREPOPULATECERTFAILED);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_List_SetImmutable(certList, plContext),
 | 
| -                    PKIX_LISTSETIMMUTABLEFAILED);
 | 
| -
 | 
| -        PKIX_INCREF(certList);
 | 
| -        colCertStoreContext->certList = certList;
 | 
| -
 | 
| -cleanup:
 | 
| -        if (dir) {
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_CloseDir.\n");
 | 
| -                PR_CloseDir(dir);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_FREE(pathName);
 | 
| -        PKIX_FREE(dirName);
 | 
| -
 | 
| -        if (PKIX_ERROR_RECEIVED){
 | 
| -                PKIX_DECREF(certList);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_DECREF(certItem);
 | 
| -        PKIX_DECREF(certList);
 | 
| -
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_PopulateCRL
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Create list of CRLs from *.crl files at directory specified in dirName,
 | 
| - *  Not recursive to sub-dirctory. Also assume the directory contents are
 | 
| - *  not changed dynamically.
 | 
| - *
 | 
| - * PARAMETERS
 | 
| - *  "colCertStoreContext" - Address of CollectionCertStoreContext
 | 
| - *              where the dirName is specified and where the return
 | 
| - *              CRLs are stored as a list. Must be non-NULL.
 | 
| - *  "plContext" - Platform-specific context pointer.
 | 
| - *
 | 
| - * THREAD SAFETY:
 | 
| - *  Not Thread Safe - A lock at top level is required.
 | 
| - *
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CollectionCertStoreContext Error if the function fails in
 | 
| - *              a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_PopulateCRL(
 | 
| -        PKIX_PL_CollectionCertStoreContext *colCertStoreContext,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_List *crlList = NULL;
 | 
| -        PKIX_PL_CRL *crlItem = NULL;
 | 
| -        char *dirName = NULL;
 | 
| -        char *pathName = NULL;
 | 
| -        PKIX_UInt32 dirNameLen = 0;
 | 
| -        PRErrorCode prError = 0;
 | 
| -        PRDir *dir = NULL;
 | 
| -        PRDirEntry *dirEntry = NULL;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_PopulateCRL");
 | 
| -        PKIX_NULLCHECK_ONE(colCertStoreContext);
 | 
| -
 | 
| -        /* convert directory to ascii */
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_PL_String_GetEncoded
 | 
| -                    (colCertStoreContext->storeDir,
 | 
| -                    PKIX_ESCASCII,
 | 
| -                    (void **)&dirName,
 | 
| -                    &dirNameLen,
 | 
| -                    plContext),
 | 
| -                    PKIX_STRINGGETENCODEDFAILED);
 | 
| -
 | 
| -        /* create CRL list, if no CRL file, should return an empty list */
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_List_Create(&crlList, plContext),
 | 
| -                    PKIX_LISTCREATEFAILED);
 | 
| -
 | 
| -        /* open directory and read in .crl files */
 | 
| -
 | 
| -        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_OpenDir.\n");
 | 
| -        dir = PR_OpenDir(dirName);
 | 
| -
 | 
| -        if (!dir) {
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG_ARG
 | 
| -                        ("\t\t Directory Name:%s\n", dirName);
 | 
| -                PKIX_ERROR(PKIX_CANNOTOPENCOLLECTIONCERTSTORECONTEXTDIRECTORY);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_ReadDir.\n");
 | 
| -        dirEntry = PR_ReadDir(dir, PR_SKIP_HIDDEN | PR_SKIP_BOTH);
 | 
| -
 | 
| -        if (!dirEntry) {
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Empty directory.\n");
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_GetError.\n");
 | 
| -                prError = PR_GetError();
 | 
| -        }
 | 
| -
 | 
| -        PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG("\t\t Calling PR_SetError.\n");
 | 
| -        PR_SetError(0, 0);
 | 
| -
 | 
| -        while (dirEntry != NULL && prError == 0) {
 | 
| -                if (PL_strrstr(dirEntry->name, ".crl") ==
 | 
| -                    dirEntry->name + PL_strlen(dirEntry->name) - 4) {
 | 
| -
 | 
| -                        PKIX_CHECK_ONLY_FATAL
 | 
| -                                (PKIX_PL_Malloc
 | 
| -                                (dirNameLen + PL_strlen(dirEntry->name) + 2,
 | 
| -                                (void **)&pathName,
 | 
| -                                plContext),
 | 
| -                                PKIX_MALLOCFAILED);
 | 
| -
 | 
| -                        if ((!PKIX_ERROR_RECEIVED) && (pathName != NULL)){
 | 
| -
 | 
| -                                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                                    ("\t\t Calling PL_strcpy for dirName.\n");
 | 
| -                                PL_strcpy(pathName, dirName);
 | 
| -                                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                                    ("\t\t Calling PL_strcat for dirName.\n");
 | 
| -                                PL_strcat(pathName, "/");
 | 
| -                                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                                        ("\t\t Calling PL_strcat for /.\n");
 | 
| -                                PL_strcat(pathName, dirEntry->name);
 | 
| -
 | 
| -                        PKIX_CHECK_ONLY_FATAL
 | 
| -                                (pkix_pl_CollectionCertStoreContext_CreateCRL
 | 
| -                                (pathName, &crlItem, plContext),
 | 
| -                                PKIX_COLLECTIONCERTSTORECONTEXTCREATECRLFAILED);
 | 
| -
 | 
| -                                if (!PKIX_ERROR_RECEIVED){
 | 
| -                                        PKIX_CHECK_ONLY_FATAL
 | 
| -                                                (PKIX_List_AppendItem
 | 
| -                                                (crlList,
 | 
| -                                                (PKIX_PL_Object *)crlItem,
 | 
| -                                                plContext),
 | 
| -                                                PKIX_LISTAPPENDITEMFAILED);
 | 
| -                                }
 | 
| -                        }
 | 
| -
 | 
| -                        PKIX_DECREF(crlItem);
 | 
| -                        PKIX_FREE(pathName);
 | 
| -                }
 | 
| -
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_SetError.\n");
 | 
| -                PR_SetError(0, 0);
 | 
| -
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_ReadDir.\n");
 | 
| -                dirEntry = PR_ReadDir(dir, PR_SKIP_HIDDEN | PR_SKIP_BOTH);
 | 
| -
 | 
| -                if (!dirEntry) {
 | 
| -                    PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_GetError.\n");
 | 
| -                    prError = PR_GetError();
 | 
| -                }
 | 
| -        }
 | 
| -
 | 
| -        if ((prError != 0) && (prError != PR_NO_MORE_FILES_ERROR)) {
 | 
| -                PKIX_ERROR(PKIX_COLLECTIONCERTSTORECONTEXTGETSELECTCRLFAILED);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_List_SetImmutable(crlList, plContext),
 | 
| -                    PKIX_LISTSETIMMUTABLEFAILED);
 | 
| -
 | 
| -        PKIX_INCREF(crlList);
 | 
| -        colCertStoreContext->crlList = crlList;
 | 
| -
 | 
| -cleanup:
 | 
| -        if (dir) {
 | 
| -                PKIX_COLLECTIONCERTSTORECONTEXT_DEBUG
 | 
| -                        ("\t\t Calling PR_CloseDir.\n");
 | 
| -                PR_CloseDir(dir);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_FREE(pathName);
 | 
| -        PKIX_FREE(dirName);
 | 
| -
 | 
| -        if (PKIX_ERROR_RECEIVED){
 | 
| -                PKIX_DECREF(crlList);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_DECREF(crlItem);
 | 
| -        PKIX_DECREF(crlList);
 | 
| -
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_GetSelectedCert
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Finds the Certs that match the criterion of the CertSelector pointed
 | 
| - *  to by "selector" using the List of Certs pointed to by "certList" and
 | 
| - *  stores the matching Certs at "pSelectedCertList".
 | 
| - *
 | 
| - *  Not recursive to sub-directory.
 | 
| - *
 | 
| - * PARAMETERS
 | 
| - *  "certList" - Address of List of Certs to be searched. Must be non-NULL.
 | 
| - *  "colCertStoreContext" - Address of CollectionCertStoreContext
 | 
| - *              where the cached Certs are stored.
 | 
| - *  "selector" - CertSelector for chosing Cert based on Params set
 | 
| - *  "pSelectedCertList" - Certs that qualified by selector.
 | 
| - *  "plContext" - Platform-specific context pointer.
 | 
| - *
 | 
| - * THREAD SAFETY:
 | 
| - *  Not Thread Safe - A lock at top level is required.
 | 
| - *
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CollectionCertStoreContext Error if the function fails in
 | 
| - *              a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_GetSelectedCert(
 | 
| -        PKIX_List *certList,
 | 
| -        PKIX_CertSelector *selector,
 | 
| -        PKIX_List **pSelectedCertList,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_List *selectCertList = NULL;
 | 
| -        PKIX_PL_Cert *certItem = NULL;
 | 
| -        PKIX_CertSelector_MatchCallback certSelectorMatch = NULL;
 | 
| -        PKIX_UInt32 numCerts = 0;
 | 
| -        PKIX_UInt32 i = 0;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_GetSelectedCert");
 | 
| -        PKIX_NULLCHECK_THREE(certList, selector, pSelectedCertList);
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_CertSelector_GetMatchCallback
 | 
| -                    (selector, &certSelectorMatch, plContext),
 | 
| -                    PKIX_CERTSELECTORGETMATCHCALLBACKFAILED);
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_List_GetLength(certList, &numCerts, plContext),
 | 
| -                    PKIX_LISTGETLENGTHFAILED);
 | 
| -
 | 
| -        if (certSelectorMatch) {
 | 
| -
 | 
| -                PKIX_CHECK(PKIX_List_Create(&selectCertList, plContext),
 | 
| -                            PKIX_LISTCREATEFAILED);
 | 
| -
 | 
| -                for (i = 0; i < numCerts; i++) {
 | 
| -                        PKIX_CHECK_ONLY_FATAL
 | 
| -                                (PKIX_List_GetItem
 | 
| -                                (certList,
 | 
| -                                i,
 | 
| -                                (PKIX_PL_Object **) &certItem,
 | 
| -                                plContext),
 | 
| -                                PKIX_LISTGETITEMFAILED);
 | 
| -
 | 
| -                        if (!PKIX_ERROR_RECEIVED){
 | 
| -                                PKIX_CHECK_ONLY_FATAL
 | 
| -                                        (certSelectorMatch
 | 
| -                                        (selector, certItem, plContext),
 | 
| -                                        PKIX_CERTSELECTORMATCHFAILED);
 | 
| -
 | 
| -                                if (!PKIX_ERROR_RECEIVED){
 | 
| -                                        PKIX_CHECK_ONLY_FATAL
 | 
| -                                                (PKIX_List_AppendItem
 | 
| -                                                (selectCertList,
 | 
| -                                                (PKIX_PL_Object *)certItem,
 | 
| -                                                plContext),
 | 
| -                                                PKIX_LISTAPPENDITEMFAILED);
 | 
| -                                }
 | 
| -                        }
 | 
| -
 | 
| -                        PKIX_DECREF(certItem);
 | 
| -                }
 | 
| -
 | 
| -        } else {
 | 
| -
 | 
| -                PKIX_INCREF(certList);
 | 
| -
 | 
| -                selectCertList = certList;
 | 
| -        }
 | 
| -
 | 
| -        *pSelectedCertList = selectCertList;
 | 
| -
 | 
| -cleanup:
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_GetSelectedCRL
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Finds the CRLs that match the criterion of the CRLSelector pointed
 | 
| - *  to by "selector" using the List of CRLs pointed to by "crlList" and
 | 
| - *  stores the matching CRLs at "pSelectedCrlList".
 | 
| - *
 | 
| - *  Not recursive to sub-directory.
 | 
| - *
 | 
| - * PARAMETERS
 | 
| - *  "crlList" - Address of List of CRLs to be searched. Must be non-NULL
 | 
| - *  "selector" - CRLSelector for chosing CRL based on Params set
 | 
| - *  "pSelectedCrlList" - CRLs that qualified by selector.
 | 
| - *  "plContext" - Platform-specific context pointer.
 | 
| - *
 | 
| - * THREAD SAFETY:
 | 
| - *  Not Thread Safe - A lock at top level is required.
 | 
| - *
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CollectionCertStoreContext Error if the function fails in
 | 
| - *              a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -static PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_GetSelectedCRL(
 | 
| -        PKIX_List *crlList,
 | 
| -        PKIX_CRLSelector *selector,
 | 
| -        PKIX_List **pSelectedCrlList,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_List *selectCrlList = NULL;
 | 
| -        PKIX_PL_CRL *crlItem = NULL;
 | 
| -        PKIX_CRLSelector_MatchCallback crlSelectorMatch = NULL;
 | 
| -        PKIX_UInt32 numCrls = 0;
 | 
| -        PKIX_UInt32 i = 0;
 | 
| -        PKIX_Boolean match = PKIX_FALSE;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_GetSelectedCRL");
 | 
| -        PKIX_NULLCHECK_THREE(crlList, selector, pSelectedCrlList);
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_CRLSelector_GetMatchCallback
 | 
| -                    (selector, &crlSelectorMatch, plContext),
 | 
| -                    PKIX_CRLSELECTORGETMATCHCALLBACKFAILED);
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_List_GetLength(crlList, &numCrls, plContext),
 | 
| -                    PKIX_LISTGETLENGTHFAILED);
 | 
| -
 | 
| -        if (crlSelectorMatch) {
 | 
| -
 | 
| -                PKIX_CHECK(PKIX_List_Create(&selectCrlList, plContext),
 | 
| -                            PKIX_LISTCREATEFAILED);
 | 
| -
 | 
| -                for (i = 0; i < numCrls; i++) {
 | 
| -                        PKIX_CHECK_ONLY_FATAL(PKIX_List_GetItem
 | 
| -                                (crlList,
 | 
| -                                i,
 | 
| -                                (PKIX_PL_Object **) &crlItem,
 | 
| -                                plContext),
 | 
| -                                PKIX_LISTGETITEMFAILED);
 | 
| -
 | 
| -                        if (!PKIX_ERROR_RECEIVED){
 | 
| -                                PKIX_CHECK_ONLY_FATAL
 | 
| -                                        (crlSelectorMatch
 | 
| -                                        (selector, crlItem, &match, plContext),
 | 
| -                                        PKIX_CRLSELECTORMATCHFAILED);
 | 
| -
 | 
| -                                if (!(PKIX_ERROR_RECEIVED) && match) {
 | 
| -                                        PKIX_CHECK_ONLY_FATAL
 | 
| -                                                (PKIX_List_AppendItem
 | 
| -                                                (selectCrlList,
 | 
| -                                                (PKIX_PL_Object *)crlItem,
 | 
| -                                                plContext),
 | 
| -                                                PKIX_LISTAPPENDITEMFAILED);
 | 
| -                                }
 | 
| -                        }
 | 
| -
 | 
| -                        PKIX_DECREF(crlItem);
 | 
| -                }
 | 
| -        } else {
 | 
| -
 | 
| -                PKIX_INCREF(crlList);
 | 
| -
 | 
| -                selectCrlList = crlList;
 | 
| -        }
 | 
| -
 | 
| -        /* Don't throw away the list if one CRL was bad! */
 | 
| -        pkixTempErrorReceived = PKIX_FALSE;
 | 
| -
 | 
| -        *pSelectedCrlList = selectCrlList;
 | 
| -
 | 
| -cleanup:
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStore_GetCert
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Retrieve Certs in a list of PKIX_PL_Cert object.
 | 
| - *
 | 
| - * PARAMETERS:
 | 
| - *  "colCertStoreContext"
 | 
| - *      The object CertStore is the object passed in by checker call.
 | 
| - *  "crlSelector"
 | 
| - *      CRLSelector specifies criteria for chosing CRL's
 | 
| - *  "pNBIOContext"
 | 
| - *      Address where platform-dependent information is returned for CertStores
 | 
| - *      that use non-blocking I/O. Must be non-NULL.
 | 
| - *  "pCertList"
 | 
| - *      Address where object pointer will be returned. Must be non-NULL.
 | 
| - *  "plContext"
 | 
| - *      Platform-specific context pointer.
 | 
| - * THREAD SAFETY:
 | 
| - *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CertStore Error if the function fails in
 | 
| - *      a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -PKIX_Error *
 | 
| -pkix_pl_CollectionCertStore_GetCert(
 | 
| -        PKIX_CertStore *certStore,
 | 
| -        PKIX_CertSelector *selector,
 | 
| -        PKIX_VerifyNode *verifyNode,
 | 
| -        void **pNBIOContext,
 | 
| -        PKIX_List **pCerts,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_CollectionCertStoreContext *colCertStoreContext = NULL;
 | 
| -        PKIX_List *selectedCerts = NULL;
 | 
| -
 | 
| -        PKIX_ENTER(CERTSTORE, "pkix_pl_CollectionCertStore_GetCert");
 | 
| -        PKIX_NULLCHECK_FOUR(certStore, selector, pNBIOContext, pCerts);
 | 
| -
 | 
| -        *pNBIOContext = NULL;   /* We don't use non-blocking I/O */
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_CertStore_GetCertStoreContext
 | 
| -                    (certStore,
 | 
| -                    (PKIX_PL_Object **) &colCertStoreContext,
 | 
| -                    plContext),
 | 
| -                    PKIX_CERTSTOREGETCERTSTORECONTEXTFAILED);
 | 
| -
 | 
| -        if (colCertStoreContext->certList == NULL) {
 | 
| -
 | 
| -                PKIX_OBJECT_LOCK(colCertStoreContext);
 | 
| -
 | 
| -                /*
 | 
| -                 * Certs in the directory are cached based on the
 | 
| -                 * assumption that the directory contents won't be
 | 
| -                 * changed dynamically.
 | 
| -                 */
 | 
| -                if (colCertStoreContext->certList == NULL){
 | 
| -                    PKIX_CHECK(pkix_pl_CollectionCertStoreContext_PopulateCert
 | 
| -                            (colCertStoreContext, plContext),
 | 
| -                            PKIX_COLLECTIONCERTSTORECONTEXTPOPULATECERTFAILED);
 | 
| -                }
 | 
| -
 | 
| -                PKIX_OBJECT_UNLOCK(colCertStoreContext);
 | 
| -        }
 | 
| -
 | 
| -        PKIX_CHECK(pkix_pl_CollectionCertStoreContext_GetSelectedCert
 | 
| -                    (colCertStoreContext->certList,
 | 
| -                    selector,
 | 
| -                    &selectedCerts,
 | 
| -                    plContext),
 | 
| -                    PKIX_COLLECTIONCERTSTORECONTEXTGETSELECTCERTFAILED);
 | 
| -
 | 
| -        *pCerts = selectedCerts;
 | 
| -
 | 
| -cleanup:
 | 
| -	PKIX_OBJECT_UNLOCK(lockedObject);
 | 
| -        PKIX_DECREF(colCertStoreContext);
 | 
| -        PKIX_RETURN(CERTSTORE);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStore_GetCRL
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Retrieve CRL's in a list of PKIX_PL_CRL object.
 | 
| - *
 | 
| - * PARAMETERS:
 | 
| - *  "colCertStoreContext"
 | 
| - *      The object CertStore is passed in by checker call.
 | 
| - *  "crlSelector"
 | 
| - *      CRLSelector specifies criteria for chosing CRL's
 | 
| - *  "pNBIOContext"
 | 
| - *      Address where platform-dependent information is returned for CertStores
 | 
| - *      that use non-blocking I/O. Must be non-NULL.
 | 
| - *  "pCrlList"
 | 
| - *      Address where object pointer will be returned. Must be non-NULL.
 | 
| - *  "plContext"
 | 
| - *      Platform-specific context pointer.
 | 
| - * THREAD SAFETY:
 | 
| - *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
 | 
| - * RETURNS:
 | 
| - *  Returns NULL if the function succeeds.
 | 
| - *  Returns a CertStore Error if the function fails in
 | 
| - *      a non-fatal way.
 | 
| - *  Returns a Fatal Error if the function fails in an unrecoverable way.
 | 
| - */
 | 
| -PKIX_Error *
 | 
| -pkix_pl_CollectionCertStore_GetCRL(
 | 
| -        PKIX_CertStore *certStore,
 | 
| -        PKIX_CRLSelector *selector,
 | 
| -        void **pNBIOContext,
 | 
| -        PKIX_List **pCrlList,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_CollectionCertStoreContext *colCertStoreContext = NULL;
 | 
| -        PKIX_List *selectCrl = NULL;
 | 
| -
 | 
| -        PKIX_ENTER(CERTSTORE, "pkix_pl_CollectionCertStore_GetCRL");
 | 
| -        PKIX_NULLCHECK_FOUR(certStore, selector, pNBIOContext, pCrlList);
 | 
| -
 | 
| -        *pNBIOContext = NULL;   /* We don't use non-blocking I/O */
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_CertStore_GetCertStoreContext
 | 
| -                    (certStore,
 | 
| -                    (PKIX_PL_Object **) &colCertStoreContext,
 | 
| -                    plContext),
 | 
| -                    PKIX_CERTSTOREGETCERTSTORECONTEXTFAILED);
 | 
| -
 | 
| -        if (colCertStoreContext->crlList == NULL) {
 | 
| -
 | 
| -                PKIX_OBJECT_LOCK(colCertStoreContext);
 | 
| -
 | 
| -                /*
 | 
| -                 * CRLs in the directory are cached based on the
 | 
| -                 * assumption that the directory contents won't be
 | 
| -                 * changed dynamically.
 | 
| -                 */
 | 
| -                if (colCertStoreContext->crlList == NULL){
 | 
| -                    PKIX_CHECK(pkix_pl_CollectionCertStoreContext_PopulateCRL
 | 
| -                            (colCertStoreContext, plContext),
 | 
| -                            PKIX_COLLECTIONCERTSTORECONTEXTPOPULATECRLFAILED);
 | 
| -                }
 | 
| -
 | 
| -                PKIX_OBJECT_UNLOCK(colCertStoreContext);
 | 
| -
 | 
| -        }
 | 
| -
 | 
| -        PKIX_CHECK(pkix_pl_CollectionCertStoreContext_GetSelectedCRL
 | 
| -                    (colCertStoreContext->crlList,
 | 
| -                    selector,
 | 
| -                    &selectCrl,
 | 
| -                    plContext),
 | 
| -                    PKIX_COLLECTIONCERTSTORECONTEXTGETSELECTCRLFAILED);
 | 
| -
 | 
| -        *pCrlList = selectCrl;
 | 
| -
 | 
| -cleanup:
 | 
| -	PKIX_OBJECT_UNLOCK(lockedObject);
 | 
| -        PKIX_DECREF(colCertStoreContext);
 | 
| -        PKIX_RETURN(CERTSTORE);
 | 
| -}
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: pkix_pl_CollectionCertStoreContext_RegisterSelf
 | 
| - * DESCRIPTION:
 | 
| - *
 | 
| - *  Registers PKIX_PL_COLLECTIONCERTSTORECONTEXT_TYPE and its related
 | 
| - *  functions with systemClasses[]
 | 
| - *
 | 
| - * THREAD SAFETY:
 | 
| - *  Not Thread Safe - for performance and complexity reasons
 | 
| - *
 | 
| - *  Since this function is only called by PKIX_PL_Initialize, which should
 | 
| - *  only be called once, it is acceptable that this function is not
 | 
| - *  thread-safe.
 | 
| - */
 | 
| -PKIX_Error *
 | 
| -pkix_pl_CollectionCertStoreContext_RegisterSelf(void *plContext)
 | 
| -{
 | 
| -        extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
 | 
| -        pkix_ClassTable_Entry entry;
 | 
| -
 | 
| -        PKIX_ENTER(COLLECTIONCERTSTORECONTEXT,
 | 
| -                    "pkix_pl_CollectionCertStoreContext_RegisterSelf");
 | 
| -
 | 
| -        entry.description = "CollectionCertStoreContext";
 | 
| -        entry.objCounter = 0;
 | 
| -        entry.typeObjectSize = sizeof(PKIX_PL_CollectionCertStoreContext);
 | 
| -        entry.destructor = pkix_pl_CollectionCertStoreContext_Destroy;
 | 
| -        entry.equalsFunction = pkix_pl_CollectionCertStoreContext_Equals;
 | 
| -        entry.hashcodeFunction = pkix_pl_CollectionCertStoreContext_Hashcode;
 | 
| -        entry.toStringFunction = NULL;
 | 
| -        entry.comparator = NULL;
 | 
| -        entry.duplicateFunction = NULL;
 | 
| -
 | 
| -        systemClasses[PKIX_COLLECTIONCERTSTORECONTEXT_TYPE] = entry;
 | 
| -
 | 
| -        PKIX_RETURN(COLLECTIONCERTSTORECONTEXT);
 | 
| -}
 | 
| -
 | 
| -/* --Public-CollectionCertStoreContext-Functions--------------------------- */
 | 
| -
 | 
| -/*
 | 
| - * FUNCTION: PKIX_PL_CollectionCertStore_Create
 | 
| - * (see comments in pkix_samples_modules.h)
 | 
| - */
 | 
| -PKIX_Error *
 | 
| -PKIX_PL_CollectionCertStore_Create(
 | 
| -        PKIX_PL_String *storeDir,
 | 
| -        PKIX_CertStore **pCertStore,
 | 
| -        void *plContext)
 | 
| -{
 | 
| -        PKIX_PL_CollectionCertStoreContext *colCertStoreContext = NULL;
 | 
| -        PKIX_CertStore *certStore = NULL;
 | 
| -
 | 
| -        PKIX_ENTER(CERTSTORE, "PKIX_PL_CollectionCertStore_Create");
 | 
| -        PKIX_NULLCHECK_TWO(storeDir, pCertStore);
 | 
| -
 | 
| -        PKIX_CHECK(pkix_pl_CollectionCertStoreContext_Create
 | 
| -                    (storeDir, &colCertStoreContext, plContext),
 | 
| -                    PKIX_COULDNOTCREATECOLLECTIONCERTSTORECONTEXTOBJECT);
 | 
| -
 | 
| -        PKIX_CHECK(PKIX_CertStore_Create
 | 
| -                    (pkix_pl_CollectionCertStore_GetCert,
 | 
| -                    pkix_pl_CollectionCertStore_GetCRL,
 | 
| -                    NULL, /* GetCertContinue */
 | 
| -                    NULL, /* GetCRLContinue */
 | 
| -                    pkix_pl_CollectionCertStore_CheckTrust,
 | 
| -                    NULL,      /* can not store crls */
 | 
| -                    NULL,      /* can not do revocation check */
 | 
| -                    (PKIX_PL_Object *)colCertStoreContext,
 | 
| -                    PKIX_TRUE, /* cache flag */
 | 
| -                    PKIX_TRUE, /* local - no network I/O */
 | 
| -                    &certStore,
 | 
| -                    plContext),
 | 
| -                    PKIX_CERTSTORECREATEFAILED);
 | 
| -
 | 
| -        PKIX_DECREF(colCertStoreContext);
 | 
| -
 | 
| -        *pCertStore = certStore;
 | 
| -
 | 
| -cleanup:
 | 
| -        PKIX_RETURN(CERTSTORE);
 | 
| -}
 | 
| 
 |