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