Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(138)

Side by Side Diff: nss/lib/libpkix/pkix/store/pkix_store.c

Issue 2078763002: Delete bundled copy of NSS and replace with README. (Closed) Base URL: https://chromium.googlesource.com/chromium/deps/nss@master
Patch Set: Delete bundled copy of NSS and replace with README. Created 4 years, 6 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « nss/lib/libpkix/pkix/store/pkix_store.h ('k') | nss/lib/libpkix/pkix/top/pkix_build.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
(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_store.c
6 *
7 * CertStore Function Definitions
8 *
9 */
10
11 #include "pkix_store.h"
12
13 /* --CertStore-Private-Functions----------------------------------------- */
14
15 /*
16 * FUNCTION: pkix_CertStore_Destroy
17 * (see comments for PKIX_PL_DestructorCallback in pkix_pl_system.h)
18 */
19 static PKIX_Error *
20 pkix_CertStore_Destroy(
21 PKIX_PL_Object *object,
22 void *plContext)
23 {
24 PKIX_CertStore *certStore = NULL;
25
26 PKIX_ENTER(CERTSTORE, "pkix_CertStore_Destroy");
27 PKIX_NULLCHECK_ONE(object);
28
29 /* Check that this object is a CertStore object */
30 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTSTORE_TYPE, plContext),
31 PKIX_OBJECTNOTCERTSTORE);
32
33 certStore = (PKIX_CertStore *)object;
34
35 certStore->certCallback = NULL;
36 certStore->crlCallback = NULL;
37 certStore->certContinue = NULL;
38 certStore->crlContinue = NULL;
39 certStore->trustCallback = NULL;
40
41 PKIX_DECREF(certStore->certStoreContext);
42
43 cleanup:
44
45 PKIX_RETURN(CERTSTORE);
46 }
47
48 /*
49 * FUNCTION: pkix_CertStore_Hashcode
50 * (see comments for PKIX_PL_HashcodeCallback in pkix_pl_system.h)
51 */
52 static PKIX_Error *
53 pkix_CertStore_Hashcode(
54 PKIX_PL_Object *object,
55 PKIX_UInt32 *pHashcode,
56 void *plContext)
57 {
58 PKIX_CertStore *certStore = NULL;
59 PKIX_UInt32 tempHash = 0;
60
61 PKIX_ENTER(CERTSTORE, "pkix_CertStore_Hashcode");
62 PKIX_NULLCHECK_TWO(object, pHashcode);
63
64 PKIX_CHECK(pkix_CheckType(object, PKIX_CERTSTORE_TYPE, plContext),
65 PKIX_OBJECTNOTCERTSTORE);
66
67 certStore = (PKIX_CertStore *)object;
68
69 if (certStore->certStoreContext) {
70 PKIX_CHECK(PKIX_PL_Object_Hashcode
71 ((PKIX_PL_Object *) certStore->certStoreContext,
72 &tempHash,
73 plContext),
74 PKIX_CERTSTOREHASHCODEFAILED);
75 }
76
77 *pHashcode = (PKIX_UInt32)((char *)certStore->certCallback - (char *)NUL L) +
78 (PKIX_UInt32)((char *)certStore->crlCallback - (char *)NULL ) +
79 (PKIX_UInt32)((char *)certStore->certContinue - (char *)NUL L) +
80 (PKIX_UInt32)((char *)certStore->crlContinue - (char *)NULL ) +
81 (PKIX_UInt32)((char *)certStore->trustCallback - (char *)NU LL) +
82 (tempHash << 7);
83
84 cleanup:
85
86 PKIX_RETURN(CERTSTORE);
87 }
88
89 /*
90 * FUNCTION: pkix_CertStore_Equals
91 * (see comments for PKIX_PL_EqualsCallback in pkix_pl_system.h)
92 */
93 static PKIX_Error *
94 pkix_CertStore_Equals(
95 PKIX_PL_Object *firstObject,
96 PKIX_PL_Object *secondObject,
97 PKIX_Int32 *pResult,
98 void *plContext)
99 {
100 PKIX_CertStore *firstCS = NULL;
101 PKIX_CertStore *secondCS = NULL;
102 PKIX_Boolean cmpResult = PKIX_FALSE;
103
104 PKIX_ENTER(CERTSTORE, "pkix_CertStore_Equals");
105 PKIX_NULLCHECK_THREE(firstObject, secondObject, pResult);
106
107 PKIX_CHECK(pkix_CheckTypes
108 (firstObject, secondObject, PKIX_CERTSTORE_TYPE, plContext),
109 PKIX_ARGUMENTSNOTDATES);
110
111 firstCS = (PKIX_CertStore *)firstObject;
112 secondCS = (PKIX_CertStore *)secondObject;
113
114 cmpResult = (firstCS->certCallback == secondCS->certCallback) &&
115 (firstCS->crlCallback == secondCS->crlCallback) &&
116 (firstCS->certContinue == secondCS->certContinue) &&
117 (firstCS->crlContinue == secondCS->crlContinue) &&
118 (firstCS->trustCallback == secondCS->trustCallback);
119
120 if (cmpResult &&
121 (firstCS->certStoreContext != secondCS->certStoreContext)) {
122
123 PKIX_CHECK(PKIX_PL_Object_Equals
124 ((PKIX_PL_Object *) firstCS->certStoreContext,
125 (PKIX_PL_Object *) secondCS->certStoreContext,
126 &cmpResult,
127 plContext),
128 PKIX_CERTSTOREEQUALSFAILED);
129 }
130
131 *pResult = cmpResult;
132
133 cleanup:
134
135 PKIX_RETURN(CERTSTORE);
136 }
137
138 /*
139 * FUNCTION: pkix_CertStore_RegisterSelf
140 * DESCRIPTION:
141 * Registers PKIX_CERTSTORE_TYPE and its related functions with
142 * systemClasses[]
143 * THREAD SAFETY:
144 * Not Thread Safe - for performance and complexity reasons
145 *
146 * Since this function is only called by PKIX_PL_Initialize, which should
147 * only be called once, it is acceptable that this function is not
148 * thread-safe.
149 */
150 PKIX_Error *
151 pkix_CertStore_RegisterSelf(void *plContext)
152 {
153 extern pkix_ClassTable_Entry systemClasses[PKIX_NUMTYPES];
154 pkix_ClassTable_Entry entry;
155
156 PKIX_ENTER(CERTSTORE, "pkix_CertStore_RegisterSelf");
157
158 entry.description = "CertStore";
159 entry.objCounter = 0;
160 entry.typeObjectSize = sizeof(PKIX_CertStore);
161 entry.destructor = pkix_CertStore_Destroy;
162 entry.equalsFunction = pkix_CertStore_Equals;
163 entry.hashcodeFunction = pkix_CertStore_Hashcode;
164 entry.toStringFunction = NULL;
165 entry.comparator = NULL;
166 entry.duplicateFunction = pkix_duplicateImmutable;
167
168 systemClasses[PKIX_CERTSTORE_TYPE] = entry;
169
170 PKIX_RETURN(CERTSTORE);
171 }
172
173 /* --CertStore-Public-Functions------------------------------------------ */
174
175 /*
176 * FUNCTION: PKIX_CertStore_Create (see comments in pkix_certstore.h)
177 */
178 PKIX_Error *
179 PKIX_CertStore_Create(
180 PKIX_CertStore_CertCallback certCallback,
181 PKIX_CertStore_CRLCallback crlCallback,
182 PKIX_CertStore_CertContinueFunction certContinue,
183 PKIX_CertStore_CrlContinueFunction crlContinue,
184 PKIX_CertStore_CheckTrustCallback trustCallback,
185 PKIX_CertStore_ImportCrlCallback importCrlCallback,
186 PKIX_CertStore_CheckRevokationByCrlCallback checkRevByCrlCallback,
187 PKIX_PL_Object *certStoreContext,
188 PKIX_Boolean cacheFlag,
189 PKIX_Boolean localFlag,
190 PKIX_CertStore **pStore,
191 void *plContext)
192 {
193 PKIX_CertStore *certStore = NULL;
194
195 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_Create");
196 PKIX_NULLCHECK_THREE(certCallback, crlCallback, pStore);
197
198 PKIX_CHECK(PKIX_PL_Object_Alloc
199 (PKIX_CERTSTORE_TYPE,
200 sizeof (PKIX_CertStore),
201 (PKIX_PL_Object **)&certStore,
202 plContext),
203 PKIX_COULDNOTCREATECERTSTOREOBJECT);
204
205 certStore->certCallback = certCallback;
206 certStore->crlCallback = crlCallback;
207 certStore->certContinue = certContinue;
208 certStore->crlContinue = crlContinue;
209 certStore->trustCallback = trustCallback;
210 certStore->importCrlCallback = importCrlCallback;
211 certStore->checkRevByCrlCallback = checkRevByCrlCallback;
212 certStore->cacheFlag = cacheFlag;
213 certStore->localFlag = localFlag;
214
215 PKIX_INCREF(certStoreContext);
216 certStore->certStoreContext = certStoreContext;
217
218 *pStore = certStore;
219 certStore = NULL;
220
221 cleanup:
222
223 PKIX_DECREF(certStore);
224
225 PKIX_RETURN(CERTSTORE);
226 }
227
228 /*
229 * FUNCTION: PKIX_CertStore_GetCertCallback (see comments in pkix_certstore.h)
230 */
231 PKIX_Error *
232 PKIX_CertStore_GetCertCallback(
233 PKIX_CertStore *store,
234 PKIX_CertStore_CertCallback *pCallback,
235 void *plContext)
236 {
237 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetCertCallback");
238 PKIX_NULLCHECK_TWO(store, pCallback);
239
240 *pCallback = store->certCallback;
241
242 PKIX_RETURN(CERTSTORE);
243 }
244
245 /*
246 * FUNCTION: PKIX_CertStore_GetCRLCallback (see comments in pkix_certstore.h)
247 */
248 PKIX_Error *
249 PKIX_CertStore_GetCRLCallback(
250 PKIX_CertStore *store,
251 PKIX_CertStore_CRLCallback *pCallback,
252 void *plContext)
253 {
254 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetCRLCallback");
255 PKIX_NULLCHECK_TWO(store, pCallback);
256
257 *pCallback = store->crlCallback;
258
259 PKIX_RETURN(CERTSTORE);
260 }
261
262 /*
263 * FUNCTION: PKIX_CertStore_CertContinue (see comments in pkix_certstore.h)
264 */
265 PKIX_Error *
266 PKIX_CertStore_CertContinue(
267 PKIX_CertStore *store,
268 PKIX_CertSelector *selector,
269 PKIX_VerifyNode *verifyNode,
270 void **pNBIOContext,
271 PKIX_List **pCertList,
272 void *plContext)
273 {
274 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_CertContinue");
275 PKIX_NULLCHECK_FOUR(store, selector, pNBIOContext, pCertList);
276
277 PKIX_CHECK(store->certContinue
278 (store, selector, verifyNode,
279 pNBIOContext, pCertList, plContext),
280 PKIX_CERTSTORECERTCONTINUEFUNCTIONFAILED);
281
282 cleanup:
283
284 PKIX_RETURN(CERTSTORE);
285 }
286
287 /*
288 * FUNCTION: PKIX_CertStore_CrlContinue (see comments in pkix_certstore.h)
289 */
290 PKIX_Error *
291 PKIX_CertStore_CrlContinue(
292 PKIX_CertStore *store,
293 PKIX_CRLSelector *selector,
294 void **pNBIOContext,
295 PKIX_List **pCrlList,
296 void *plContext)
297 {
298 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_CrlContinue");
299 PKIX_NULLCHECK_FOUR(store, selector, pNBIOContext, pCrlList);
300
301 PKIX_CHECK(store->crlContinue
302 (store, selector, pNBIOContext, pCrlList, plContext),
303 PKIX_CERTSTORECRLCONTINUEFAILED);
304
305 cleanup:
306
307 PKIX_RETURN(CERTSTORE);
308 }
309
310 /*
311 * FUNCTION: PKIX_CertStore_GetTrustCallback (see comments in pkix_certstore.h)
312 */
313 PKIX_Error *
314 PKIX_CertStore_GetTrustCallback(
315 PKIX_CertStore *store,
316 PKIX_CertStore_CheckTrustCallback *pCallback,
317 void *plContext)
318 {
319 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetTrustCallback");
320 PKIX_NULLCHECK_TWO(store, pCallback);
321
322 *pCallback = store->trustCallback;
323
324 PKIX_RETURN(CERTSTORE);
325 }
326
327 /*
328 * FUNCTION: PKIX_CertStore_GetImportCrlCallback (see comments in pkix_certstore .h)
329 */
330 PKIX_Error *
331 PKIX_CertStore_GetImportCrlCallback(
332 PKIX_CertStore *store,
333 PKIX_CertStore_ImportCrlCallback *pCallback,
334 void *plContext)
335 {
336 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetTrustCallback");
337 PKIX_NULLCHECK_TWO(store, pCallback);
338
339 *pCallback = store->importCrlCallback;
340
341 PKIX_RETURN(CERTSTORE);
342 }
343
344 /*
345 * FUNCTION: PKIX_CertStore_GetCheckRevByCrl (see comments in pkix_certstore.h)
346 */
347 PKIX_Error *
348 PKIX_CertStore_GetCrlCheckerFn(
349 PKIX_CertStore *store,
350 PKIX_CertStore_CheckRevokationByCrlCallback *pCallback,
351 void *plContext)
352 {
353 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetTrustCallback");
354 PKIX_NULLCHECK_TWO(store, pCallback);
355
356 *pCallback = store->checkRevByCrlCallback;
357
358 PKIX_RETURN(CERTSTORE);
359 }
360
361 /*
362 * FUNCTION: PKIX_CertStore_GetCertStoreContext
363 * (see comments in pkix_certstore.h)
364 */
365 PKIX_Error *
366 PKIX_CertStore_GetCertStoreContext(
367 PKIX_CertStore *store,
368 PKIX_PL_Object **pCertStoreContext,
369 void *plContext)
370 {
371 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetCertStoreContext");
372 PKIX_NULLCHECK_TWO(store, pCertStoreContext);
373
374 PKIX_INCREF(store->certStoreContext);
375 *pCertStoreContext = store->certStoreContext;
376
377 cleanup:
378 PKIX_RETURN(CERTSTORE);
379 }
380
381 /*
382 * FUNCTION: PKIX_CertStore_GetCertStoreCacheFlag
383 * (see comments in pkix_certstore.h)
384 */
385 PKIX_Error *
386 PKIX_CertStore_GetCertStoreCacheFlag(
387 PKIX_CertStore *store,
388 PKIX_Boolean *pCacheFlag,
389 void *plContext)
390 {
391 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetCertStoreCacheFlag");
392 PKIX_NULLCHECK_TWO(store, pCacheFlag);
393
394 *pCacheFlag = store->cacheFlag;
395
396 PKIX_RETURN(CERTSTORE);
397 }
398
399 /*
400 * FUNCTION: PKIX_CertStore_GetLocalFlag
401 * (see comments in pkix_certstore.h)
402 */
403 PKIX_Error *
404 PKIX_CertStore_GetLocalFlag(
405 PKIX_CertStore *store,
406 PKIX_Boolean *pLocalFlag,
407 void *plContext)
408 {
409 PKIX_ENTER(CERTSTORE, "PKIX_CertStore_GetLocalFlag");
410 PKIX_NULLCHECK_TWO(store, pLocalFlag);
411
412 *pLocalFlag = store->localFlag;
413
414 PKIX_RETURN(CERTSTORE);
415 }
OLDNEW
« no previous file with comments | « nss/lib/libpkix/pkix/store/pkix_store.h ('k') | nss/lib/libpkix/pkix/top/pkix_build.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698