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_pl_certpolicymap.c
6 *
7 * CertPolicyMap Type Functions
8 *
9 */
10
11 #include "pkix_pl_certpolicymap.h"
12
13 /*
14 * FUNCTION: pkix_pl_CertPolicyMap_Create
15 * DESCRIPTION:
16 *
17 * Creates a new CertPolicyMap Object pairing the OID given by
18 * "issuerDomainPolicy" with the OID given by "subjectDomainPolicy", and
19 * stores the result at "pCertPolicyMap".
20 *
21 * PARAMETERS
22 * "issuerDomainPolicy"
23 * Address of the OID of the IssuerDomainPolicy. Must be non-NULL.
24 * "subjectDomainPolicy"
25 * Address of the OID of the SubjectDomainPolicy. Must be non-NULL.
26 * "pCertPolicyMap"
27 * Address where CertPolicyMap pointer will be stored. Must be non-NULL.
28 * "plContext"
29 * Platform-specific context pointer.
30 * THREAD SAFETY:
31 * Thread Safe (see Thread Safety Definitions in Programmer's Guide)
32 * RETURNS:
33 * Returns NULL if the function succeeds.
34 * Returns a CertPolicyMap Error if the function fails in a non-fatal way.
35 * Returns a Fatal Error if the function fails in an unrecoverable way.
36 */
37 PKIX_Error *
pkix_pl_CertPolicyMap_Create(PKIX_PL_OID * issuerDomainPolicy,PKIX_PL_OID * subjectDomainPolicy,PKIX_PL_CertPolicyMap ** pCertPolicyMap,void * plContext)38 pkix_pl_CertPolicyMap_Create(
39 PKIX_PL_OID *issuerDomainPolicy,
40 PKIX_PL_OID *subjectDomainPolicy,
41 PKIX_PL_CertPolicyMap **pCertPolicyMap,
42 void *plContext)
43 {
44 PKIX_PL_CertPolicyMap *policyMap = NULL;
45
46 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Create");
47
48 PKIX_NULLCHECK_THREE
49 (issuerDomainPolicy, subjectDomainPolicy, pCertPolicyMap);
50
51 PKIX_CHECK(PKIX_PL_Object_Alloc
52 (PKIX_CERTPOLICYMAP_TYPE,
53 sizeof (PKIX_PL_CertPolicyMap),
54 (PKIX_PL_Object **)&policyMap,
55 plContext),
56 PKIX_COULDNOTCREATECERTPOLICYMAPOBJECT);
57
58 PKIX_INCREF(issuerDomainPolicy);
59 policyMap->issuerDomainPolicy = issuerDomainPolicy;
60
61 PKIX_INCREF(subjectDomainPolicy);
62 policyMap->subjectDomainPolicy = subjectDomainPolicy;
63
64 *pCertPolicyMap = policyMap;
65 policyMap = NULL;
66
67 cleanup:
68 PKIX_DECREF(policyMap);
69
70 PKIX_RETURN(CERTPOLICYMAP);
71 }
72
73 /*
74 * FUNCTION: pkix_pl_CertPolicyMap_Destroy
75 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
76 */
77 static PKIX_Error *
pkix_pl_CertPolicyMap_Destroy(PKIX_PL_Object * object,void * plContext)78 pkix_pl_CertPolicyMap_Destroy(
79 PKIX_PL_Object *object,
80 void *plContext)
81 {
82 PKIX_PL_CertPolicyMap *certMap = NULL;
83
84 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Destroy");
85
86 PKIX_NULLCHECK_ONE(object);
87
88 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYMAP_TYPE, plContext),
89 PKIX_OBJECTNOTCERTPOLICYMAP);
90
91 certMap = (PKIX_PL_CertPolicyMap*)object;
92
93 PKIX_DECREF(certMap->issuerDomainPolicy);
94 PKIX_DECREF(certMap->subjectDomainPolicy);
95
96 cleanup:
97
98 PKIX_RETURN(CERTPOLICYMAP);
99 }
100
101 /*
102 * FUNCTION: pkix_pl_CertPolicyMap_ToString
103 * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h)
104 */
105 static PKIX_Error *
pkix_pl_CertPolicyMap_ToString(PKIX_PL_Object * object,PKIX_PL_String ** pString,void * plContext)106 pkix_pl_CertPolicyMap_ToString(
107 PKIX_PL_Object *object,
108 PKIX_PL_String **pString,
109 void *plContext)
110 {
111 PKIX_PL_CertPolicyMap *certMap = NULL;
112 PKIX_PL_String *format = NULL;
113 PKIX_PL_String *outString = NULL;
114 PKIX_PL_String *issuerString = NULL;
115 PKIX_PL_String *subjectString = NULL;
116
117 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_ToString");
118
119 PKIX_NULLCHECK_TWO(object, pString);
120
121 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYMAP_TYPE, plContext),
122 PKIX_OBJECTNOTCERTPOLICYMAP);
123
124 certMap = (PKIX_PL_CertPolicyMap *)object;
125
126 PKIX_TOSTRING
127 (certMap->issuerDomainPolicy,
128 &issuerString,
129 plContext,
130 PKIX_OBJECTTOSTRINGFAILED);
131
132 PKIX_TOSTRING
133 (certMap->subjectDomainPolicy,
134 &subjectString,
135 plContext,
136 PKIX_OBJECTTOSTRINGFAILED);
137
138 /* Put them together in the form issuerPolicy=>subjectPolicy */
139 PKIX_CHECK(PKIX_PL_String_Create
140 (PKIX_ESCASCII, "%s=>%s", 0, &format, plContext),
141 PKIX_ERRORINSTRINGCREATE);
142
143 PKIX_CHECK(PKIX_PL_Sprintf
144 (&outString, plContext, format, issuerString, subjectString),
145 PKIX_ERRORINSPRINTF);
146
147 *pString = outString;
148
149 cleanup:
150 PKIX_DECREF(format);
151 PKIX_DECREF(issuerString);
152 PKIX_DECREF(subjectString);
153
154 PKIX_RETURN(CERTPOLICYMAP);
155 }
156
157 /*
158 * FUNCTION: pkix_pl_CertPolicyMap_Hashcode
159 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
160 */
161 static PKIX_Error *
pkix_pl_CertPolicyMap_Hashcode(PKIX_PL_Object * object,PKIX_UInt32 * pHashcode,void * plContext)162 pkix_pl_CertPolicyMap_Hashcode(
163 PKIX_PL_Object *object,
164 PKIX_UInt32 *pHashcode,
165 void *plContext)
166 {
167 PKIX_UInt32 issuerHash = 0;
168 PKIX_UInt32 subjectHash = 0;
169 PKIX_PL_CertPolicyMap *certMap = NULL;
170
171 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Hashcode");
172
173 PKIX_NULLCHECK_TWO(object, pHashcode);
174
175 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYMAP_TYPE, plContext),
176 PKIX_OBJECTNOTCERTPOLICYMAP);
177
178 certMap = (PKIX_PL_CertPolicyMap *)object;
179
180 PKIX_HASHCODE
181 (certMap->issuerDomainPolicy,
182 &issuerHash,
183 plContext,
184 PKIX_OBJECTHASHCODEFAILED);
185
186 PKIX_HASHCODE
187 (certMap->subjectDomainPolicy,
188 &subjectHash,
189 plContext,
190 PKIX_OBJECTHASHCODEFAILED);
191
192 *pHashcode = issuerHash*31 + subjectHash;
193
194 cleanup:
195
196 PKIX_RETURN(CERTPOLICYMAP);
197 }
198
199 /*
200 * FUNCTION: pkix_pl_CertPolicyMap_Equals
201 * (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h)
202 */
203 static PKIX_Error *
pkix_pl_CertPolicyMap_Equals(PKIX_PL_Object * firstObject,PKIX_PL_Object * secondObject,PKIX_Boolean * pResult,void * plContext)204 pkix_pl_CertPolicyMap_Equals(
205 PKIX_PL_Object *firstObject,
206 PKIX_PL_Object *secondObject,
207 PKIX_Boolean *pResult,
208 void *plContext)
209 {
210 PKIX_PL_CertPolicyMap *firstCertMap = NULL;
211 PKIX_PL_CertPolicyMap *secondCertMap = NULL;
212 PKIX_UInt32 secondType = 0;
213 PKIX_Boolean compare = PKIX_FALSE;
214
215 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Equals");
216 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
217
218 /* test that firstObject is a CertPolicyMap */
219 PKIX_CHECK(pkix_CheckType
220 (firstObject, PKIX_CERTPOLICYMAP_TYPE, plContext),
221 PKIX_FIRSTOBJECTNOTCERTPOLICYMAP);
222
223 /*
224 * Since we know firstObject is a CertPolicyMap,
225 * if both references are identical, they must be equal
226 */
227 if (firstObject == secondObject){
228 *pResult = PKIX_TRUE;
229 goto cleanup;
230 }
231
232 /*
233 * If secondObject isn't a CertPolicyMap, we
234 * don't throw an error. We simply return FALSE.
235 */
236 PKIX_CHECK(PKIX_PL_Object_GetType
237 (secondObject, &secondType, plContext),
238 PKIX_COULDNOTGETTYPEOFSECONDARGUMENT);
239 if (secondType != PKIX_CERTPOLICYMAP_TYPE) {
240 *pResult = PKIX_FALSE;
241 goto cleanup;
242 }
243
244 firstCertMap = (PKIX_PL_CertPolicyMap *)firstObject;
245 secondCertMap = (PKIX_PL_CertPolicyMap *)secondObject;
246
247 PKIX_EQUALS
248 (firstCertMap->issuerDomainPolicy,
249 secondCertMap->issuerDomainPolicy,
250 &compare,
251 plContext,
252 PKIX_OBJECTEQUALSFAILED);
253
254 if (compare) {
255 PKIX_EQUALS
256 (firstCertMap->subjectDomainPolicy,
257 secondCertMap->subjectDomainPolicy,
258 &compare,
259 plContext,
260 PKIX_OBJECTEQUALSFAILED);
261 }
262
263 *pResult = compare;
264
265 cleanup:
266
267 PKIX_RETURN(CERTPOLICYMAP);
268 }
269
270 /*
271 * FUNCTION: pkix_pl_CertPolicyMap_Duplicate
272 * (see comments for PKIX_PL_Duplicate_Callback in pkix_pl_system.h)
273 */
274 static PKIX_Error *
pkix_pl_CertPolicyMap_Duplicate(PKIX_PL_Object * object,PKIX_PL_Object ** pNewObject,void * plContext)275 pkix_pl_CertPolicyMap_Duplicate(
276 PKIX_PL_Object *object,
277 PKIX_PL_Object **pNewObject,
278 void *plContext)
279 {
280 PKIX_PL_CertPolicyMap *original = NULL;
281 PKIX_PL_CertPolicyMap *copy = NULL;
282
283 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_Duplicate");
284
285 PKIX_NULLCHECK_TWO(object, pNewObject);
286
287 PKIX_CHECK(pkix_CheckType
288 (object, PKIX_CERTPOLICYMAP_TYPE, plContext),
289 PKIX_OBJECTARGUMENTNOTPOLICYMAP);
290
291 original = (PKIX_PL_CertPolicyMap *)object;
292
293 PKIX_CHECK(pkix_pl_CertPolicyMap_Create
294 (original->issuerDomainPolicy,
295 original->subjectDomainPolicy,
296 ©,
297 plContext),
298 PKIX_CERTPOLICYMAPCREATEFAILED);
299
300 *pNewObject = (PKIX_PL_Object *)copy;
301
302 cleanup:
303
304 PKIX_RETURN(CERTPOLICYMAP);
305 }
306
307 /*
308 * FUNCTION: pkix_pl_CertPolicyMap_RegisterSelf
309 * DESCRIPTION:
310 * Registers PKIX_CERTPOLICYMAP_TYPE and its related
311 * functions with systemClasses[]
312 * THREAD SAFETY:
313 * Not Thread Safe - for performance and complexity reasons
314 *
315 * Since this function is only called by PKIX_PL_Initialize,
316 * which should only be called once, it is acceptable that
317 * this function is not thread-safe.
318 */
319 PKIX_Error *
pkix_pl_CertPolicyMap_RegisterSelf(void * plContext)320 pkix_pl_CertPolicyMap_RegisterSelf(void *plContext)
321 {
322 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
323 pkix_ClassTable_Entry entry;
324
325 PKIX_ENTER(CERTPOLICYMAP, "pkix_pl_CertPolicyMap_RegisterSelf");
326
327 entry.description = "CertPolicyMap";
328 entry.objCounter = 0;
329 entry.typeObjectSize = sizeof(PKIX_PL_CertPolicyMap);
330 entry.destructor = pkix_pl_CertPolicyMap_Destroy;
331 entry.equalsFunction = pkix_pl_CertPolicyMap_Equals;
332 entry.hashcodeFunction = pkix_pl_CertPolicyMap_Hashcode;
333 entry.toStringFunction = pkix_pl_CertPolicyMap_ToString;
334 entry.comparator = NULL;
335 entry.duplicateFunction = pkix_pl_CertPolicyMap_Duplicate;
336
337 systemClasses[PKIX_CERTPOLICYMAP_TYPE] = entry;
338
339 PKIX_RETURN(CERTPOLICYMAP);
340 }
341
342 /* --Public-CertPolicyMap-Functions------------------------- */
343
344 /*
345 * FUNCTION: PKIX_PL_CertPolicyMap_GetIssuerDomainPolicy
346 * (see comments in pkix_pl_pki.h)
347 */
348 PKIX_Error *
PKIX_PL_CertPolicyMap_GetIssuerDomainPolicy(PKIX_PL_CertPolicyMap * policyMapping,PKIX_PL_OID ** pIssuerDomainPolicy,void * plContext)349 PKIX_PL_CertPolicyMap_GetIssuerDomainPolicy(
350 PKIX_PL_CertPolicyMap *policyMapping,
351 PKIX_PL_OID **pIssuerDomainPolicy,
352 void *plContext)
353 {
354 PKIX_ENTER
355 (CERTPOLICYMAP, "PKIX_PL_CertPolicyMap_GetIssuerDomainPolicy");
356
357 PKIX_NULLCHECK_TWO(policyMapping, pIssuerDomainPolicy);
358
359 PKIX_INCREF(policyMapping->issuerDomainPolicy);
360 *pIssuerDomainPolicy = policyMapping->issuerDomainPolicy;
361
362 cleanup:
363 PKIX_RETURN(CERTPOLICYMAP);
364 }
365
366 /*
367 * FUNCTION: PKIX_PL_CertPolicyMap_GetSubjectDomainPolicy
368 * (see comments in pkix_pl_pki.h)
369 */
370 PKIX_Error *
PKIX_PL_CertPolicyMap_GetSubjectDomainPolicy(PKIX_PL_CertPolicyMap * policyMapping,PKIX_PL_OID ** pSubjectDomainPolicy,void * plContext)371 PKIX_PL_CertPolicyMap_GetSubjectDomainPolicy(
372 PKIX_PL_CertPolicyMap *policyMapping,
373 PKIX_PL_OID **pSubjectDomainPolicy,
374 void *plContext)
375 {
376 PKIX_ENTER
377 (CERTPOLICYMAP, "PKIX_PL_CertPolicyMap_GetSubjectDomainPolicy");
378
379 PKIX_NULLCHECK_TWO(policyMapping, pSubjectDomainPolicy);
380
381 PKIX_INCREF(policyMapping->subjectDomainPolicy);
382 *pSubjectDomainPolicy = policyMapping->subjectDomainPolicy;
383
384 cleanup:
385 PKIX_RETURN(CERTPOLICYMAP);
386 }
387