security/nss/lib/libpkix/pkix/params/pkix_procparams.c@6474c204b198
security/nss/lib/libpkix/pkix/params/pkix_procparams.c
Wed, 31 Dec 2014 06:09:35 +0100
- author
- Michael Schloh von Bennewitz <michael@schloh.com>
- date
- Wed, 31 Dec 2014 06:09:35 +0100
- changeset 0
- 6474c204b198
- permissions
- -rwxr-xr-x
Cloned upstream origin tor-browser at tor-browser-31.3.0esr-4.5-1-build1
revision ID fc1c9ff7c1b2defdbc039f12214767608f46423f for hacking purpose.
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 */
11 #include "pkix_procparams.h"
13 /* --Private-Functions-------------------------------------------- */
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;
26 PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Destroy");
27 PKIX_NULLCHECK_ONE(object);
29 /* Check that this object is a processing params object */
30 PKIX_CHECK(pkix_CheckType
31 (object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
32 PKIX_OBJECTNOTPROCESSINGPARAMS);
34 params = (PKIX_ProcessingParams *)object;
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);
46 cleanup:
48 PKIX_RETURN(PROCESSINGPARAMS);
49 }
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;
67 PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Equals");
68 PKIX_NULLCHECK_THREE(first, second, pResult);
70 PKIX_CHECK(pkix_CheckType(first, PKIX_PROCESSINGPARAMS_TYPE, plContext),
71 PKIX_FIRSTOBJECTNOTPROCESSINGPARAMS);
73 PKIX_CHECK(PKIX_PL_Object_GetType(second, &secondType, plContext),
74 PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
76 *pResult = PKIX_FALSE;
78 if (secondType != PKIX_PROCESSINGPARAMS_TYPE) goto cleanup;
80 firstProcParams = (PKIX_ProcessingParams *)first;
81 secondProcParams = (PKIX_ProcessingParams *)second;
83 /* Do the simplest tests first */
84 if ((firstProcParams->qualifiersRejected) !=
85 (secondProcParams->qualifiersRejected)) {
86 goto cleanup;
87 }
89 if (firstProcParams->isCrlRevocationCheckingEnabled !=
90 secondProcParams->isCrlRevocationCheckingEnabled) {
91 goto cleanup;
92 }
93 if (firstProcParams->isCrlRevocationCheckingEnabledWithNISTPolicy !=
94 secondProcParams->isCrlRevocationCheckingEnabledWithNISTPolicy) {
95 goto cleanup;
96 }
98 /* trustAnchors can never be NULL */
100 PKIX_EQUALS
101 (firstProcParams->trustAnchors,
102 secondProcParams->trustAnchors,
103 &cmpResult,
104 plContext,
105 PKIX_OBJECTEQUALSFAILED);
107 if (!cmpResult) goto cleanup;
109 PKIX_EQUALS
110 (firstProcParams->hintCerts,
111 secondProcParams->hintCerts,
112 &cmpResult,
113 plContext,
114 PKIX_OBJECTEQUALSFAILED);
116 if (!cmpResult) goto cleanup;
118 PKIX_EQUALS
119 (firstProcParams->date,
120 secondProcParams->date,
121 &cmpResult,
122 plContext,
123 PKIX_OBJECTEQUALSFAILED);
125 if (!cmpResult) goto cleanup;
127 PKIX_EQUALS
128 (firstProcParams->constraints,
129 secondProcParams->constraints,
130 &cmpResult,
131 plContext,
132 PKIX_OBJECTEQUALSFAILED);
134 if (!cmpResult) goto cleanup;
136 PKIX_EQUALS
137 (firstProcParams->initialPolicies,
138 secondProcParams->initialPolicies,
139 &cmpResult,
140 plContext,
141 PKIX_OBJECTEQUALSFAILED);
143 if (!cmpResult) goto cleanup;
145 /* There is no Equals function for CertChainCheckers */
147 PKIX_EQUALS
148 ((PKIX_PL_Object *)firstProcParams->certStores,
149 (PKIX_PL_Object *)secondProcParams->certStores,
150 &cmpResult,
151 plContext,
152 PKIX_OBJECTEQUALSFAILED);
154 if (!cmpResult) goto cleanup;
156 PKIX_EQUALS
157 (firstProcParams->resourceLimits,
158 secondProcParams->resourceLimits,
159 &cmpResult,
160 plContext,
161 PKIX_OBJECTEQUALSFAILED);
163 if (cmpResult == PKIX_FALSE) {
164 *pResult = PKIX_FALSE;
165 goto cleanup;
166 }
168 *pResult = cmpResult;
170 cleanup:
172 PKIX_RETURN(PROCESSINGPARAMS);
173 }
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;
198 PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Hashcode");
199 PKIX_NULLCHECK_TWO(object, pHashcode);
201 PKIX_CHECK(pkix_CheckType
202 (object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
203 PKIX_OBJECTNOTPROCESSINGPARAMS);
205 procParams = (PKIX_ProcessingParams*)object;
207 PKIX_HASHCODE(procParams->trustAnchors, &anchorsHash, plContext,
208 PKIX_OBJECTHASHCODEFAILED);
210 PKIX_HASHCODE(procParams->hintCerts, &hintCertsHash, plContext,
211 PKIX_OBJECTHASHCODEFAILED);
213 PKIX_HASHCODE(procParams->date, &dateHash, plContext,
214 PKIX_OBJECTHASHCODEFAILED);
216 PKIX_HASHCODE(procParams->constraints, &constraintsHash, plContext,
217 PKIX_OBJECTHASHCODEFAILED);
219 PKIX_HASHCODE(procParams->initialPolicies, &initialHash, plContext,
220 PKIX_OBJECTHASHCODEFAILED);
222 rejectedHash = procParams->qualifiersRejected;
224 /* There is no Hash function for CertChainCheckers */
226 PKIX_HASHCODE(procParams->certStores, &certStoresHash, plContext,
227 PKIX_OBJECTHASHCODEFAILED);
229 PKIX_HASHCODE(procParams->resourceLimits,
230 &resourceLimitsHash,
231 plContext,
232 PKIX_OBJECTHASHCODEFAILED);
234 hash = (31 * ((31 * anchorsHash) + hintCertsHash + dateHash)) +
235 constraintsHash + initialHash + rejectedHash;
237 hash += ((((certStoresHash + resourceLimitsHash) << 7) +
238 certChainCheckersHash + revCheckerHash +
239 procParams->isCrlRevocationCheckingEnabled +
240 procParams->isCrlRevocationCheckingEnabledWithNISTPolicy) << 7);
242 *pHashcode = hash;
244 cleanup:
246 PKIX_RETURN(PROCESSINGPARAMS);
247 }
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;
272 PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_ToString");
273 PKIX_NULLCHECK_TWO(object, pString);
275 PKIX_CHECK(pkix_CheckType
276 (object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
277 PKIX_OBJECTNOTPROCESSINGPARAMS);
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";
294 PKIX_CHECK(PKIX_PL_String_Create
295 (PKIX_ESCASCII,
296 asciiFormat,
297 0,
298 &formatString,
299 plContext),
300 PKIX_STRINGCREATEFAILED);
302 procParams = (PKIX_ProcessingParams*)object;
304 PKIX_TOSTRING(procParams->trustAnchors, &anchorsString, plContext,
305 PKIX_OBJECTTOSTRINGFAILED);
307 PKIX_TOSTRING(procParams->date, &dateString, plContext,
308 PKIX_OBJECTTOSTRINGFAILED);
310 PKIX_TOSTRING(procParams->constraints, &constraintsString, plContext,
311 PKIX_OBJECTTOSTRINGFAILED);
313 PKIX_TOSTRING
314 (procParams->initialPolicies, &InitialPoliciesString, plContext,
315 PKIX_OBJECTTOSTRINGFAILED);
317 PKIX_CHECK(PKIX_PL_String_Create
318 (PKIX_ESCASCII,
319 (procParams->qualifiersRejected)?"TRUE":"FALSE",
320 0,
321 &qualsRejectedString,
322 plContext),
323 PKIX_STRINGCREATEFAILED);
325 /* There is no ToString function for CertChainCheckers */
327 PKIX_CHECK(PKIX_ProcessingParams_GetCertStores
328 (procParams, &certStores, plContext),
329 PKIX_PROCESSINGPARAMSGETCERTSTORESFAILED);
331 PKIX_TOSTRING(certStores, &certStoresString, plContext,
332 PKIX_LISTTOSTRINGFAILED);
334 PKIX_TOSTRING(procParams->resourceLimits,
335 &resourceLimitsString,
336 plContext,
337 PKIX_OBJECTTOSTRINGFAILED);
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);
354 *pString = procParamsString;
356 cleanup:
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);
368 PKIX_RETURN(PROCESSINGPARAMS);
369 }
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;
384 PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_Duplicate");
385 PKIX_NULLCHECK_TWO(object, pNewObject);
387 PKIX_CHECK(pkix_CheckType
388 (object, PKIX_PROCESSINGPARAMS_TYPE, plContext),
389 PKIX_OBJECTNOTPROCESSINGPARAMS);
391 params = (PKIX_ProcessingParams *)object;
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);
400 /* initialize fields */
401 PKIX_DUPLICATE
402 (params->trustAnchors,
403 &(paramsDuplicate->trustAnchors),
404 plContext,
405 PKIX_OBJECTDUPLICATEFAILED);
407 PKIX_DUPLICATE
408 (params->hintCerts, &(paramsDuplicate->hintCerts), plContext,
409 PKIX_OBJECTDUPLICATEFAILED);
411 PKIX_DUPLICATE
412 (params->constraints,
413 &(paramsDuplicate->constraints),
414 plContext,
415 PKIX_OBJECTDUPLICATEFAILED);
417 PKIX_DUPLICATE
418 (params->date, &(paramsDuplicate->date), plContext,
419 PKIX_OBJECTDUPLICATEFAILED);
421 PKIX_DUPLICATE
422 (params->initialPolicies,
423 &(paramsDuplicate->initialPolicies),
424 plContext,
425 PKIX_OBJECTDUPLICATEFAILED);
427 paramsDuplicate->initialPolicyMappingInhibit =
428 params->initialPolicyMappingInhibit;
429 paramsDuplicate->initialAnyPolicyInhibit =
430 params->initialAnyPolicyInhibit;
431 paramsDuplicate->initialExplicitPolicy = params->initialExplicitPolicy;
432 paramsDuplicate->qualifiersRejected = params->qualifiersRejected;
434 PKIX_DUPLICATE
435 (params->certChainCheckers,
436 &(paramsDuplicate->certChainCheckers),
437 plContext,
438 PKIX_OBJECTDUPLICATEFAILED);
440 PKIX_DUPLICATE
441 (params->revChecker,
442 &(paramsDuplicate->revChecker),
443 plContext,
444 PKIX_OBJECTDUPLICATEFAILED);
446 PKIX_DUPLICATE
447 (params->certStores, &(paramsDuplicate->certStores), plContext,
448 PKIX_OBJECTDUPLICATEFAILED);
450 PKIX_DUPLICATE
451 (params->resourceLimits,
452 &(paramsDuplicate->resourceLimits),
453 plContext,
454 PKIX_OBJECTDUPLICATEFAILED);
456 paramsDuplicate->isCrlRevocationCheckingEnabled =
457 params->isCrlRevocationCheckingEnabled;
459 paramsDuplicate->isCrlRevocationCheckingEnabledWithNISTPolicy =
460 params->isCrlRevocationCheckingEnabledWithNISTPolicy;
462 *pNewObject = (PKIX_PL_Object *)paramsDuplicate;
464 cleanup:
466 if (PKIX_ERROR_RECEIVED){
467 PKIX_DECREF(paramsDuplicate);
468 }
470 PKIX_RETURN(PROCESSINGPARAMS);
472 }
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;
492 PKIX_ENTER(PROCESSINGPARAMS, "pkix_ProcessingParams_RegisterSelf");
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;
504 systemClasses[PKIX_PROCESSINGPARAMS_TYPE] = entry;
506 PKIX_RETURN(PROCESSINGPARAMS);
507 }
509 /* --Public-Functions--------------------------------------------- */
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;
521 PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_Create");
522 PKIX_NULLCHECK_ONE(pParams);
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);
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);
537 PKIX_CHECK(PKIX_PL_Date_Create_UTCTime
538 (NULL, ¶ms->date, plContext),
539 PKIX_DATECREATEUTCTIMEFAILED);
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;
553 params->isCrlRevocationCheckingEnabled = PKIX_TRUE;
555 params->isCrlRevocationCheckingEnabledWithNISTPolicy = PKIX_TRUE;
557 params->useAIAForCertFetching = PKIX_FALSE;
558 params->qualifyTargetCert = PKIX_TRUE;
559 params->useOnlyTrustAnchors = PKIX_TRUE;
561 *pParams = params;
562 params = NULL;
564 cleanup:
566 PKIX_DECREF(params);
568 PKIX_RETURN(PROCESSINGPARAMS);
570 }
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_GetUseAIAForCertFetching");
583 PKIX_NULLCHECK_TWO(params, pUseAIA);
585 *pUseAIA = params->useAIAForCertFetching;
587 PKIX_RETURN(PROCESSINGPARAMS);
588 }
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_SetUseAIAForCertFetching");
601 PKIX_NULLCHECK_ONE(params);
603 params->useAIAForCertFetching = useAIA;
605 PKIX_RETURN(PROCESSINGPARAMS);
606 }
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);
622 *pQualifyTargetCert = params->qualifyTargetCert;
624 PKIX_RETURN(PROCESSINGPARAMS);
625 }
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);
641 params->qualifyTargetCert = qualifyTargetCert;
643 PKIX_RETURN(PROCESSINGPARAMS);
644 }
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);
659 PKIX_DECREF(params->trustAnchors);
661 PKIX_INCREF(anchors);
662 params->trustAnchors = anchors;
663 PKIX_CHECK(PKIX_List_SetImmutable(params->trustAnchors, plContext),
664 PKIX_LISTSETIMMUTABLEFAILED);
666 cleanup:
667 PKIX_RETURN(PROCESSINGPARAMS);
668 }
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);
683 PKIX_INCREF(params->trustAnchors);
685 *pAnchors = params->trustAnchors;
687 cleanup:
688 PKIX_RETURN(PROCESSINGPARAMS);
689 }
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);
705 *pUseOnlyTrustAnchors = params->useOnlyTrustAnchors;
707 PKIX_RETURN(PROCESSINGPARAMS);
708 }
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);
724 params->useOnlyTrustAnchors = useOnlyTrustAnchors;
726 PKIX_RETURN(PROCESSINGPARAMS);
727 }
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);
741 PKIX_INCREF(params->date);
742 *pDate = params->date;
744 cleanup:
745 PKIX_RETURN(PROCESSINGPARAMS);
746 }
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);
760 PKIX_DECREF(params->date);
762 PKIX_INCREF(date);
763 params->date = date;
765 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
766 ((PKIX_PL_Object *)params, plContext),
767 PKIX_OBJECTINVALIDATECACHEFAILED);
769 cleanup:
771 if (PKIX_ERROR_RECEIVED && params) {
772 PKIX_DECREF(params->date);
773 }
775 PKIX_RETURN(PROCESSINGPARAMS);
776 }
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");
791 PKIX_NULLCHECK_TWO(params, pConstraints);
793 PKIX_INCREF(params->constraints);
794 *pConstraints = params->constraints;
796 cleanup:
797 PKIX_RETURN(PROCESSINGPARAMS);
798 }
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 {
811 PKIX_ENTER(PROCESSINGPARAMS,
812 "PKIX_ProcessingParams_SetTargetCertConstraints");
814 PKIX_NULLCHECK_ONE(params);
816 PKIX_DECREF(params->constraints);
818 PKIX_INCREF(constraints);
819 params->constraints = constraints;
821 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
822 ((PKIX_PL_Object *)params, plContext),
823 PKIX_OBJECTINVALIDATECACHEFAILED);
825 cleanup:
826 if (PKIX_ERROR_RECEIVED && params) {
827 PKIX_DECREF(params->constraints);
828 }
830 PKIX_RETURN(PROCESSINGPARAMS);
831 }
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 {
844 PKIX_ENTER(PROCESSINGPARAMS,
845 "PKIX_ProcessingParams_GetInitialPolicies");
847 PKIX_NULLCHECK_TWO(params, pInitPolicies);
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 }
861 PKIX_INCREF(params->initialPolicies);
862 *pInitPolicies = params->initialPolicies;
864 cleanup:
866 PKIX_RETURN(PROCESSINGPARAMS);
867 }
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);
883 PKIX_DECREF(params->initialPolicies);
885 PKIX_INCREF(initPolicies);
886 params->initialPolicies = initPolicies;
888 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
889 ((PKIX_PL_Object *)params, plContext),
890 PKIX_OBJECTINVALIDATECACHEFAILED);
892 cleanup:
894 if (PKIX_ERROR_RECEIVED && params) {
895 PKIX_DECREF(params->initialPolicies);
896 }
897 PKIX_RETURN(PROCESSINGPARAMS);
898 }
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");
913 PKIX_NULLCHECK_TWO(params, pRejected);
915 *pRejected = params->qualifiersRejected;
917 PKIX_RETURN(PROCESSINGPARAMS);
918 }
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");
933 PKIX_NULLCHECK_ONE(params);
935 params->qualifiersRejected = rejected;
937 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
938 ((PKIX_PL_Object *)params, plContext),
939 PKIX_OBJECTINVALIDATECACHEFAILED);
941 cleanup:
943 PKIX_RETURN(PROCESSINGPARAMS);
944 }
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);
960 PKIX_INCREF(params->certChainCheckers);
961 *pCheckers = params->certChainCheckers;
963 cleanup:
964 PKIX_RETURN(PROCESSINGPARAMS);
965 }
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 {
978 PKIX_ENTER(PROCESSINGPARAMS,
979 "PKIX_ProcessingParams_SetCertChainCheckers");
980 PKIX_NULLCHECK_ONE(params);
982 PKIX_DECREF(params->certChainCheckers);
984 PKIX_INCREF(checkers);
985 params->certChainCheckers = checkers;
987 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
988 ((PKIX_PL_Object *)params, plContext),
989 PKIX_OBJECTINVALIDATECACHEFAILED);
991 cleanup:
993 if (PKIX_ERROR_RECEIVED && params) {
994 PKIX_DECREF(params->certChainCheckers);
995 }
997 PKIX_RETURN(PROCESSINGPARAMS);
998 }
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;
1012 PKIX_ENTER(PROCESSINGPARAMS,
1013 "PKIX_ProcessingParams_AddCertChainChecker");
1014 PKIX_NULLCHECK_TWO(params, checker);
1016 if (params->certChainCheckers == NULL) {
1018 PKIX_CHECK(PKIX_List_Create(&list, plContext),
1019 PKIX_LISTCREATEFAILED);
1021 params->certChainCheckers = list;
1022 }
1024 PKIX_CHECK(PKIX_List_AppendItem
1025 (params->certChainCheckers, (PKIX_PL_Object *)checker, plContext),
1026 PKIX_LISTAPPENDITEMFAILED);
1028 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1029 ((PKIX_PL_Object *)params, plContext),
1030 PKIX_OBJECTINVALIDATECACHEFAILED);
1032 list = NULL;
1034 cleanup:
1036 if (list && params) {
1037 PKIX_DECREF(params->certChainCheckers);
1038 }
1040 PKIX_RETURN(PROCESSINGPARAMS);
1041 }
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 {
1054 PKIX_ENTER
1055 (PROCESSINGPARAMS, "PKIX_ProcessingParams_GetRevocationCheckers");
1056 PKIX_NULLCHECK_TWO(params, pChecker);
1058 PKIX_INCREF(params->revChecker);
1059 *pChecker = params->revChecker;
1061 cleanup:
1063 PKIX_RETURN(PROCESSINGPARAMS);
1064 }
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 {
1077 PKIX_ENTER(PROCESSINGPARAMS,
1078 "PKIX_ProcessingParams_InitRevocationChecker");
1079 PKIX_NULLCHECK_ONE(params);
1081 PKIX_DECREF(params->revChecker);
1082 PKIX_INCREF(checker);
1083 params->revChecker = checker;
1085 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1086 ((PKIX_PL_Object *)params, plContext),
1087 PKIX_OBJECTINVALIDATECACHEFAILED);
1088 cleanup:
1090 PKIX_RETURN(PROCESSINGPARAMS);
1091 }
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");
1105 PKIX_NULLCHECK_TWO(params, pStores);
1107 if (!params->certStores){
1108 PKIX_CHECK(PKIX_List_Create(¶ms->certStores, plContext),
1109 PKIX_UNABLETOCREATELIST);
1110 }
1112 PKIX_INCREF(params->certStores);
1113 *pStores = params->certStores;
1115 cleanup:
1117 PKIX_RETURN(PROCESSINGPARAMS);
1118 }
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");
1132 PKIX_NULLCHECK_ONE(params);
1134 PKIX_DECREF(params->certStores);
1136 PKIX_INCREF(stores);
1137 params->certStores = stores;
1139 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1140 ((PKIX_PL_Object *)params, plContext),
1141 PKIX_OBJECTINVALIDATECACHEFAILED);
1143 cleanup:
1145 if (PKIX_ERROR_RECEIVED && params) {
1146 PKIX_DECREF(params->certStores);
1147 }
1149 PKIX_RETURN(PROCESSINGPARAMS);
1150 }
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;
1164 PKIX_ENTER(PROCESSINGPARAMS, "PKIX_ProcessingParams_AddCertStore");
1165 PKIX_NULLCHECK_TWO(params, store);
1167 PKIX_CHECK(PKIX_ProcessingParams_GetCertStores
1168 (params, &certStores, plContext),
1169 PKIX_PROCESSINGPARAMSGETCERTSTORESFAILED);
1171 PKIX_CHECK(PKIX_List_AppendItem
1172 (certStores, (PKIX_PL_Object *)store, plContext),
1173 PKIX_LISTAPPENDITEMFAILED);
1175 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1176 ((PKIX_PL_Object *)params, plContext),
1177 PKIX_OBJECTINVALIDATECACHEFAILED);
1179 cleanup:
1181 PKIX_DECREF(certStores);
1182 PKIX_RETURN(PROCESSINGPARAMS);
1183 }
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");
1198 PKIX_NULLCHECK_TWO(params, resourceLimits);
1200 PKIX_DECREF(params->resourceLimits);
1201 PKIX_INCREF(resourceLimits);
1202 params->resourceLimits = resourceLimits;
1204 cleanup:
1205 if (PKIX_ERROR_RECEIVED && params) {
1206 PKIX_DECREF(params->resourceLimits);
1207 }
1209 PKIX_RETURN(PROCESSINGPARAMS);
1210 }
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");
1225 PKIX_NULLCHECK_TWO(params, pResourceLimits);
1227 PKIX_INCREF(params->resourceLimits);
1228 *pResourceLimits = params->resourceLimits;
1230 cleanup:
1231 PKIX_RETURN(PROCESSINGPARAMS);
1232 }
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");
1247 PKIX_NULLCHECK_TWO(params, pInhibited);
1249 *pInhibited = params->initialAnyPolicyInhibit;
1251 PKIX_RETURN(PROCESSINGPARAMS);
1252 }
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");
1267 PKIX_NULLCHECK_ONE(params);
1269 params->initialAnyPolicyInhibit = inhibited;
1271 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1272 ((PKIX_PL_Object *)params, plContext),
1273 PKIX_OBJECTINVALIDATECACHEFAILED);
1275 cleanup:
1277 PKIX_RETURN(PROCESSINGPARAMS);
1278 }
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");
1293 PKIX_NULLCHECK_TWO(params, pRequired);
1295 *pRequired = params->initialExplicitPolicy;
1297 PKIX_RETURN(PROCESSINGPARAMS);
1298 }
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");
1313 PKIX_NULLCHECK_ONE(params);
1315 params->initialExplicitPolicy = required;
1317 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1318 ((PKIX_PL_Object *)params, plContext),
1319 PKIX_OBJECTINVALIDATECACHEFAILED);
1321 cleanup:
1323 PKIX_RETURN(PROCESSINGPARAMS);
1324 }
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");
1339 PKIX_NULLCHECK_TWO(params, pInhibited);
1341 *pInhibited = params->initialPolicyMappingInhibit;
1343 PKIX_RETURN(PROCESSINGPARAMS);
1344 }
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");
1359 PKIX_NULLCHECK_ONE(params);
1361 params->initialPolicyMappingInhibit = inhibited;
1363 PKIX_CHECK(PKIX_PL_Object_InvalidateCache
1364 ((PKIX_PL_Object *)params, plContext),
1365 PKIX_OBJECTINVALIDATECACHEFAILED);
1367 cleanup:
1369 PKIX_RETURN(PROCESSINGPARAMS);
1370 }
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");
1384 PKIX_NULLCHECK_ONE(params);
1386 PKIX_DECREF(params->hintCerts);
1387 PKIX_INCREF(hintCerts);
1388 params->hintCerts = hintCerts;
1390 cleanup:
1391 if (PKIX_ERROR_RECEIVED && params) {
1392 PKIX_DECREF(params->hintCerts);
1393 }
1395 PKIX_RETURN(PROCESSINGPARAMS);
1396 }
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");
1410 PKIX_NULLCHECK_TWO(params, pHintCerts);
1412 PKIX_INCREF(params->hintCerts);
1413 *pHintCerts = params->hintCerts;
1415 cleanup:
1416 PKIX_RETURN(PROCESSINGPARAMS);
1417 }
