Mercurial > trustbridge > nss-cmake-static
comparison nss/lib/libpkix/pkix_pl_nss/pki/pkix_pl_certpolicyinfo.c @ 0:1e5118fa0cb1
This is NSS with a Cmake Buildsyste
To compile a static NSS library for Windows we've used the
Chromium-NSS fork and added a Cmake buildsystem to compile
it statically for Windows. See README.chromium for chromium
changes and README.trustbridge for our modifications.
author | Andre Heinecke <andre.heinecke@intevation.de> |
---|---|
date | Mon, 28 Jul 2014 10:47:06 +0200 |
parents | |
children |
comparison
equal
deleted
inserted
replaced
-1:000000000000 | 0:1e5118fa0cb1 |
---|---|
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_certpolicyinfo.c | |
6 * | |
7 * CertPolicyInfo Type Functions | |
8 * | |
9 */ | |
10 | |
11 #include "pkix_pl_certpolicyinfo.h" | |
12 | |
13 /* | |
14 * FUNCTION: pkix_pl_CertPolicyInfo_Create | |
15 * DESCRIPTION: | |
16 * | |
17 * Creates a new CertPolicyInfo Object using the OID pointed to by "oid" and | |
18 * the List of CertPolicyQualifiers pointed to by "qualifiers", and stores it | |
19 * at "pObject". If a non-NULL list is provided, the caller is expected to | |
20 * have already set it to be immutable. The caller may provide an empty List, | |
21 * but a NULL List is preferable so a user does not need to call | |
22 * List_GetLength to get the number of qualifiers. | |
23 * | |
24 * PARAMETERS | |
25 * "oid" | |
26 * OID of the desired PolicyInfo ID; must be non-NULL | |
27 * "qualifiers" | |
28 * List of CertPolicyQualifiers; may be NULL or empty | |
29 * "pObject" | |
30 * Address where object pointer will be stored. Must be non-NULL. | |
31 * "plContext" | |
32 * Platform-specific context pointer. | |
33 * THREAD SAFETY: | |
34 * Thread Safe (see Thread Safety Definitions in Programmer's Guide) | |
35 * RETURNS: | |
36 * Returns NULL if the function succeeds. | |
37 * Returns a Fatal Error if the function fails in an unrecoverable way. | |
38 */ | |
39 PKIX_Error * | |
40 pkix_pl_CertPolicyInfo_Create( | |
41 PKIX_PL_OID *oid, | |
42 PKIX_List *qualifiers, | |
43 PKIX_PL_CertPolicyInfo **pObject, | |
44 void *plContext) | |
45 { | |
46 PKIX_PL_CertPolicyInfo *policyInfo = NULL; | |
47 | |
48 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_Create"); | |
49 | |
50 PKIX_NULLCHECK_TWO(oid, pObject); | |
51 | |
52 PKIX_CHECK(PKIX_PL_Object_Alloc | |
53 (PKIX_CERTPOLICYINFO_TYPE, | |
54 sizeof (PKIX_PL_CertPolicyInfo), | |
55 (PKIX_PL_Object **)&policyInfo, | |
56 plContext), | |
57 PKIX_COULDNOTCREATECERTPOLICYINFOOBJECT); | |
58 | |
59 PKIX_INCREF(oid); | |
60 policyInfo->cpID = oid; | |
61 | |
62 PKIX_INCREF(qualifiers); | |
63 policyInfo->policyQualifiers = qualifiers; | |
64 | |
65 *pObject = policyInfo; | |
66 policyInfo = NULL; | |
67 | |
68 cleanup: | |
69 PKIX_DECREF(policyInfo); | |
70 | |
71 PKIX_RETURN(CERTPOLICYINFO); | |
72 } | |
73 | |
74 /* | |
75 * FUNCTION: pkix_pl_CertPolicyInfo_Destroy | |
76 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h) | |
77 */ | |
78 static PKIX_Error * | |
79 pkix_pl_CertPolicyInfo_Destroy( | |
80 PKIX_PL_Object *object, | |
81 void *plContext) | |
82 { | |
83 PKIX_PL_CertPolicyInfo *certPI = NULL; | |
84 | |
85 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_Destroy"); | |
86 | |
87 PKIX_NULLCHECK_ONE(object); | |
88 | |
89 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYINFO_TYPE, plContext), | |
90 PKIX_OBJECTNOTCERTPOLICYINFO); | |
91 | |
92 certPI = (PKIX_PL_CertPolicyInfo*)object; | |
93 | |
94 PKIX_DECREF(certPI->cpID); | |
95 PKIX_DECREF(certPI->policyQualifiers); | |
96 | |
97 cleanup: | |
98 | |
99 PKIX_RETURN(CERTPOLICYINFO); | |
100 } | |
101 | |
102 /* | |
103 * FUNCTION: pkix_pl_CertPolicyInfo_ToString | |
104 * (see comments for PKIX_PL_ToStringCallback in pkix_pl_system.h) | |
105 */ | |
106 static PKIX_Error * | |
107 pkix_pl_CertPolicyInfo_ToString( | |
108 PKIX_PL_Object *object, | |
109 PKIX_PL_String **pString, | |
110 void *plContext) | |
111 { | |
112 PKIX_PL_CertPolicyInfo *certPI = NULL; | |
113 PKIX_PL_String *oidString = NULL; | |
114 PKIX_PL_String *listString = NULL; | |
115 PKIX_PL_String *format = NULL; | |
116 PKIX_PL_String *outString = NULL; | |
117 | |
118 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_ToString"); | |
119 | |
120 PKIX_NULLCHECK_TWO(object, pString); | |
121 | |
122 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYINFO_TYPE, plContext), | |
123 PKIX_OBJECTNOTCERTPOLICYINFO); | |
124 | |
125 certPI = (PKIX_PL_CertPolicyInfo *)object; | |
126 | |
127 PKIX_NULLCHECK_ONE(certPI->cpID); | |
128 | |
129 PKIX_TOSTRING | |
130 (certPI->cpID, | |
131 &oidString, | |
132 plContext, | |
133 PKIX_OIDTOSTRINGFAILED); | |
134 | |
135 PKIX_TOSTRING | |
136 (certPI->policyQualifiers, | |
137 &listString, | |
138 plContext, | |
139 PKIX_LISTTOSTRINGFAILED); | |
140 | |
141 /* Put them together in the form OID[Qualifiers] */ | |
142 PKIX_CHECK(PKIX_PL_String_Create | |
143 (PKIX_ESCASCII, "%s[%s]", 0, &format, plContext), | |
144 PKIX_ERRORINSTRINGCREATE); | |
145 | |
146 PKIX_CHECK(PKIX_PL_Sprintf | |
147 (&outString, plContext, format, oidString, listString), | |
148 PKIX_ERRORINSPRINTF); | |
149 | |
150 *pString = outString; | |
151 | |
152 cleanup: | |
153 | |
154 PKIX_DECREF(oidString); | |
155 PKIX_DECREF(listString); | |
156 PKIX_DECREF(format); | |
157 PKIX_RETURN(CERTPOLICYINFO); | |
158 } | |
159 | |
160 /* | |
161 * FUNCTION: pkix_pl_CertPolicyInfo_Hashcode | |
162 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h) | |
163 */ | |
164 static PKIX_Error * | |
165 pkix_pl_CertPolicyInfo_Hashcode( | |
166 PKIX_PL_Object *object, | |
167 PKIX_UInt32 *pHashcode, | |
168 void *plContext) | |
169 { | |
170 PKIX_PL_CertPolicyInfo *certPI = NULL; | |
171 PKIX_UInt32 oidHash = 0; | |
172 PKIX_UInt32 listHash = 0; | |
173 | |
174 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_Hashcode"); | |
175 | |
176 PKIX_NULLCHECK_TWO(object, pHashcode); | |
177 | |
178 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTPOLICYINFO_TYPE, plContext), | |
179 PKIX_OBJECTNOTCERTPOLICYINFO); | |
180 | |
181 certPI = (PKIX_PL_CertPolicyInfo *)object; | |
182 | |
183 PKIX_NULLCHECK_ONE(certPI->cpID); | |
184 | |
185 PKIX_HASHCODE | |
186 (certPI->cpID, | |
187 &oidHash, | |
188 plContext, | |
189 PKIX_ERRORINOIDHASHCODE); | |
190 | |
191 PKIX_HASHCODE | |
192 (certPI->policyQualifiers, | |
193 &listHash, | |
194 plContext, | |
195 PKIX_ERRORINLISTHASHCODE); | |
196 | |
197 *pHashcode = (31 * oidHash) + listHash; | |
198 | |
199 cleanup: | |
200 | |
201 PKIX_RETURN(CERTPOLICYINFO); | |
202 } | |
203 | |
204 | |
205 /* | |
206 * FUNCTION: pkix_pl_CertPolicyInfo_Equals | |
207 * (see comments for PKIX_PL_Equals_Callback in pkix_pl_system.h) | |
208 */ | |
209 static PKIX_Error * | |
210 pkix_pl_CertPolicyInfo_Equals( | |
211 PKIX_PL_Object *firstObject, | |
212 PKIX_PL_Object *secondObject, | |
213 PKIX_Boolean *pResult, | |
214 void *plContext) | |
215 { | |
216 PKIX_PL_CertPolicyInfo *firstCPI = NULL; | |
217 PKIX_PL_CertPolicyInfo *secondCPI = NULL; | |
218 PKIX_UInt32 secondType = 0; | |
219 PKIX_Boolean compare = PKIX_FALSE; | |
220 | |
221 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_Equals"); | |
222 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult); | |
223 | |
224 /* test that firstObject is a CertPolicyInfo */ | |
225 PKIX_CHECK(pkix_CheckType | |
226 (firstObject, PKIX_CERTPOLICYINFO_TYPE, plContext), | |
227 PKIX_FIRSTOBJECTNOTCERTPOLICYINFO); | |
228 | |
229 /* | |
230 * Since we know firstObject is a CertPolicyInfo, | |
231 * if both references are identical, they must be equal | |
232 */ | |
233 if (firstObject == secondObject){ | |
234 *pResult = PKIX_TRUE; | |
235 goto cleanup; | |
236 } | |
237 | |
238 /* | |
239 * If secondObject isn't a CertPolicyInfo, we | |
240 * don't throw an error. We simply return FALSE. | |
241 */ | |
242 PKIX_CHECK(PKIX_PL_Object_GetType | |
243 (secondObject, &secondType, plContext), | |
244 PKIX_COULDNOTGETTYPEOFSECONDARGUMENT); | |
245 if (secondType != PKIX_CERTPOLICYINFO_TYPE) { | |
246 *pResult = PKIX_FALSE; | |
247 goto cleanup; | |
248 } | |
249 | |
250 firstCPI = (PKIX_PL_CertPolicyInfo *)firstObject; | |
251 secondCPI = (PKIX_PL_CertPolicyInfo *)secondObject; | |
252 | |
253 /* | |
254 * Compare the value of the OID components | |
255 */ | |
256 | |
257 PKIX_NULLCHECK_TWO(firstCPI->cpID, secondCPI->cpID); | |
258 | |
259 PKIX_EQUALS | |
260 (firstCPI->cpID, | |
261 secondCPI->cpID, | |
262 &compare, | |
263 plContext, | |
264 PKIX_OIDEQUALSFAILED); | |
265 | |
266 /* | |
267 * If the OIDs did not match, we don't need to | |
268 * compare the Lists. If the OIDs did match, | |
269 * the return value is the value of the | |
270 * List comparison. | |
271 */ | |
272 if (compare) { | |
273 PKIX_EQUALS | |
274 (firstCPI->policyQualifiers, | |
275 secondCPI->policyQualifiers, | |
276 &compare, | |
277 plContext, | |
278 PKIX_LISTEQUALSFAILED); | |
279 } | |
280 | |
281 *pResult = compare; | |
282 | |
283 cleanup: | |
284 | |
285 PKIX_RETURN(CERTPOLICYINFO); | |
286 } | |
287 | |
288 /* | |
289 * FUNCTION: pkix_pl_CertPolicyInfo_RegisterSelf | |
290 * DESCRIPTION: | |
291 * Registers PKIX_CERTPOLICYINFO_TYPE and its related | |
292 * functions with systemClasses[] | |
293 * THREAD SAFETY: | |
294 * Not Thread Safe - for performance and complexity reasons | |
295 * | |
296 * Since this function is only called by PKIX_PL_Initialize, | |
297 * which should only be called once, it is acceptable that | |
298 * this function is not thread-safe. | |
299 */ | |
300 PKIX_Error * | |
301 pkix_pl_CertPolicyInfo_RegisterSelf(void *plContext) | |
302 { | |
303 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES]; | |
304 pkix_ClassTable_Entry entry; | |
305 | |
306 PKIX_ENTER(CERTPOLICYINFO, "pkix_pl_CertPolicyInfo_RegisterSelf"); | |
307 | |
308 entry.description = "CertPolicyInfo"; | |
309 entry.objCounter = 0; | |
310 entry.typeObjectSize = sizeof(PKIX_PL_CertPolicyInfo); | |
311 entry.destructor = pkix_pl_CertPolicyInfo_Destroy; | |
312 entry.equalsFunction = pkix_pl_CertPolicyInfo_Equals; | |
313 entry.hashcodeFunction = pkix_pl_CertPolicyInfo_Hashcode; | |
314 entry.toStringFunction = pkix_pl_CertPolicyInfo_ToString; | |
315 entry.comparator = NULL; | |
316 entry.duplicateFunction = pkix_duplicateImmutable; | |
317 | |
318 systemClasses[PKIX_CERTPOLICYINFO_TYPE] = entry; | |
319 | |
320 PKIX_RETURN(CERTPOLICYINFO); | |
321 } | |
322 | |
323 /* --Public-CertPolicyInfo-Functions------------------------- */ | |
324 | |
325 /* | |
326 * FUNCTION: PKIX_PL_CertPolicyInfo_GetPolicyId | |
327 * (see comments in pkix_pl_pki.h) | |
328 */ | |
329 PKIX_Error * | |
330 PKIX_PL_CertPolicyInfo_GetPolicyId( | |
331 PKIX_PL_CertPolicyInfo *policyInfo, | |
332 PKIX_PL_OID **pPolicyId, | |
333 void *plContext) | |
334 { | |
335 PKIX_ENTER(CERTPOLICYINFO, "PKIX_PL_CertPolicyInfo_GetPolicyId"); | |
336 | |
337 PKIX_NULLCHECK_TWO(policyInfo, pPolicyId); | |
338 | |
339 PKIX_INCREF(policyInfo->cpID); | |
340 | |
341 *pPolicyId = policyInfo->cpID; | |
342 | |
343 cleanup: | |
344 PKIX_RETURN(CERTPOLICYINFO); | |
345 } | |
346 | |
347 /* | |
348 * FUNCTION: PKIX_PL_CertPolicyInfo_GetPolQualifiers | |
349 * (see comments in pkix_pl_pki.h) | |
350 */ | |
351 PKIX_Error * | |
352 PKIX_PL_CertPolicyInfo_GetPolQualifiers( | |
353 PKIX_PL_CertPolicyInfo *policyInfo, | |
354 PKIX_List **pQuals, | |
355 void *plContext) | |
356 { | |
357 PKIX_ENTER(CERTPOLICYINFO, "PKIX_PL_CertPolicyInfo_GetPolQualifiers"); | |
358 | |
359 PKIX_NULLCHECK_TWO(policyInfo, pQuals); | |
360 | |
361 PKIX_INCREF(policyInfo->policyQualifiers); | |
362 | |
363 /* | |
364 * This List is created in PKIX_PL_Cert_DecodePolicyInfo | |
365 * and is set immutable immediately after being created. | |
366 */ | |
367 *pQuals = policyInfo->policyQualifiers; | |
368 | |
369 cleanup: | |
370 PKIX_RETURN(CERTPOLICYINFO); | |
371 } |