Rename functions for new convention.
[openssl.git] / crypto / x509 / x509_lu.c
1 /* crypto/x509/x509_lu.c */
2 /* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
3  * All rights reserved.
4  *
5  * This package is an SSL implementation written
6  * by Eric Young (eay@cryptsoft.com).
7  * The implementation was written so as to conform with Netscapes SSL.
8  * 
9  * This library is free for commercial and non-commercial use as long as
10  * the following conditions are aheared to.  The following conditions
11  * apply to all code found in this distribution, be it the RC4, RSA,
12  * lhash, DES, etc., code; not just the SSL code.  The SSL documentation
13  * included with this distribution is covered by the same copyright terms
14  * except that the holder is Tim Hudson (tjh@cryptsoft.com).
15  * 
16  * Copyright remains Eric Young's, and as such any Copyright notices in
17  * the code are not to be removed.
18  * If this package is used in a product, Eric Young should be given attribution
19  * as the author of the parts of the library used.
20  * This can be in the form of a textual message at program startup or
21  * in documentation (online or textual) provided with the package.
22  * 
23  * Redistribution and use in source and binary forms, with or without
24  * modification, are permitted provided that the following conditions
25  * are met:
26  * 1. Redistributions of source code must retain the copyright
27  *    notice, this list of conditions and the following disclaimer.
28  * 2. Redistributions in binary form must reproduce the above copyright
29  *    notice, this list of conditions and the following disclaimer in the
30  *    documentation and/or other materials provided with the distribution.
31  * 3. All advertising materials mentioning features or use of this software
32  *    must display the following acknowledgement:
33  *    "This product includes cryptographic software written by
34  *     Eric Young (eay@cryptsoft.com)"
35  *    The word 'cryptographic' can be left out if the rouines from the library
36  *    being used are not cryptographic related :-).
37  * 4. If you include any Windows specific code (or a derivative thereof) from 
38  *    the apps directory (application code) you must include an acknowledgement:
39  *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
40  * 
41  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
42  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
43  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
44  * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
45  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
46  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
47  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
49  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
50  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
51  * SUCH DAMAGE.
52  * 
53  * The licence and distribution terms for any publically available version or
54  * derivative of this code cannot be changed.  i.e. this code cannot simply be
55  * copied and put under another distribution licence
56  * [including the GNU Public Licence.]
57  */
58
59 #include <stdio.h>
60 #include "cryptlib.h"
61 #include <openssl/lhash.h>
62 #include <openssl/x509.h>
63
64 static STACK_OF(CRYPTO_EX_DATA_FUNCS) *x509_store_meth=NULL;
65 static STACK_OF(CRYPTO_EX_DATA_FUNCS) *x509_store_ctx_meth=NULL;
66
67 X509_LOOKUP *X509_LOOKUP_new(X509_LOOKUP_METHOD *method)
68         {
69         X509_LOOKUP *ret;
70
71         ret=(X509_LOOKUP *)Malloc(sizeof(X509_LOOKUP));
72         if (ret == NULL) return(NULL);
73
74         ret->init=0;
75         ret->skip=0;
76         ret->method=method;
77         ret->method_data=NULL;
78         ret->store_ctx=NULL;
79         if ((method->new_item != NULL) && !method->new_item(ret))
80                 {
81                 Free(ret);
82                 return(NULL);
83                 }
84         return(ret);
85         }
86
87 void X509_LOOKUP_free(X509_LOOKUP *ctx)
88         {
89         if (ctx == NULL) return;
90         if (    (ctx->method != NULL) &&
91                 (ctx->method->free != NULL))
92                 ctx->method->free(ctx);
93         Free(ctx);
94         }
95
96 int X509_LOOKUP_init(X509_LOOKUP *ctx)
97         {
98         if (ctx->method == NULL) return(0);
99         if (ctx->method->init != NULL)
100                 return(ctx->method->init(ctx));
101         else
102                 return(1);
103         }
104
105 int X509_LOOKUP_shutdown(X509_LOOKUP *ctx)
106         {
107         if (ctx->method == NULL) return(0);
108         if (ctx->method->shutdown != NULL)
109                 return(ctx->method->shutdown(ctx));
110         else
111                 return(1);
112         }
113
114 int X509_LOOKUP_ctrl(X509_LOOKUP *ctx, int cmd, const char *argc, long argl,
115              char **ret)
116         {
117         if (ctx->method == NULL) return(-1);
118         if (ctx->method->ctrl != NULL)
119                 return(ctx->method->ctrl(ctx,cmd,argc,argl,ret));
120         else
121                 return(1);
122         }
123
124 int X509_LOOKUP_by_subject(X509_LOOKUP *ctx, int type, X509_NAME *name,
125              X509_OBJECT *ret)
126         {
127         if ((ctx->method == NULL) || (ctx->method->get_by_subject == NULL))
128                 return(X509_LU_FAIL);
129         if (ctx->skip) return(0);
130         return(ctx->method->get_by_subject(ctx,type,name,ret));
131         }
132
133 int X509_LOOKUP_by_issuer_serial(X509_LOOKUP *ctx, int type, X509_NAME *name,
134              ASN1_INTEGER *serial, X509_OBJECT *ret)
135         {
136         if ((ctx->method == NULL) ||
137                 (ctx->method->get_by_issuer_serial == NULL))
138                 return(X509_LU_FAIL);
139         return(ctx->method->get_by_issuer_serial(ctx,type,name,serial,ret));
140         }
141
142 int X509_LOOKUP_by_fingerprint(X509_LOOKUP *ctx, int type,
143              unsigned char *bytes, int len, X509_OBJECT *ret)
144         {
145         if ((ctx->method == NULL) || (ctx->method->get_by_fingerprint == NULL))
146                 return(X509_LU_FAIL);
147         return(ctx->method->get_by_fingerprint(ctx,type,bytes,len,ret));
148         }
149
150 int X509_LOOKUP_by_alias(X509_LOOKUP *ctx, int type, char *str, int len,
151              X509_OBJECT *ret)
152         {
153         if ((ctx->method == NULL) || (ctx->method->get_by_alias == NULL))
154                 return(X509_LU_FAIL);
155         return(ctx->method->get_by_alias(ctx,type,str,len,ret));
156         }
157
158 static unsigned long x509_object_hash(X509_OBJECT *a)
159         {
160         unsigned long h;
161
162         switch (a->type)
163                 {
164         case X509_LU_X509:
165                 h=X509_NAME_hash(a->data.x509->cert_info->subject);
166                 break;
167         case X509_LU_CRL:
168                 h=X509_NAME_hash(a->data.crl->crl->issuer);
169                 break;
170         default:
171                 abort();
172                 }
173         return(h);
174         }
175
176 static int x509_object_cmp(X509_OBJECT *a, X509_OBJECT *b)
177         {
178         int ret;
179
180         ret=(a->type - b->type);
181         if (ret) return(ret);
182         switch (a->type)
183                 {
184         case X509_LU_X509:
185                 ret=X509_subject_name_cmp(a->data.x509,b->data.x509);
186                 break;
187         case X509_LU_CRL:
188                 ret=X509_CRL_cmp(a->data.crl,b->data.crl);
189                 break;
190         default:
191                 abort();
192                 }
193         return(ret);
194         }
195
196 X509_STORE *X509_STORE_new(void)
197         {
198         X509_STORE *ret;
199
200         if ((ret=(X509_STORE *)Malloc(sizeof(X509_STORE))) == NULL)
201                 return(NULL);
202         ret->certs=lh_new(x509_object_hash,x509_object_cmp);
203         ret->cache=1;
204         ret->get_cert_methods=sk_X509_LOOKUP_new_null();
205         ret->verify=NULL;
206         ret->verify_cb=NULL;
207         memset(&ret->ex_data,0,sizeof(CRYPTO_EX_DATA));
208         ret->references=1;
209         ret->depth=0;
210         return(ret);
211         }
212
213 static void cleanup(X509_OBJECT *a)
214         {
215         if (a->type == X509_LU_X509)
216                 {
217                 X509_free(a->data.x509);
218                 }
219         else if (a->type == X509_LU_CRL)
220                 {
221                 X509_CRL_free(a->data.crl);
222                 }
223         else
224                 abort();
225
226         Free(a);
227         }
228
229 void X509_STORE_free(X509_STORE *vfy)
230         {
231         int i;
232         STACK_OF(X509_LOOKUP) *sk;
233         X509_LOOKUP *lu;
234
235         if(vfy == NULL)
236             return;
237
238         sk=vfy->get_cert_methods;
239         for (i=0; i<sk_X509_LOOKUP_num(sk); i++)
240                 {
241                 lu=sk_X509_LOOKUP_value(sk,i);
242                 X509_LOOKUP_shutdown(lu);
243                 X509_LOOKUP_free(lu);
244                 }
245         sk_X509_LOOKUP_free(sk);
246
247         CRYPTO_free_ex_data(x509_store_meth,vfy,&vfy->ex_data);
248         lh_doall(vfy->certs,cleanup);
249         lh_free(vfy->certs);
250         Free(vfy);
251         }
252
253 X509_LOOKUP *X509_STORE_add_lookup(X509_STORE *v, X509_LOOKUP_METHOD *m)
254         {
255         int i;
256         STACK_OF(X509_LOOKUP) *sk;
257         X509_LOOKUP *lu;
258
259         sk=v->get_cert_methods;
260         for (i=0; i<sk_X509_LOOKUP_num(sk); i++)
261                 {
262                 lu=sk_X509_LOOKUP_value(sk,i);
263                 if (m == lu->method)
264                         {
265                         return(lu);
266                         }
267                 }
268         /* a new one */
269         lu=X509_LOOKUP_new(m);
270         if (lu == NULL)
271                 return(NULL);
272         else
273                 {
274                 lu->store_ctx=v;
275                 if (sk_X509_LOOKUP_push(v->get_cert_methods,lu))
276                         return(lu);
277                 else
278                         {
279                         X509_LOOKUP_free(lu);
280                         return(NULL);
281                         }
282                 }
283         }
284
285 int X509_STORE_get_by_subject(X509_STORE_CTX *vs, int type, X509_NAME *name,
286              X509_OBJECT *ret)
287         {
288         X509_STORE *ctx=vs->ctx;
289         X509_LOOKUP *lu;
290         X509_OBJECT stmp,*tmp;
291         int i,j;
292
293         tmp=X509_OBJECT_retrieve_by_subject(ctx->certs,type,name);
294
295         if (tmp == NULL)
296                 {
297                 for (i=vs->current_method; i<sk_X509_LOOKUP_num(ctx->get_cert_methods); i++)
298                         {
299                         lu=sk_X509_LOOKUP_value(ctx->get_cert_methods,i);
300                         j=X509_LOOKUP_by_subject(lu,type,name,&stmp);
301                         if (j < 0)
302                                 {
303                                 vs->current_method=j;
304                                 return(j);
305                                 }
306                         else if (j)
307                                 {
308                                 tmp= &stmp;
309                                 break;
310                                 }
311                         }
312                 vs->current_method=0;
313                 if (tmp == NULL)
314                         return(0);
315                 }
316
317 /*      if (ret->data.ptr != NULL)
318                 X509_OBJECT_free_contents(ret); */
319
320         ret->type=tmp->type;
321         ret->data.ptr=tmp->data.ptr;
322
323         X509_OBJECT_up_ref_count(ret);
324
325         return(1);
326         }
327
328 void X509_OBJECT_up_ref_count(X509_OBJECT *a)
329         {
330         switch (a->type)
331                 {
332         case X509_LU_X509:
333                 CRYPTO_add(&a->data.x509->references,1,CRYPTO_LOCK_X509);
334                 break;
335         case X509_LU_CRL:
336                 CRYPTO_add(&a->data.crl->references,1,CRYPTO_LOCK_X509_CRL);
337                 break;
338                 }
339         }
340
341 void X509_OBJECT_free_contents(X509_OBJECT *a)
342         {
343         switch (a->type)
344                 {
345         case X509_LU_X509:
346                 X509_free(a->data.x509);
347                 break;
348         case X509_LU_CRL:
349                 X509_CRL_free(a->data.crl);
350                 break;
351                 }
352         }
353
354 X509_OBJECT *X509_OBJECT_retrieve_by_subject(LHASH *h, int type,
355              X509_NAME *name)
356         {
357         X509_OBJECT stmp,*tmp;
358         X509 x509_s;
359         X509_CINF cinf_s;
360         X509_CRL crl_s;
361         X509_CRL_INFO crl_info_s;
362
363         stmp.type=type;
364         switch (type)
365                 {
366         case X509_LU_X509:
367                 stmp.data.x509= &x509_s;
368                 x509_s.cert_info= &cinf_s;
369                 cinf_s.subject=name;
370                 break;
371         case X509_LU_CRL:
372                 stmp.data.crl= &crl_s;
373                 crl_s.crl= &crl_info_s;
374                 crl_info_s.issuer=name;
375                 break;
376         default:
377                 abort();
378                 }
379
380         tmp=(X509_OBJECT *)lh_retrieve(h,&stmp);
381         return(tmp);
382         }
383
384 X509_STORE_CTX *X509_STORE_CTX_new(void)
385 {
386         X509_STORE_CTX *ctx;
387         ctx = (X509_STORE_CTX *)Malloc(sizeof(X509_STORE_CTX));
388         if(ctx) memset(ctx, 0, sizeof(X509_STORE_CTX));
389         return ctx;
390 }
391
392 void X509_STORE_CTX_free(X509_STORE_CTX *ctx)
393 {
394         X509_STORE_CTX_cleanup(ctx);
395         Free(ctx);
396 }
397
398 void X509_STORE_CTX_init(X509_STORE_CTX *ctx, X509_STORE *store, X509 *x509,
399              STACK_OF(X509) *chain)
400         {
401         ctx->ctx=store;
402         ctx->current_method=0;
403         ctx->cert=x509;
404         ctx->untrusted=chain;
405         ctx->last_untrusted=0;
406         ctx->purpose=0;
407         ctx->trust=0;
408         ctx->valid=0;
409         ctx->chain=NULL;
410         ctx->depth=9;
411         ctx->error=0;
412         ctx->current_cert=NULL;
413         memset(&(ctx->ex_data),0,sizeof(CRYPTO_EX_DATA));
414         }
415
416 void X509_STORE_CTX_cleanup(X509_STORE_CTX *ctx)
417         {
418         if (ctx->chain != NULL)
419                 {
420                 sk_X509_pop_free(ctx->chain,X509_free);
421                 ctx->chain=NULL;
422                 }
423         CRYPTO_free_ex_data(x509_store_ctx_meth,ctx,&(ctx->ex_data));
424         memset(&ctx->ex_data,0,sizeof(CRYPTO_EX_DATA));
425         }
426
427 IMPLEMENT_STACK_OF(X509_LOOKUP)