The Tor Browser: security/nss/lib/libpkix/pkix/store/pkix

Incorporate requested changes from Mozilla in review:
https://bugzilla.mozilla.org/show_bug.cgi?id=1123480#c6

     1 /* This Source Code Form is subject to the terms of the Mozilla Public

     2  * License, v. 2.0. If a copy of the MPL was not distributed with this

     3  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */

     4 /*

     5  * pkix_store.c

     6  *

     7  * CertStore Function Definitions

     8  *

     9  */

    11 #include "pkix_store.h"

    13 /* --CertStore-Private-Functions----------------------------------------- */

    15 /*

    16  * FUNCTION: pkix_CertStore_Destroy

    17  * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)

    18  */

    19 static PKIX_Error *

    20 pkix_CertStore_Destroy(

    21         PKIX_PL_Object *object,

    22         void *plContext)

    23 {

    24         PKIX_CertStore *certStore = NULL;

    26         PKIX_ENTER(CERTSTORE, "pkix_CertStore_Destroy");

    27         PKIX_NULLCHECK_ONE(object);

    29         /* Check that this object is a CertStore object */

    30         PKIX_CHECK(pkix_CheckType(object, PKIX_CERTSTORE_TYPE, plContext),

    31                 PKIX_OBJECTNOTCERTSTORE);

    33         certStore = (PKIX_CertStore *)object;

    35         certStore->certCallback = NULL;

    36         certStore->crlCallback = NULL;

    37         certStore->certContinue = NULL;

    38         certStore->crlContinue = NULL;

    39         certStore->trustCallback = NULL;

    41         PKIX_DECREF(certStore->certStoreContext);

    43 cleanup:

    45         PKIX_RETURN(CERTSTORE);

    46 }

    48 /*

    49  * FUNCTION: pkix_CertStore_Hashcode

    50  * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)

    51  */

    52 static PKIX_Error *

    53 pkix_CertStore_Hashcode(

    54         PKIX_PL_Object *object,

    55         PKIX_UInt32 *pHashcode,

    56         void *plContext)

    57 {

    58         PKIX_CertStore *certStore = NULL;

    59         PKIX_UInt32 tempHash = 0;

    61         PKIX_ENTER(CERTSTORE, "pkix_CertStore_Hashcode");

    62         PKIX_NULLCHECK_TWO(object, pHashcode);

    64         PKIX_CHECK(pkix_CheckType(object, PKIX_CERTSTORE_TYPE, plContext),

    65                     PKIX_OBJECTNOTCERTSTORE);

    67         certStore = (PKIX_CertStore *)object;

    69         if (certStore->certStoreContext) {

    70                 PKIX_CHECK(PKIX_PL_Object_Hashcode

    71                     ((PKIX_PL_Object *) certStore->certStoreContext,

    72                     &tempHash,

    73                     plContext),

    74                    PKIX_CERTSTOREHASHCODEFAILED);

    75         }

    77         *pHashcode = (PKIX_UInt32) certStore->certCallback +

    78                      (PKIX_UInt32) certStore->crlCallback +

    79                      (PKIX_UInt32) certStore->certContinue +

    80                      (PKIX_UInt32) certStore->crlContinue +

    81                      (PKIX_UInt32) certStore->trustCallback +

    82                      (tempHash << 7);

    84 cleanup:

    86         PKIX_RETURN(CERTSTORE);

    87 }

    89 /*

    90  * FUNCTION: pkix_CertStore_Equals

    91  * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)

    92  */

    93 static PKIX_Error *

    94 pkix_CertStore_Equals(

    95         PKIX_PL_Object *firstObject,

    96         PKIX_PL_Object *secondObject,

    97         PKIX_Int32 *pResult,

    98         void *plContext)

    99 {

   100         PKIX_CertStore *firstCS = NULL;

   101         PKIX_CertStore *secondCS = NULL;

   102         PKIX_Boolean cmpResult = PKIX_FALSE;

   104         PKIX_ENTER(CERTSTORE, "pkix_CertStore_Equals");

   105         PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);

   107         PKIX_CHECK(pkix_CheckTypes

   108                     (firstObject, secondObject, PKIX_CERTSTORE_TYPE, plContext),

   109                     PKIX_ARGUMENTSNOTDATES);

   111         firstCS = (PKIX_CertStore *)firstObject;

   112         secondCS = (PKIX_CertStore *)secondObject;

   114         cmpResult = (firstCS->certCallback == secondCS->certCallback) &&

   115             (firstCS->crlCallback == secondCS->crlCallback) &&

   116             (firstCS->certContinue == secondCS->certContinue) &&

   117             (firstCS->crlContinue == secondCS->crlContinue) &&

   118             (firstCS->trustCallback == secondCS->trustCallback);

   120         if (cmpResult &&

   121             (firstCS->certStoreContext != secondCS->certStoreContext)) {

   123                 PKIX_CHECK(PKIX_PL_Object_Equals

   124                     ((PKIX_PL_Object *) firstCS->certStoreContext,

   125                     (PKIX_PL_Object *) secondCS->certStoreContext,

   126                     &cmpResult,

   127                     plContext),

   128                     PKIX_CERTSTOREEQUALSFAILED);

   129         }

   131         *pResult = cmpResult;

   133 cleanup:

   135         PKIX_RETURN(CERTSTORE);

   136 }

   138 /*

   139  * FUNCTION: pkix_CertStore_RegisterSelf

   140  * DESCRIPTION:

   141  *  Registers PKIX_CERTSTORE_TYPE and its related functions with

   142  *  systemClasses[]

   143  * THREAD SAFETY:

   144  *  Not Thread Safe - for performance and complexity reasons

   145  *

   146  *  Since this function is only called by PKIX_PL_Initialize, which should

   147  *  only be called once, it is acceptable that this function is not

   148  *  thread-safe.

   149  */

   150 PKIX_Error *

   151 pkix_CertStore_RegisterSelf(void *plContext)

   152 {

   153         extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];

   154         pkix_ClassTable_Entry entry;

   156         PKIX_ENTER(CERTSTORE, "pkix_CertStore_RegisterSelf");

   158         entry.description = "CertStore";

   159         entry.objCounter = 0;

   160         entry.typeObjectSize = sizeof(PKIX_CertStore);

   161         entry.destructor = pkix_CertStore_Destroy;

   162         entry.equalsFunction = pkix_CertStore_Equals;

   163         entry.hashcodeFunction = pkix_CertStore_Hashcode;

   164         entry.toStringFunction = NULL;

   165         entry.comparator = NULL;

   166         entry.duplicateFunction = pkix_duplicateImmutable;

   168         systemClasses[PKIX_CERTSTORE_TYPE] = entry;

   170         PKIX_RETURN(CERTSTORE);

   171 }

   173 /* --CertStore-Public-Functions------------------------------------------ */

   175 /*

   176  * FUNCTION: PKIX_CertStore_Create (see comments in pkix_certstore.h)

   177  */

   178 PKIX_Error *

   179 PKIX_CertStore_Create(

   180         PKIX_CertStore_CertCallback certCallback,

   181         PKIX_CertStore_CRLCallback crlCallback,

   182         PKIX_CertStore_CertContinueFunction certContinue,

   183         PKIX_CertStore_CrlContinueFunction crlContinue,

   184         PKIX_CertStore_CheckTrustCallback trustCallback,

   185         PKIX_CertStore_ImportCrlCallback importCrlCallback,

   186         PKIX_CertStore_CheckRevokationByCrlCallback checkRevByCrlCallback,

   187         PKIX_PL_Object *certStoreContext,

   188         PKIX_Boolean cacheFlag,

   189         PKIX_Boolean localFlag,

   190         PKIX_CertStore **pStore,

   191         void *plContext)

   192 {

   193         PKIX_CertStore *certStore = NULL;

   195         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_Create");

   196         PKIX_NULLCHECK_THREE(certCallback, crlCallback, pStore);

   198         PKIX_CHECK(PKIX_PL_Object_Alloc

   199                     (PKIX_CERTSTORE_TYPE,

   200                     sizeof (PKIX_CertStore),

   201                     (PKIX_PL_Object **)&certStore,

   202                     plContext),

   203                     PKIX_COULDNOTCREATECERTSTOREOBJECT);

   205         certStore->certCallback = certCallback;

   206         certStore->crlCallback = crlCallback;

   207         certStore->certContinue = certContinue;

   208         certStore->crlContinue = crlContinue;

   209         certStore->trustCallback = trustCallback;

   210         certStore->importCrlCallback = importCrlCallback;

   211         certStore->checkRevByCrlCallback = checkRevByCrlCallback;

   212         certStore->cacheFlag = cacheFlag;

   213         certStore->localFlag = localFlag;

   215         PKIX_INCREF(certStoreContext);

   216         certStore->certStoreContext = certStoreContext;

   218         *pStore = certStore;

   219         certStore = NULL;

   221 cleanup:

   223         PKIX_DECREF(certStore);

   225         PKIX_RETURN(CERTSTORE);

   226 }

   228 /*

   229  * FUNCTION: PKIX_CertStore_GetCertCallback (see comments in pkix_certstore.h)

   230  */

   231 PKIX_Error *

   232 PKIX_CertStore_GetCertCallback(

   233         PKIX_CertStore *store,

   234         PKIX_CertStore_CertCallback *pCallback,

   235         void *plContext)

   236 {

   237         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetCertCallback");

   238         PKIX_NULLCHECK_TWO(store, pCallback);

   240         *pCallback = store->certCallback;

   242         PKIX_RETURN(CERTSTORE);

   243 }

   245 /*

   246  * FUNCTION: PKIX_CertStore_GetCRLCallback (see comments in pkix_certstore.h)

   247  */

   248 PKIX_Error *

   249 PKIX_CertStore_GetCRLCallback(

   250         PKIX_CertStore *store,

   251         PKIX_CertStore_CRLCallback *pCallback,

   252         void *plContext)

   253 {

   254         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetCRLCallback");

   255         PKIX_NULLCHECK_TWO(store, pCallback);

   257         *pCallback = store->crlCallback;

   259         PKIX_RETURN(CERTSTORE);

   260 }

   262 /*

   263  * FUNCTION: PKIX_CertStore_CertContinue (see comments in pkix_certstore.h)

   264  */

   265 PKIX_Error *

   266 PKIX_CertStore_CertContinue(

   267         PKIX_CertStore *store,

   268         PKIX_CertSelector *selector,

   269         PKIX_VerifyNode *verifyNode,

   270         void **pNBIOContext,

   271         PKIX_List **pCertList,

   272         void *plContext)

   273 {

   274         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_CertContinue");

   275         PKIX_NULLCHECK_FOUR(store, selector, pNBIOContext, pCertList);

   277         PKIX_CHECK(store->certContinue

   278                    (store, selector, verifyNode,

   279                     pNBIOContext, pCertList, plContext),

   280                 PKIX_CERTSTORECERTCONTINUEFUNCTIONFAILED);

   282 cleanup:

   284         PKIX_RETURN(CERTSTORE);

   285 }

   287 /*

   288  * FUNCTION: PKIX_CertStore_CrlContinue (see comments in pkix_certstore.h)

   289  */

   290 PKIX_Error *

   291 PKIX_CertStore_CrlContinue(

   292         PKIX_CertStore *store,

   293         PKIX_CRLSelector *selector,

   294         void **pNBIOContext,

   295         PKIX_List **pCrlList,

   296         void *plContext)

   297 {

   298         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_CrlContinue");

   299         PKIX_NULLCHECK_FOUR(store, selector, pNBIOContext, pCrlList);

   301         PKIX_CHECK(store->crlContinue

   302                 (store, selector, pNBIOContext, pCrlList, plContext),

   303                 PKIX_CERTSTORECRLCONTINUEFAILED);

   305 cleanup:

   307         PKIX_RETURN(CERTSTORE);

   308 }

   310 /*

   311  * FUNCTION: PKIX_CertStore_GetTrustCallback (see comments in pkix_certstore.h)

   312  */

   313 PKIX_Error *

   314 PKIX_CertStore_GetTrustCallback(

   315         PKIX_CertStore *store,

   316         PKIX_CertStore_CheckTrustCallback *pCallback,

   317         void *plContext)

   318 {

   319         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetTrustCallback");

   320         PKIX_NULLCHECK_TWO(store, pCallback);

   322         *pCallback = store->trustCallback;

   324         PKIX_RETURN(CERTSTORE);

   325 }

   327 /*

   328  * FUNCTION: PKIX_CertStore_GetImportCrlCallback (see comments in pkix_certstore.h)

   329  */

   330 PKIX_Error *

   331 PKIX_CertStore_GetImportCrlCallback(

   332         PKIX_CertStore *store,

   333         PKIX_CertStore_ImportCrlCallback *pCallback,

   334         void *plContext)

   335 {

   336         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetTrustCallback");

   337         PKIX_NULLCHECK_TWO(store, pCallback);

   339         *pCallback = store->importCrlCallback;

   341         PKIX_RETURN(CERTSTORE);

   342 }

   344 /*

   345  * FUNCTION: PKIX_CertStore_GetCheckRevByCrl (see comments in pkix_certstore.h)

   346  */

   347 PKIX_Error *

   348 PKIX_CertStore_GetCrlCheckerFn(

   349         PKIX_CertStore *store,

   350         PKIX_CertStore_CheckRevokationByCrlCallback *pCallback,

   351         void *plContext)

   352 {

   353         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetTrustCallback");

   354         PKIX_NULLCHECK_TWO(store, pCallback);

   356         *pCallback = store->checkRevByCrlCallback;

   358         PKIX_RETURN(CERTSTORE);

   359 }

   361 /*

   362  * FUNCTION: PKIX_CertStore_GetCertStoreContext

   363  * (see comments in pkix_certstore.h)

   364  */

   365 PKIX_Error *

   366 PKIX_CertStore_GetCertStoreContext(

   367         PKIX_CertStore *store,

   368         PKIX_PL_Object **pCertStoreContext,

   369         void *plContext)

   370 {

   371         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetCertStoreContext");

   372         PKIX_NULLCHECK_TWO(store, pCertStoreContext);

   374         PKIX_INCREF(store->certStoreContext);

   375         *pCertStoreContext = store->certStoreContext;

   377 cleanup:

   378         PKIX_RETURN(CERTSTORE);

   379 }

   381 /*

   382  * FUNCTION: PKIX_CertStore_GetCertStoreCacheFlag

   383  * (see comments in pkix_certstore.h)

   384  */

   385 PKIX_Error *

   386 PKIX_CertStore_GetCertStoreCacheFlag(

   387         PKIX_CertStore *store,

   388         PKIX_Boolean *pCacheFlag,

   389         void *plContext)

   390 {

   391         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetCertStoreCacheFlag");

   392         PKIX_NULLCHECK_TWO(store, pCacheFlag);

   394         *pCacheFlag = store->cacheFlag;

   396         PKIX_RETURN(CERTSTORE);

   397 }

   399 /*

   400  * FUNCTION: PKIX_CertStore_GetLocalFlag

   401  * (see comments in pkix_certstore.h)

   402  */

   403 PKIX_Error *

   404 PKIX_CertStore_GetLocalFlag(

   405         PKIX_CertStore *store,

   406         PKIX_Boolean *pLocalFlag,

   407         void *plContext)

   408 {

   409         PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetLocalFlag");

   410         PKIX_NULLCHECK_TWO(store, pLocalFlag);

   412         *pLocalFlag = store->localFlag;

   414         PKIX_RETURN(CERTSTORE);

   415 }

The Tor Browser / file revision

security/nss/lib/libpkix/pkix/store/pkix_store.c@b8a032363ba2

security/nss/lib/libpkix/pkix/store/pkix_store.c