security/nss/lib/libpkix/pkix/params/pkix_procparams.c

   1 /* ***** BEGIN LICENSE BLOCK *****
   2  * Version: MPL 1.1/GPL 2.0/LGPL 2.1
   3  *
   4  * The contents of this file are subject to the Mozilla Public License Version
   5  * 1.1 (the "License"); you may not use this file except in compliance with
   6  * the License. You may obtain a copy of the License at
   7  * http://www.mozilla.org/MPL/
   8  *
   9  * Software distributed under the License is distributed on an "AS IS" basis,
  10  * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
  11  * for the specific language governing rights and limitations under the
  12  * License.
  13  *
  14  * The Original Code is the Netscape security libraries.
  15  *
  16  * The Initial Developer of the Original Code is
  17  * Netscape Communications Corporation.
  18  * Portions created by the Initial Developer are Copyright (C) 1994-2000
  19  * the Initial Developer. All Rights Reserved.
  20  *
  21  * Contributor(s):
  22  *   Sun Microsystems
  23  *
  24  * Alternatively, the contents of this file may be used under the terms of
  25  * either the GNU General Public License Version 2 or later (the "GPL"), or
  26  * the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
  27  * in which case the provisions of the GPL or the LGPL are applicable instead
  28  * of those above. If you wish to allow use of your version of this file only
  29  * under the terms of either the GPL or the LGPL, and not to allow others to
  30  * use your version of this file under the terms of the MPL, indicate your
  31  * decision by deleting the provisions above and replace them with the notice
  32  * and other provisions required by the GPL or the LGPL. If you do not delete
  33  * the provisions above, a recipient may use your version of this file under
  34  * the terms of any one of the MPL, the GPL or the LGPL.
  35  *
  36  * ***** END LICENSE BLOCK ***** */
  37 /*
  38  * pkix_procparams.c
  39  *
  40  * ProcessingParams Object Functions
  41  *
  42  */
  43
  44 #include "pkix_procparams.h"
  45
  46 /* --Private-Functions-------------------------------------------- */
  47
  48 /*
  49  * FUNCTION: pkix_ProcessingParams_Destroy
  50  * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
  51  */
  52 static PKIX_Error *
  53 pkix_ProcessingParams_Destroy(
  54         PKIX_PL_Object *object,
  55         void *plContext)
  56 {
  57         PKIX_ProcessingParams *params = NULL;
  58
  59         PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Destroy");
  60         PKIX_NULLCHECK_ONE(object);
  61
  62         /* Check that this object is a processing params object */
  63         PKIX_CHECK(pkix_CheckType
  64                     (object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
  65                     PKIX_OBJECTNOTPROCESSINGPARAMS);
  66
  67         params = (PKIX_ProcessingParams *)object;
  68
  69         PKIX_DECREF(params->trustAnchors);
  70         PKIX_DECREF(params->hintCerts);
  71         PKIX_DECREF(params->constraints);
  72         PKIX_DECREF(params->date);
  73         PKIX_DECREF(params->initialPolicies);
  74         PKIX_DECREF(params->certChainCheckers);
  75         PKIX_DECREF(params->revCheckers);
  76         PKIX_DECREF(params->certStores);
  77         PKIX_DECREF(params->resourceLimits);
  78
  79 cleanup:
  80
  81         PKIX_RETURN(PROCESSINGPARAMS);
  82 }
  83
  84 /*
  85  * FUNCTION: pkix_ProcessingParams_Equals
  86  * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
  87  */
  88 static PKIX_Error *
  89 pkix_ProcessingParams_Equals(
  90         PKIX_PL_Object *first,
  91         PKIX_PL_Object *second,
  92         PKIX_Boolean *pResult,
  93         void *plContext)
  94 {
  95         PKIX_UInt32 secondType;
  96         PKIX_Boolean cmpResult;
  97         PKIX_ProcessingParams *firstProcParams = NULL;
  98         PKIX_ProcessingParams *secondProcParams = NULL;
  99
 100         PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Equals");
 101         PKIX_NULLCHECK_THREE(first, second, pResult);
 102
 103         PKIX_CHECK(pkix_CheckType(first, PKIX_PROCESSINGPARAMS_TYPE, plContext),
 104                     PKIX_FIRSTOBJECTNOTPROCESSINGPARAMS);
 105
 106         PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
 107                     PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
 108
 109         *pResult = PKIX_FALSE;
 110
 111         if (secondType != PKIX_PROCESSINGPARAMS_TYPE) goto cleanup;
 112
 113         firstProcParams = (PKIX_ProcessingParams *)first;
 114         secondProcParams = (PKIX_ProcessingParams *)second;
 115
 116         /* Do the simplest tests first */
 117         if ((firstProcParams->qualifiersRejected) !=
 118             (secondProcParams->qualifiersRejected)) {
 119                 goto cleanup;
 120         }
 121
 122         if (firstProcParams->isCrlRevocationCheckingEnabled !=
 123             secondProcParams->isCrlRevocationCheckingEnabled) {
 124                 goto cleanup;
 125         }
 126
 127         /* trustAnchors can never be NULL */
 128
 129         PKIX_EQUALS
 130                 (firstProcParams->trustAnchors,
 131                 secondProcParams->trustAnchors,
 132                 &cmpResult,
 133                 plContext,
 134                 PKIX_OBJECTEQUALSFAILED);
 135
 136         if (!cmpResult) goto cleanup;
 137
 138         PKIX_EQUALS
 139                 (firstProcParams->hintCerts,
 140                 secondProcParams->hintCerts,
 141                 &cmpResult,
 142                 plContext,
 143                 PKIX_OBJECTEQUALSFAILED);
 144
 145         if (!cmpResult) goto cleanup;
 146
 147         PKIX_EQUALS
 148                 (firstProcParams->date,
 149                 secondProcParams->date,
 150                 &cmpResult,
 151                 plContext,
 152                 PKIX_OBJECTEQUALSFAILED);
 153
 154         if (!cmpResult) goto cleanup;
 155
 156         PKIX_EQUALS
 157                 (firstProcParams->constraints,
 158                 secondProcParams->constraints,
 159                 &cmpResult,
 160                 plContext,
 161                 PKIX_OBJECTEQUALSFAILED);
 162
 163         if (!cmpResult) goto cleanup;
 164
 165         PKIX_EQUALS
 166                 (firstProcParams->initialPolicies,
 167                 secondProcParams->initialPolicies,
 168                 &cmpResult,
 169                 plContext,
 170                 PKIX_OBJECTEQUALSFAILED);
 171
 172         if (!cmpResult) goto cleanup;
 173
 174         /* There is no Equals function for CertChainCheckers */
 175
 176         PKIX_EQUALS
 177                     ((PKIX_PL_Object *)firstProcParams->certStores,
 178                     (PKIX_PL_Object *)secondProcParams->certStores,
 179                     &cmpResult,
 180                     plContext,
 181                     PKIX_OBJECTEQUALSFAILED);
 182
 183         if (!cmpResult) goto cleanup;
 184
 185         PKIX_EQUALS
 186                 (firstProcParams->resourceLimits,
 187                 secondProcParams->resourceLimits,
 188                 &cmpResult,
 189                 plContext,
 190                 PKIX_OBJECTEQUALSFAILED);
 191
 192         if (cmpResult == PKIX_FALSE) {
 193                 *pResult = PKIX_FALSE;
 194                 goto cleanup;
 195         }
 196
 197         *pResult = cmpResult;
 198
 199 cleanup:
 200
 201         PKIX_RETURN(PROCESSINGPARAMS);
 202 }
 203
 204 /*
 205  * FUNCTION: pkix_ProcessingParams_Hashcode
 206  * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
 207  */
 208 static PKIX_Error *
 209 pkix_ProcessingParams_Hashcode(
 210         PKIX_PL_Object *object,
 211         PKIX_UInt32 *pHashcode,
 212         void *plContext)
 213 {
 214         PKIX_ProcessingParams *procParams = NULL;
 215         PKIX_UInt32 hash = 0;
 216         PKIX_UInt32 anchorsHash = 0;
 217         PKIX_UInt32 hintCertsHash = 0;
 218         PKIX_UInt32 dateHash = 0;
 219         PKIX_UInt32 constraintsHash = 0;
 220         PKIX_UInt32 initialHash = 0;
 221         PKIX_UInt32 rejectedHash = 0;
 222         PKIX_UInt32 certChainCheckersHash = 0;
 223         PKIX_UInt32 revCheckersHash = 0;
 224         PKIX_UInt32 certStoresHash = 0;
 225         PKIX_UInt32 resourceLimitsHash = 0;
 226
 227         PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Hashcode");
 228         PKIX_NULLCHECK_TWO(object, pHashcode);
 229
 230         PKIX_CHECK(pkix_CheckType
 231                     (object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
 232                     PKIX_OBJECTNOTPROCESSINGPARAMS);
 233
 234         procParams = (PKIX_ProcessingParams*)object;
 235
 236         PKIX_HASHCODE(procParams->trustAnchors, &anchorsHash, plContext,
 237                 PKIX_OBJECTHASHCODEFAILED);
 238
 239         PKIX_HASHCODE(procParams->hintCerts, &hintCertsHash, plContext,
 240                 PKIX_OBJECTHASHCODEFAILED);
 241
 242         PKIX_HASHCODE(procParams->date, &dateHash, plContext,
 243                 PKIX_OBJECTHASHCODEFAILED);
 244
 245         PKIX_HASHCODE(procParams->constraints, &constraintsHash, plContext,
 246                 PKIX_OBJECTHASHCODEFAILED);
 247
 248         PKIX_HASHCODE(procParams->initialPolicies, &initialHash, plContext,
 249                 PKIX_OBJECTHASHCODEFAILED);
 250
 251         rejectedHash = procParams->qualifiersRejected;
 252
 253         /* There is no Hash function for CertChainCheckers */
 254
 255         PKIX_HASHCODE(procParams->certStores, &certStoresHash, plContext,
 256                 PKIX_OBJECTHASHCODEFAILED);
 257
 258         PKIX_HASHCODE(procParams->resourceLimits,
 259                 &resourceLimitsHash,
 260                 plContext,
 261                 PKIX_OBJECTHASHCODEFAILED);
 262
 263         hash = (31 * ((31 * anchorsHash) + hintCertsHash + dateHash)) +
 264                 constraintsHash + initialHash + rejectedHash;
 265
 266         hash += ((((certStoresHash + resourceLimitsHash) << 7) +
 267                 certChainCheckersHash + revCheckersHash +
 268                 procParams->isCrlRevocationCheckingEnabled) << 7);
 269
 270         *pHashcode = hash;
 271
 272 cleanup:
 273
 274         PKIX_RETURN(PROCESSINGPARAMS);
 275 }
 276
 277 /*
 278  * FUNCTION: pkix_ProcessingParams_ToString
 279  * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
 280  */
 281 static PKIX_Error *
 282 pkix_ProcessingParams_ToString(
 283         PKIX_PL_Object *object,
 284         PKIX_PL_String **pString,
 285         void *plContext)
 286 {
 287         PKIX_ProcessingParams *procParams = NULL;
 288         char *asciiFormat = NULL;
 289         PKIX_PL_String *formatString = NULL;
 290         PKIX_PL_String *procParamsString = NULL;
 291         PKIX_PL_String *anchorsString = NULL;
 292         PKIX_PL_String *dateString = NULL;
 293         PKIX_PL_String *constraintsString = NULL;
 294         PKIX_PL_String *InitialPoliciesString = NULL;
 295         PKIX_PL_String *qualsRejectedString = NULL;
 296         PKIX_List *certStores = NULL;
 297         PKIX_PL_String *certStoresString = NULL;
 298         PKIX_PL_String *resourceLimitsString = NULL;
 299
 300         PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_ToString");
 301         PKIX_NULLCHECK_TWO(object, pString);
 302
 303         PKIX_CHECK(pkix_CheckType
 304                     (object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
 305                     PKIX_OBJECTNOTPROCESSINGPARAMS);
 306
 307         asciiFormat =
 308                 "[\n"
 309                 "\tTrust Anchors: \n"
 310                 "\t********BEGIN LIST OF TRUST ANCHORS********\n"
 311                 "\t\t%s\n"
 312                 "\t********END LIST OF TRUST ANCHORS********\n"
 313                 "\tDate:    \t\t%s\n"
 314                 "\tTarget Constraints:    %s\n"
 315                 "\tInitial Policies:      %s\n"
 316                 "\tQualifiers Rejected:   %s\n"
 317                 "\tCert Stores:           %s\n"
 318                 "\tResource Limits:       %s\n"
 319                 "\tCRL Checking Enabled:  %d\n"
 320                 "]\n";
 321
 322         PKIX_CHECK(PKIX_PL_String_Create
 323                     (PKIX_ESCASCII,
 324                     asciiFormat,
 325                     0,
 326                     &formatString,
 327                     plContext),
 328                     PKIX_STRINGCREATEFAILED);
 329
 330         procParams = (PKIX_ProcessingParams*)object;
 331
 332         PKIX_TOSTRING(procParams->trustAnchors, &anchorsString, plContext,
 333                 PKIX_OBJECTTOSTRINGFAILED);
 334
 335         PKIX_TOSTRING(procParams->date, &dateString, plContext,
 336                 PKIX_OBJECTTOSTRINGFAILED);
 337
 338         PKIX_TOSTRING(procParams->constraints, &constraintsString, plContext,
 339                 PKIX_OBJECTTOSTRINGFAILED);
 340
 341         PKIX_TOSTRING
 342                 (procParams->initialPolicies, &InitialPoliciesString, plContext,
 343                 PKIX_OBJECTTOSTRINGFAILED);
 344
 345         PKIX_CHECK(PKIX_PL_String_Create
 346                 (PKIX_ESCASCII,
 347                 (procParams->qualifiersRejected)?"TRUE":"FALSE",
 348                 0,
 349                 &qualsRejectedString,
 350                 plContext),
 351                 PKIX_STRINGCREATEFAILED);
 352
 353         /* There is no ToString function for CertChainCheckers */
 354
 355        PKIX_CHECK(PKIX_ProcessingParams_GetCertStores
 356                 (procParams, &certStores, plContext),
 357                 PKIX_PROCESSINGPARAMSGETCERTSTORESFAILED);
 358
 359         PKIX_TOSTRING(certStores, &certStoresString, plContext,
 360                 PKIX_LISTTOSTRINGFAILED);
 361
 362         PKIX_TOSTRING(procParams->resourceLimits,
 363                 &resourceLimitsString,
 364                 plContext,
 365                 PKIX_OBJECTTOSTRINGFAILED);
 366
 367         PKIX_CHECK(PKIX_PL_Sprintf
 368                 (&procParamsString,
 369                 plContext,
 370                 formatString,
 371                 anchorsString,
 372                 dateString,
 373                 constraintsString,
 374                 InitialPoliciesString,
 375                 qualsRejectedString,
 376                 certStoresString,
 377                 resourceLimitsString,
 378                 procParams->isCrlRevocationCheckingEnabled),
 379                 PKIX_SPRINTFFAILED);
 380
 381         *pString = procParamsString;
 382
 383 cleanup:
 384
 385         PKIX_DECREF(formatString);
 386         PKIX_DECREF(anchorsString);
 387         PKIX_DECREF(dateString);
 388         PKIX_DECREF(constraintsString);
 389         PKIX_DECREF(InitialPoliciesString);
 390         PKIX_DECREF(qualsRejectedString);
 391         PKIX_DECREF(certStores);
 392         PKIX_DECREF(certStoresString);
 393         PKIX_DECREF(resourceLimitsString);
 394
 395         PKIX_RETURN(PROCESSINGPARAMS);
 396 }
 397
 398 /*
 399  * FUNCTION: pkix_ProcessingParams_Duplicate
 400  * (see comments for PKIX_PL_DuplicateCallback in pkix_pl_system.h)
 401  */
 402 static PKIX_Error *
 403 pkix_ProcessingParams_Duplicate(
 404         PKIX_PL_Object *object,
 405         PKIX_PL_Object **pNewObject,
 406         void *plContext)
 407 {
 408         PKIX_ProcessingParams *params = NULL;
 409         PKIX_ProcessingParams *paramsDuplicate = NULL;
 410
 411         PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Duplicate");
 412         PKIX_NULLCHECK_TWO(object, pNewObject);
 413
 414         PKIX_CHECK(pkix_CheckType
 415                 (object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
 416                 PKIX_OBJECTNOTPROCESSINGPARAMS);
 417
 418         params = (PKIX_ProcessingParams *)object;
 419
 420         PKIX_CHECK(PKIX_PL_Object_Alloc
 421                 (PKIX_PROCESSINGPARAMS_TYPE,
 422                 sizeof (PKIX_ProcessingParams),
 423                 (PKIX_PL_Object **)&paramsDuplicate,
 424                 plContext),
 425                 PKIX_PROCESSINGPARAMSCREATEFAILED);
 426
 427         /* initialize fields */
 428         PKIX_DUPLICATE
 429                 (params->trustAnchors,
 430                 &(paramsDuplicate->trustAnchors),
 431                 plContext,
 432                 PKIX_OBJECTDUPLICATEFAILED);
 433
 434         PKIX_DUPLICATE
 435                 (params->hintCerts, &(paramsDuplicate->hintCerts), plContext,
 436                 PKIX_OBJECTDUPLICATEFAILED);
 437
 438         PKIX_DUPLICATE
 439                 (params->constraints,
 440                 &(paramsDuplicate->constraints),
 441                 plContext,
 442                 PKIX_OBJECTDUPLICATEFAILED);
 443
 444         PKIX_DUPLICATE
 445                 (params->date, &(paramsDuplicate->date), plContext,
 446                 PKIX_OBJECTDUPLICATEFAILED);
 447
 448         PKIX_DUPLICATE
 449                 (params->initialPolicies,
 450                 &(paramsDuplicate->initialPolicies),
 451                 plContext,
 452                 PKIX_OBJECTDUPLICATEFAILED);
 453
 454         paramsDuplicate->initialPolicyMappingInhibit =
 455                 params->initialPolicyMappingInhibit;
 456         paramsDuplicate->initialAnyPolicyInhibit =
 457                 params->initialAnyPolicyInhibit;
 458         paramsDuplicate->initialExplicitPolicy = params->initialExplicitPolicy;
 459         paramsDuplicate->qualifiersRejected = params->qualifiersRejected;
 460
 461         PKIX_DUPLICATE
 462                 (params->certChainCheckers,
 463                 &(paramsDuplicate->certChainCheckers),
 464                 plContext,
 465                 PKIX_OBJECTDUPLICATEFAILED);
 466
 467         PKIX_DUPLICATE
 468                 (params->revCheckers,
 469                 &(paramsDuplicate->revCheckers),
 470                 plContext,
 471                 PKIX_OBJECTDUPLICATEFAILED);
 472
 473         PKIX_DUPLICATE
 474                 (params->certStores, &(paramsDuplicate->certStores), plContext,
 475                 PKIX_OBJECTDUPLICATEFAILED);
 476
 477         PKIX_DUPLICATE
 478                 (params->resourceLimits,
 479                 &(paramsDuplicate->resourceLimits),
 480                 plContext,
 481                 PKIX_OBJECTDUPLICATEFAILED);
 482
 483         paramsDuplicate->isCrlRevocationCheckingEnabled =
 484                 params->isCrlRevocationCheckingEnabled;
 485
 486         *pNewObject = (PKIX_PL_Object *)paramsDuplicate;
 487
 488 cleanup:
 489
 490         if (PKIX_ERROR_RECEIVED){
 491                 PKIX_DECREF(paramsDuplicate);
 492         }
 493
 494         PKIX_RETURN(PROCESSINGPARAMS);
 495
 496 }
 497
 498 /*
 499  * FUNCTION: pkix_ProcessingParams_RegisterSelf
 500  * DESCRIPTION:
 501  *  Registers PKIX_PROCESSINGPARAMS_TYPE and its related functions with
 502  *  systemClasses[]
 503  * THREAD SAFETY:
 504  *  Not Thread Safe - for performance and complexity reasons
 505  *
 506  *  Since this function is only called by PKIX_PL_Initialize, which should
 507  *  only be called once, it is acceptable that this function is not
 508  *  thread-safe.
 509  */
 510 PKIX_Error *
 511 pkix_ProcessingParams_RegisterSelf(void *plContext)
 512 {
 513         extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
 514         pkix_ClassTable_Entry entry;
 515
 516         PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_RegisterSelf");
 517
 518         entry.description = "ProcessingParams";
 519         entry.destructor = pkix_ProcessingParams_Destroy;
 520         entry.equalsFunction = pkix_ProcessingParams_Equals;
 521         entry.hashcodeFunction = pkix_ProcessingParams_Hashcode;
 522         entry.toStringFunction = pkix_ProcessingParams_ToString;
 523         entry.comparator = NULL;
 524         entry.duplicateFunction = pkix_ProcessingParams_Duplicate;
 525
 526         systemClasses[PKIX_PROCESSINGPARAMS_TYPE] = entry;
 527
 528         PKIX_RETURN(PROCESSINGPARAMS);
 529 }
 530
 531 /* --Public-Functions--------------------------------------------- */
 532
 533 /*
 534  * FUNCTION: PKIX_ProcessingParams_Create (see comments in pkix_params.h)
 535  */
 536 PKIX_Error *
 537 PKIX_ProcessingParams_Create(
 538         PKIX_List *anchors,  /* list of TrustAnchor */
 539         PKIX_ProcessingParams **pParams,
 540         void *plContext)
 541 {
 542         PKIX_ProcessingParams *params = NULL;
 543
 544         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_Create");
 545         PKIX_NULLCHECK_TWO(pParams, anchors);
 546
 547         PKIX_CHECK(PKIX_PL_Object_Alloc
 548                     (PKIX_PROCESSINGPARAMS_TYPE,
 549                     sizeof (PKIX_ProcessingParams),
 550                     (PKIX_PL_Object **)&params,
 551                     plContext),
 552                     PKIX_COULDNOTCREATEPROCESSINGPARAMSOBJECT);
 553
 554         /* initialize fields */
 555         PKIX_INCREF(anchors);
 556         params->trustAnchors = anchors;
 557         PKIX_CHECK(PKIX_List_SetImmutable(params->trustAnchors, plContext),
 558                     PKIX_LISTSETIMMUTABLEFAILED);
 559
 560         params->hintCerts = NULL;
 561         params->constraints = NULL;
 562         params->date = NULL;
 563         params->initialPolicies = NULL;
 564         params->initialPolicyMappingInhibit = PKIX_FALSE;
 565         params->initialAnyPolicyInhibit = PKIX_FALSE;
 566         params->initialExplicitPolicy = PKIX_FALSE;
 567         params->qualifiersRejected = PKIX_FALSE;
 568         params->certChainCheckers = NULL;
 569         params->revCheckers = NULL;
 570         params->certStores = NULL;
 571         params->resourceLimits = NULL;
 572
 573         /*
 574          * XXX CRL checking should be enabled as default, but before
 575          * we encorporate CRL in all our tests, take it as disable for now
 576          */
 577         params->isCrlRevocationCheckingEnabled = PKIX_TRUE;
 578
 579         *pParams = params;
 580
 581 cleanup:
 582
 583         if (PKIX_ERROR_RECEIVED){
 584                 PKIX_DECREF(params);
 585         }
 586
 587         PKIX_RETURN(PROCESSINGPARAMS);
 588
 589 }
 590
 591 /*
 592  * FUNCTION: PKIX_ProcessingParams_GetTrustAnchors
 593  * (see comments in pkix_params.h)
 594  */
 595 PKIX_Error *
 596 PKIX_ProcessingParams_GetTrustAnchors(
 597         PKIX_ProcessingParams *params,
 598         PKIX_List **pAnchors,  /* list of TrustAnchor */
 599         void *plContext)
 600 {
 601         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_GetTrustAnchors");
 602         PKIX_NULLCHECK_TWO(params, pAnchors);
 603
 604         PKIX_INCREF(params->trustAnchors);
 605
 606         *pAnchors = params->trustAnchors;
 607
 608         PKIX_RETURN(PROCESSINGPARAMS);
 609 }
 610
 611 /*
 612  * FUNCTION: PKIX_ProcessingParams_GetDate (see comments in pkix_params.h)
 613  */
 614 PKIX_Error *
 615 PKIX_ProcessingParams_GetDate(
 616         PKIX_ProcessingParams *params,
 617         PKIX_PL_Date **pDate,
 618         void *plContext)
 619 {
 620         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_GetDate");
 621         PKIX_NULLCHECK_TWO(params, pDate);
 622
 623         PKIX_INCREF(params->date);
 624         *pDate = params->date;
 625
 626         PKIX_RETURN(PROCESSINGPARAMS);
 627 }
 628
 629 /*
 630  * FUNCTION: PKIX_ProcessingParams_SetDate (see comments in pkix_params.h)
 631  */
 632 PKIX_Error *
 633 PKIX_ProcessingParams_SetDate(
 634         PKIX_ProcessingParams *params,
 635         PKIX_PL_Date *date,
 636         void *plContext)
 637 {
 638         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_SetDate");
 639         PKIX_NULLCHECK_ONE(params);
 640
 641         PKIX_DECREF(params->date);
 642
 643         PKIX_INCREF(date);
 644
 645         params->date = date;
 646
 647         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
 648                     ((PKIX_PL_Object *)params, plContext),
 649                     PKIX_OBJECTINVALIDATECACHEFAILED);
 650 cleanup:
 651
 652         if (PKIX_ERROR_RECEIVED){
 653                 PKIX_DECREF(date);
 654         }
 655
 656         PKIX_RETURN(PROCESSINGPARAMS);
 657 }
 658
 659 /*
 660  * FUNCTION: PKIX_ProcessingParams_GetTargetCertConstraints
 661  * (see comments in pkix_params.h)
 662  */
 663 PKIX_Error *
 664 PKIX_ProcessingParams_GetTargetCertConstraints(
 665         PKIX_ProcessingParams *params,
 666         PKIX_CertSelector **pConstraints,
 667         void *plContext)
 668 {
 669         PKIX_ENTER(PROCESSINGPARAMS,
 670                     "PKIX_ProcessingParams_GetTargetCertConstraints");
 671
 672         PKIX_NULLCHECK_TWO(params, pConstraints);
 673
 674         PKIX_INCREF(params->constraints);
 675         *pConstraints = params->constraints;
 676
 677         PKIX_RETURN(PROCESSINGPARAMS);
 678 }
 679
 680 /*
 681  * FUNCTION: PKIX_ProcessingParams_SetTargetCertConstraints
 682  * (see comments in pkix_params.h)
 683  */
 684 PKIX_Error *
 685 PKIX_ProcessingParams_SetTargetCertConstraints(
 686         PKIX_ProcessingParams *params,
 687         PKIX_CertSelector *constraints,
 688         void *plContext)
 689 {
 690
 691         PKIX_ENTER(PROCESSINGPARAMS,
 692                     "PKIX_ProcessingParams_SetTargetCertConstraints");
 693
 694         PKIX_NULLCHECK_ONE(params);
 695
 696         PKIX_DECREF(params->constraints);
 697
 698         PKIX_INCREF(constraints);
 699
 700         params->constraints = constraints;
 701
 702         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
 703                     ((PKIX_PL_Object *)params, plContext),
 704                     PKIX_OBJECTINVALIDATECACHEFAILED);
 705
 706 cleanup:
 707
 708         PKIX_RETURN(PROCESSINGPARAMS);
 709 }
 710
 711 /*
 712  * FUNCTION: PKIX_ProcessingParams_GetInitialPolicies
 713  *      (see comments in pkix_params.h)
 714  */
 715 PKIX_Error *
 716 PKIX_ProcessingParams_GetInitialPolicies(
 717         PKIX_ProcessingParams *params,
 718         PKIX_List **pInitPolicies, /* list of PKIX_PL_OID */
 719         void *plContext)
 720 {
 721
 722         PKIX_ENTER(PROCESSINGPARAMS,
 723                 "PKIX_ProcessingParams_GetInitialPolicies");
 724
 725         PKIX_NULLCHECK_TWO(params, pInitPolicies);
 726
 727         if (params->initialPolicies == NULL) {
 728                 PKIX_CHECK(PKIX_List_Create
 729                         (&params->initialPolicies, plContext),
 730                         PKIX_UNABLETOCREATELIST);
 731                 PKIX_CHECK(PKIX_List_SetImmutable
 732                         (params->initialPolicies, plContext),
 733                         PKIX_UNABLETOMAKELISTIMMUTABLE);
 734                 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
 735                         ((PKIX_PL_Object *)params, plContext),
 736                         PKIX_OBJECTINVALIDATECACHEFAILED);
 737         }
 738
 739         PKIX_INCREF(params->initialPolicies);
 740         *pInitPolicies = params->initialPolicies;
 741
 742 cleanup:
 743
 744         PKIX_RETURN(PROCESSINGPARAMS);
 745 }
 746
 747 /*
 748  * FUNCTION: PKIX_ProcessingParams_SetInitialPolicies
 749  *      (see comments in pkix_params.h)
 750  */
 751 PKIX_Error *
 752 PKIX_ProcessingParams_SetInitialPolicies(
 753         PKIX_ProcessingParams *params,
 754         PKIX_List *initPolicies, /* list of PKIX_PL_OID */
 755         void *plContext)
 756 {
 757         PKIX_ENTER(PROCESSINGPARAMS,
 758                 "PKIX_ProcessingParams_SetInitialPolicies");
 759
 760         PKIX_NULLCHECK_ONE(params);
 761
 762         PKIX_DECREF(params->initialPolicies);
 763
 764         PKIX_INCREF(initPolicies);
 765         params->initialPolicies = initPolicies;
 766
 767         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
 768                 ((PKIX_PL_Object *)params, plContext),
 769                 PKIX_OBJECTINVALIDATECACHEFAILED);
 770
 771 cleanup:
 772
 773         PKIX_RETURN(PROCESSINGPARAMS);
 774 }
 775
 776 /*
 777  * FUNCTION: PKIX_ProcessingParams_GetPolicyQualifiersRejected
 778  *      (see comments in pkix_params.h)
 779  */
 780 PKIX_Error *
 781 PKIX_ProcessingParams_GetPolicyQualifiersRejected(
 782         PKIX_ProcessingParams *params,
 783         PKIX_Boolean *pRejected,
 784         void *plContext)
 785 {
 786         PKIX_ENTER(PROCESSINGPARAMS,
 787                 "PKIX_ProcessingParams_GetPolicyQualifiersRejected");
 788
 789         PKIX_NULLCHECK_TWO(params, pRejected);
 790
 791         *pRejected = params->qualifiersRejected;
 792
 793         PKIX_RETURN(PROCESSINGPARAMS);
 794 }
 795
 796 /*
 797  * FUNCTION: PKIX_ProcessingParams_SetPolicyQualifiersRejected
 798  *      (see comments in pkix_params.h)
 799  */
 800 PKIX_Error *
 801 PKIX_ProcessingParams_SetPolicyQualifiersRejected(
 802         PKIX_ProcessingParams *params,
 803         PKIX_Boolean rejected,
 804         void *plContext)
 805 {
 806         PKIX_ENTER(PROCESSINGPARAMS,
 807                 "PKIX_ProcessingParams_SetPolicyQualifiersRejected");
 808
 809         PKIX_NULLCHECK_ONE(params);
 810
 811         params->qualifiersRejected = rejected;
 812
 813         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
 814                 ((PKIX_PL_Object *)params, plContext),
 815                 PKIX_OBJECTINVALIDATECACHEFAILED);
 816
 817 cleanup:
 818
 819         PKIX_RETURN(PROCESSINGPARAMS);
 820 }
 821
 822 /*
 823  * FUNCTION: PKIX_ProcessingParams_GetCertChainCheckers
 824  * (see comments in pkix_params.h)
 825  */
 826 PKIX_Error *
 827 PKIX_ProcessingParams_GetCertChainCheckers(
 828         PKIX_ProcessingParams *params,
 829         PKIX_List **pCheckers,  /* list of PKIX_CertChainChecker */
 830         void *plContext)
 831 {
 832
 833         PKIX_ENTER
 834             (PROCESSINGPARAMS, "PKIX_ProcessingParams_GetCertChainCheckers");
 835         PKIX_NULLCHECK_TWO(params, pCheckers);
 836
 837         if (params->certChainCheckers) {
 838                 PKIX_INCREF(params->certChainCheckers);
 839         }
 840
 841         *pCheckers = params->certChainCheckers;
 842
 843         PKIX_RETURN(PROCESSINGPARAMS);
 844 }
 845
 846 /*
 847  * FUNCTION: PKIX_ProcessingParams_SetCertChainCheckers
 848  * (see comments in pkix_params.h)
 849  */
 850 PKIX_Error *
 851 PKIX_ProcessingParams_SetCertChainCheckers(
 852         PKIX_ProcessingParams *params,
 853         PKIX_List *checkers,  /* list of PKIX_CertChainChecker */
 854         void *plContext)
 855 {
 856
 857         PKIX_ENTER
 858             (PROCESSINGPARAMS, "PKIX_ProcessingParams_SetCertChainCheckers");
 859         PKIX_NULLCHECK_ONE(params);
 860
 861         if (checkers == NULL) {
 862                 /* accordingly to spec, nothing done */
 863                 goto cleanup;
 864
 865         } else {
 866
 867                 PKIX_INCREF(checkers);
 868
 869                 params->certChainCheckers = checkers;
 870         }
 871
 872         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
 873                 ((PKIX_PL_Object *)params, plContext),
 874                 PKIX_OBJECTINVALIDATECACHEFAILED);
 875
 876 cleanup:
 877
 878         PKIX_RETURN(PROCESSINGPARAMS);
 879 }
 880
 881 /*
 882  * FUNCTION: PKIX_ProcessingParams_AddCertChainCheckers
 883  * (see comments in pkix_params.h)
 884  */
 885 PKIX_Error *
 886 PKIX_ProcessingParams_AddCertChainChecker(
 887         PKIX_ProcessingParams *params,
 888         PKIX_CertChainChecker *checker,
 889         void *plContext)
 890 {
 891         PKIX_List *list = NULL;
 892
 893         PKIX_ENTER
 894             (PROCESSINGPARAMS, "PKIX_ProcessingParams_AddCertChainChecker");
 895         PKIX_NULLCHECK_TWO(params, checker);
 896
 897         if (params->certChainCheckers == NULL) {
 898
 899                 PKIX_CHECK(PKIX_List_Create(&list, plContext),
 900                     PKIX_LISTCREATEFAILED);
 901
 902                 PKIX_INCREF(list);
 903
 904                 params->certChainCheckers = list;
 905
 906         }
 907
 908         PKIX_CHECK(PKIX_List_AppendItem
 909             (params->certChainCheckers, (PKIX_PL_Object *)checker, plContext),
 910             PKIX_LISTAPPENDITEMFAILED);
 911
 912         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
 913             ((PKIX_PL_Object *)params, plContext),
 914             PKIX_OBJECTINVALIDATECACHEFAILED);
 915
 916 cleanup:
 917
 918         PKIX_DECREF(list);
 919         PKIX_RETURN(PROCESSINGPARAMS);
 920 }
 921
 922 /*
 923  * FUNCTION: PKIX_ProcessingParams_GetRevocationCheckers
 924  * (see comments in pkix_params.h)
 925  */
 926 PKIX_Error *
 927 PKIX_ProcessingParams_GetRevocationCheckers(
 928         PKIX_ProcessingParams *params,
 929         PKIX_List **pCheckers,  /* list of PKIX_RevocationChecker */
 930         void *plContext)
 931 {
 932
 933         PKIX_ENTER
 934             (PROCESSINGPARAMS, "PKIX_ProcessingParams_GetRevocationCheckers");
 935         PKIX_NULLCHECK_TWO(params, pCheckers);
 936
 937         if (params->revCheckers == NULL) {
 938                 PKIX_CHECK(PKIX_List_Create
 939                         (&(params->revCheckers), plContext),
 940                         PKIX_LISTCREATEFAILED);
 941         }
 942
 943         PKIX_INCREF(params->revCheckers);
 944
 945         *pCheckers = params->revCheckers;
 946
 947 cleanup:
 948
 949         PKIX_RETURN(PROCESSINGPARAMS);
 950 }
 951
 952 /*
 953  * FUNCTION: PKIX_ProcessingParams_SetRevocationCheckers
 954  * (see comments in pkix_params.h)
 955  */
 956 PKIX_Error *
 957 PKIX_ProcessingParams_SetRevocationCheckers(
 958         PKIX_ProcessingParams *params,
 959         PKIX_List *checkers,  /* list of PKIX_RevocationChecker */
 960         void *plContext)
 961 {
 962
 963         PKIX_ENTER
 964             (PROCESSINGPARAMS, "PKIX_ProcessingParams_SetRevocationCheckers");
 965         PKIX_NULLCHECK_ONE(params);
 966
 967         PKIX_DECREF(params->revCheckers);
 968
 969         if (checkers != NULL) {
 970
 971                 PKIX_INCREF(checkers);
 972
 973                 params->revCheckers = checkers;
 974         }
 975
 976         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
 977                 ((PKIX_PL_Object *)params, plContext),
 978                 PKIX_OBJECTINVALIDATECACHEFAILED);
 979
 980 cleanup:
 981
 982         PKIX_RETURN(PROCESSINGPARAMS);
 983 }
 984
 985 /*
 986  * FUNCTION: PKIX_ProcessingParams_AddRevocationCheckers
 987  * (see comments in pkix_params.h)
 988  */
 989 PKIX_Error *
 990 PKIX_ProcessingParams_AddRevocationChecker(
 991         PKIX_ProcessingParams *params,
 992         PKIX_RevocationChecker *checker,
 993         void *plContext)
 994 {
 995         PKIX_List *list = NULL;
 996
 997         PKIX_ENTER
 998             (PROCESSINGPARAMS, "PKIX_ProcessingParams_AddRevocationChecker");
 999         PKIX_NULLCHECK_TWO(params, checker);
1000
1001         if (params->certChainCheckers == NULL) {
1002
1003                 PKIX_CHECK(PKIX_List_Create(&list, plContext),
1004                     PKIX_LISTCREATEFAILED);
1005
1006                 PKIX_INCREF(list);
1007
1008                 params->certChainCheckers = list;
1009
1010         }
1011
1012         PKIX_CHECK(PKIX_List_AppendItem
1013             (params->certChainCheckers, (PKIX_PL_Object *)checker, plContext),
1014             PKIX_LISTAPPENDITEMFAILED);
1015
1016         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1017             ((PKIX_PL_Object *)params, plContext),
1018             PKIX_OBJECTINVALIDATECACHEFAILED);
1019
1020 cleanup:
1021
1022         PKIX_DECREF(list);
1023         PKIX_RETURN(PROCESSINGPARAMS);
1024 }
1025
1026 /*
1027  * FUNCTION: PKIX_ProcessingParams_GetCertStores
1028  * (see comments in pkix_params.h)
1029  */
1030 PKIX_Error *
1031 PKIX_ProcessingParams_GetCertStores(
1032         PKIX_ProcessingParams *params,
1033         PKIX_List **pStores,  /* list of PKIX_CertStore */
1034         void *plContext)
1035 {
1036         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_GetCertStores");
1037
1038         PKIX_NULLCHECK_TWO(params, pStores);
1039
1040         if (!params->certStores){
1041                 PKIX_CHECK(PKIX_List_Create(&params->certStores, plContext),
1042                             PKIX_UNABLETOCREATELIST);
1043         }
1044
1045         PKIX_INCREF(params->certStores);
1046         *pStores = params->certStores;
1047
1048 cleanup:
1049
1050         PKIX_RETURN(PROCESSINGPARAMS);
1051 }
1052
1053 /*
1054  * FUNCTION: PKIX_ProcessingParams_SetCertStores
1055  * (see comments in pkix_params.h)
1056  */
1057 PKIX_Error *
1058 PKIX_ProcessingParams_SetCertStores(
1059         PKIX_ProcessingParams *params,
1060         PKIX_List *stores,  /* list of PKIX_CertStore */
1061         void *plContext)
1062 {
1063         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_SetCertStores");
1064
1065         PKIX_NULLCHECK_ONE(params);
1066
1067         PKIX_DECREF(params->certStores);
1068
1069         PKIX_INCREF(stores);
1070         params->certStores = stores;
1071
1072         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1073                 ((PKIX_PL_Object *)params, plContext),
1074                 PKIX_OBJECTINVALIDATECACHEFAILED);
1075
1076 cleanup:
1077
1078         PKIX_RETURN(PROCESSINGPARAMS);
1079 }
1080
1081 /*
1082  * FUNCTION: PKIX_ProcessingParams_AddCertStore
1083  * (see comments in pkix_params.h)
1084  */
1085 PKIX_Error *
1086 PKIX_ProcessingParams_AddCertStore(
1087         PKIX_ProcessingParams *params,
1088         PKIX_CertStore *store,
1089         void *plContext)
1090 {
1091         PKIX_List *certStores = NULL;
1092
1093         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_AddCertStore");
1094         PKIX_NULLCHECK_TWO(params, store);
1095
1096         PKIX_CHECK(PKIX_ProcessingParams_GetCertStores
1097                     (params, &certStores, plContext),
1098                     PKIX_PROCESSINGPARAMSGETCERTSTORESFAILED);
1099
1100         PKIX_CHECK(PKIX_List_AppendItem
1101                     (certStores, (PKIX_PL_Object *)store, plContext),
1102                     PKIX_LISTAPPENDITEMFAILED);
1103
1104         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1105                     ((PKIX_PL_Object *)params, plContext),
1106                     PKIX_OBJECTINVALIDATECACHEFAILED);
1107
1108 cleanup:
1109
1110         PKIX_DECREF(certStores);
1111         PKIX_RETURN(PROCESSINGPARAMS);
1112 }
1113
1114 /*
1115  * FUNCTION: PKIX_ProcessingParams_IsCRLRevocationCheckingEnabled
1116  * (see comments in pkix_params.h)
1117  */
1118 PKIX_Error *
1119 PKIX_ProcessingParams_IsCRLRevocationCheckingEnabled(
1120         PKIX_ProcessingParams *params,
1121         PKIX_Boolean *pEnabled,
1122         void *plContext)
1123 {
1124
1125         PKIX_ENTER(PROCESSINGPARAMS,
1126                     "PKIX_ProcessingParams_IsCRLRevocationCheckingEnabled");
1127         PKIX_NULLCHECK_TWO(params, pEnabled);
1128
1129         *pEnabled = params->isCrlRevocationCheckingEnabled;
1130
1131         PKIX_RETURN(PROCESSINGPARAMS);
1132 }
1133
1134 /*
1135  * FUNCTION: PKIX_ProcessingParams_SetRevocationEnabled
1136  * (see comments in pkix_params.h)
1137  */
1138 PKIX_Error *
1139 PKIX_ProcessingParams_SetRevocationEnabled(
1140         PKIX_ProcessingParams *params,
1141         PKIX_Boolean enabled,
1142         void *plContext)
1143 {
1144
1145         PKIX_ENTER(PROCESSINGPARAMS,
1146                     "PKIX_ProcessingParams_SetRevocationEnabled");
1147         PKIX_NULLCHECK_ONE(params);
1148
1149         params->isCrlRevocationCheckingEnabled = enabled;
1150
1151         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1152                     ((PKIX_PL_Object *)params, plContext),
1153                     PKIX_OBJECTINVALIDATECACHEFAILED);
1154
1155 cleanup:
1156
1157         PKIX_RETURN(PROCESSINGPARAMS);
1158 }
1159
1160 /*
1161  * FUNCTION: pkix_ProcessingParams_GetRevocationEnabled
1162  *
1163  * DESCRIPTION:
1164  *  Retrieves the boolean value indicating whether Revocation Checking
1165  *  should be performed, from the ProcessingParams pointed to by "params",
1166  *  and stores the result at "pEnable".
1167  *
1168  * PARAMETERS:
1169  *  "params"
1170  *      Address of ProcessingParams whose revocationEnabled flag is to be
1171  *      retrieved. Must be non-NULL.
1172  *  "pEnable"
1173  *      Address where Boolean value will be stored. Must be non-NULL.
1174  *  "plContext"
1175  *      Platform-specific context pointer.
1176  *
1177  * THREAD SAFETY:
1178  *  Thread Safe (see Thread Safety Definitions in Programmer's Guide)
1179  *
1180  * RETURNS:
1181  *  Returns NULL if the function succeeds.
1182  *  Returns a Fatal Error if the function fails in an unrecoverable way.
1183  */
1184 PKIX_Error *
1185 pkix_ProcessingParams_GetRevocationEnabled(
1186         PKIX_ProcessingParams *params,
1187         PKIX_Boolean *pEnabled,
1188         void *plContext)
1189 {
1190
1191         PKIX_ENTER(PROCESSINGPARAMS,
1192                     "PKIX_ProcessingParams_GetRevocationEnabled");
1193
1194         PKIX_NULLCHECK_TWO(params, pEnabled);
1195
1196         *pEnabled = params->isCrlRevocationCheckingEnabled;
1197
1198         PKIX_RETURN(PROCESSINGPARAMS);
1199 }
1200
1201 /*
1202  * FUNCTION: PKIX_ProcessingParams_SetResourceLimits
1203  * (see comments in pkix_params.h)
1204  */
1205 PKIX_Error *
1206 PKIX_ProcessingParams_SetResourceLimits(
1207         PKIX_ProcessingParams *params,
1208         PKIX_ResourceLimits *resourceLimits,
1209         void *plContext)
1210 {
1211         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_SetResourceLimits");
1212
1213         PKIX_NULLCHECK_TWO(params, resourceLimits);
1214
1215         PKIX_DECREF(params->resourceLimits);
1216         PKIX_INCREF(resourceLimits);
1217         params->resourceLimits = resourceLimits;
1218
1219         PKIX_RETURN(PROCESSINGPARAMS);
1220 }
1221
1222 /*
1223  * FUNCTION: PKIX_ProcessingParams_GetResourceLimits
1224  * (see comments in pkix_params.h)
1225  */
1226 PKIX_Error *
1227 PKIX_ProcessingParams_GetResourceLimits(
1228         PKIX_ProcessingParams *params,
1229         PKIX_ResourceLimits **pResourceLimits,
1230         void *plContext)
1231 {
1232         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_GetResourceLimits");
1233
1234         PKIX_NULLCHECK_TWO(params, pResourceLimits);
1235
1236         PKIX_INCREF(params->resourceLimits);
1237         *pResourceLimits = params->resourceLimits;
1238
1239         PKIX_RETURN(PROCESSINGPARAMS);
1240 }
1241
1242 /*
1243  * FUNCTION: PKIX_ProcessingParams_IsAnyPolicyInhibited
1244  * (see comments in pkix_params.h)
1245  */
1246 PKIX_Error *
1247 PKIX_ProcessingParams_IsAnyPolicyInhibited(
1248         PKIX_ProcessingParams *params,
1249         PKIX_Boolean *pInhibited,
1250         void *plContext)
1251 {
1252         PKIX_ENTER(PROCESSINGPARAMS,
1253                 "PKIX_ProcessingParams_IsAnyPolicyInhibited");
1254
1255         PKIX_NULLCHECK_TWO(params, pInhibited);
1256
1257         *pInhibited = params->initialAnyPolicyInhibit;
1258
1259         PKIX_RETURN(PROCESSINGPARAMS);
1260 }
1261
1262 /*
1263  * FUNCTION: PKIX_ProcessingParams_SetAnyPolicyInhibited
1264  * (see comments in pkix_params.h)
1265  */
1266 PKIX_Error *
1267 PKIX_ProcessingParams_SetAnyPolicyInhibited(
1268         PKIX_ProcessingParams *params,
1269         PKIX_Boolean inhibited,
1270         void *plContext)
1271 {
1272         PKIX_ENTER(PROCESSINGPARAMS,
1273                 "PKIX_ProcessingParams_SetAnyPolicyInhibited");
1274
1275         PKIX_NULLCHECK_ONE(params);
1276
1277         params->initialAnyPolicyInhibit = inhibited;
1278
1279         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1280                     ((PKIX_PL_Object *)params, plContext),
1281                     PKIX_OBJECTINVALIDATECACHEFAILED);
1282
1283 cleanup:
1284
1285         PKIX_RETURN(PROCESSINGPARAMS);
1286 }
1287
1288 /*
1289  * FUNCTION: PKIX_ProcessingParams_IsExplicitPolicyRequired
1290  * (see comments in pkix_params.h)
1291  */
1292 PKIX_Error *
1293 PKIX_ProcessingParams_IsExplicitPolicyRequired(
1294         PKIX_ProcessingParams *params,
1295         PKIX_Boolean *pRequired,
1296         void *plContext)
1297 {
1298         PKIX_ENTER(PROCESSINGPARAMS,
1299                 "PKIX_ProcessingParams_IsExplicitPolicyRequired");
1300
1301         PKIX_NULLCHECK_TWO(params, pRequired);
1302
1303         *pRequired = params->initialExplicitPolicy;
1304
1305         PKIX_RETURN(PROCESSINGPARAMS);
1306 }
1307
1308 /*
1309  * FUNCTION: PKIX_ProcessingParams_SetExplicitPolicyRequired
1310  * (see comments in pkix_params.h)
1311  */
1312 PKIX_Error *
1313 PKIX_ProcessingParams_SetExplicitPolicyRequired(
1314         PKIX_ProcessingParams *params,
1315         PKIX_Boolean required,
1316         void *plContext)
1317 {
1318         PKIX_ENTER(PROCESSINGPARAMS,
1319                 "PKIX_ProcessingParams_SetExplicitPolicyRequired");
1320
1321         PKIX_NULLCHECK_ONE(params);
1322
1323         params->initialExplicitPolicy = required;
1324
1325         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1326                     ((PKIX_PL_Object *)params, plContext),
1327                     PKIX_OBJECTINVALIDATECACHEFAILED);
1328
1329 cleanup:
1330
1331         PKIX_RETURN(PROCESSINGPARAMS);
1332 }
1333
1334 /*
1335  * FUNCTION: PKIX_ProcessingParams_IsPolicyMappingInhibited
1336  * (see comments in pkix_params.h)
1337  */
1338 PKIX_Error *
1339 PKIX_ProcessingParams_IsPolicyMappingInhibited(
1340         PKIX_ProcessingParams *params,
1341         PKIX_Boolean *pInhibited,
1342         void *plContext)
1343 {
1344         PKIX_ENTER(PROCESSINGPARAMS,
1345                 "PKIX_ProcessingParams_IsPolicyMappingInhibited");
1346
1347         PKIX_NULLCHECK_TWO(params, pInhibited);
1348
1349         *pInhibited = params->initialPolicyMappingInhibit;
1350
1351         PKIX_RETURN(PROCESSINGPARAMS);
1352 }
1353
1354 /*
1355  * FUNCTION: PKIX_ProcessingParams_SetPolicyMappingInhibited
1356  * (see comments in pkix_params.h)
1357  */
1358 PKIX_Error *
1359 PKIX_ProcessingParams_SetPolicyMappingInhibited(
1360         PKIX_ProcessingParams *params,
1361         PKIX_Boolean inhibited,
1362         void *plContext)
1363 {
1364         PKIX_ENTER(PROCESSINGPARAMS,
1365                 "PKIX_ProcessingParams_SetPolicyMappingInhibited");
1366
1367         PKIX_NULLCHECK_ONE(params);
1368
1369         params->initialPolicyMappingInhibit = inhibited;
1370
1371         PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1372                     ((PKIX_PL_Object *)params, plContext),
1373                     PKIX_OBJECTINVALIDATECACHEFAILED);
1374
1375 cleanup:
1376
1377         PKIX_RETURN(PROCESSINGPARAMS);
1378 }
1379
1380 /*
1381  * FUNCTION: PKIX_ProcessingParams_SetHintCerts
1382  * (see comments in pkix_params.h)
1383  */
1384 PKIX_Error *
1385 PKIX_ProcessingParams_SetHintCerts(
1386         PKIX_ProcessingParams *params,
1387         PKIX_List *hintCerts,
1388         void *plContext)
1389 {
1390         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_SetHintCerts");
1391
1392         PKIX_NULLCHECK_ONE(params);
1393
1394         PKIX_DECREF(params->hintCerts);
1395         PKIX_INCREF(hintCerts);
1396         params->hintCerts = hintCerts;
1397
1398         PKIX_RETURN(PROCESSINGPARAMS);
1399 }
1400
1401 /*
1402  * FUNCTION: PKIX_ProcessingParams_GetHintCerts
1403  * (see comments in pkix_params.h)
1404  */
1405 PKIX_Error *
1406 PKIX_ProcessingParams_GetHintCerts(
1407         PKIX_ProcessingParams *params,
1408         PKIX_List **pHintCerts,
1409         void *plContext)
1410 {
1411         PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_GetHintCerts");
1412
1413         PKIX_NULLCHECK_TWO(params, pHintCerts);
1414
1415         PKIX_INCREF(params->hintCerts);
1416         *pHintCerts = params->hintCerts;
1417
1418         PKIX_RETURN(PROCESSINGPARAMS);
1419 }