Add and use OPENSSL_zalloc
[openssl.git] / crypto / asn1 / tasn_new.c
1 /* tasn_new.c */
2 /*
3  * Written by Dr Stephen N Henson (steve@openssl.org) for the OpenSSL project
4  * 2000.
5  */
6 /* ====================================================================
7  * Copyright (c) 2000-2004 The OpenSSL Project.  All rights reserved.
8  *
9  * Redistribution and use in source and binary forms, with or without
10  * modification, are permitted provided that the following conditions
11  * are met:
12  *
13  * 1. Redistributions of source code must retain the above copyright
14  *    notice, this list of conditions and the following disclaimer.
15  *
16  * 2. Redistributions in binary form must reproduce the above copyright
17  *    notice, this list of conditions and the following disclaimer in
18  *    the documentation and/or other materials provided with the
19  *    distribution.
20  *
21  * 3. All advertising materials mentioning features or use of this
22  *    software must display the following acknowledgment:
23  *    "This product includes software developed by the OpenSSL Project
24  *    for use in the OpenSSL Toolkit. (http://www.OpenSSL.org/)"
25  *
26  * 4. The names "OpenSSL Toolkit" and "OpenSSL Project" must not be used to
27  *    endorse or promote products derived from this software without
28  *    prior written permission. For written permission, please contact
29  *    licensing@OpenSSL.org.
30  *
31  * 5. Products derived from this software may not be called "OpenSSL"
32  *    nor may "OpenSSL" appear in their names without prior written
33  *    permission of the OpenSSL Project.
34  *
35  * 6. Redistributions of any form whatsoever must retain the following
36  *    acknowledgment:
37  *    "This product includes software developed by the OpenSSL Project
38  *    for use in the OpenSSL Toolkit (http://www.OpenSSL.org/)"
39  *
40  * THIS SOFTWARE IS PROVIDED BY THE OpenSSL PROJECT ``AS IS'' AND ANY
41  * EXPRESSED OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
42  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
43  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE OpenSSL PROJECT OR
44  * ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
45  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
46  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
47  * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
48  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
49  * STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
50  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
51  * OF THE POSSIBILITY OF SUCH DAMAGE.
52  * ====================================================================
53  *
54  * This product includes cryptographic software written by Eric Young
55  * (eay@cryptsoft.com).  This product includes software written by Tim
56  * Hudson (tjh@cryptsoft.com).
57  *
58  */
59
60 #include <stddef.h>
61 #include <openssl/asn1.h>
62 #include <openssl/objects.h>
63 #include <openssl/err.h>
64 #include <openssl/asn1t.h>
65 #include <string.h>
66 #include "asn1_locl.h"
67
68 static int asn1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it);
69 static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
70 static int asn1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
71 static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt);
72 static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it);
73
74 ASN1_VALUE *ASN1_item_new(const ASN1_ITEM *it)
75 {
76     ASN1_VALUE *ret = NULL;
77     if (ASN1_item_ex_new(&ret, it) > 0)
78         return ret;
79     return NULL;
80 }
81
82 /* Allocate an ASN1 structure */
83
84 int ASN1_item_ex_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
85 {
86     const ASN1_TEMPLATE *tt = NULL;
87     const ASN1_EXTERN_FUNCS *ef;
88     const ASN1_AUX *aux = it->funcs;
89     ASN1_aux_cb *asn1_cb;
90     ASN1_VALUE **pseqval;
91     int i;
92     if (aux && aux->asn1_cb)
93         asn1_cb = aux->asn1_cb;
94     else
95         asn1_cb = 0;
96
97 #ifdef CRYPTO_MDEBUG
98     if (it->sname)
99         CRYPTO_push_info(it->sname);
100 #endif
101
102     switch (it->itype) {
103
104     case ASN1_ITYPE_EXTERN:
105         ef = it->funcs;
106         if (ef && ef->asn1_ex_new) {
107             if (!ef->asn1_ex_new(pval, it))
108                 goto memerr;
109         }
110         break;
111
112     case ASN1_ITYPE_PRIMITIVE:
113         if (it->templates) {
114             if (!asn1_template_new(pval, it->templates))
115                 goto memerr;
116         } else if (!asn1_primitive_new(pval, it))
117             goto memerr;
118         break;
119
120     case ASN1_ITYPE_MSTRING:
121         if (!asn1_primitive_new(pval, it))
122             goto memerr;
123         break;
124
125     case ASN1_ITYPE_CHOICE:
126         if (asn1_cb) {
127             i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
128             if (!i)
129                 goto auxerr;
130             if (i == 2) {
131 #ifdef CRYPTO_MDEBUG
132                 if (it->sname)
133                     CRYPTO_pop_info();
134 #endif
135                 return 1;
136             }
137         }
138         *pval = OPENSSL_zalloc(it->size);
139         if (!*pval)
140             goto memerr;
141         asn1_set_choice_selector(pval, -1, it);
142         if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
143             goto auxerr;
144         break;
145
146     case ASN1_ITYPE_NDEF_SEQUENCE:
147     case ASN1_ITYPE_SEQUENCE:
148         if (asn1_cb) {
149             i = asn1_cb(ASN1_OP_NEW_PRE, pval, it, NULL);
150             if (!i)
151                 goto auxerr;
152             if (i == 2) {
153 #ifdef CRYPTO_MDEBUG
154                 if (it->sname)
155                     CRYPTO_pop_info();
156 #endif
157                 return 1;
158             }
159         }
160         *pval = OPENSSL_zalloc(it->size);
161         if (!*pval)
162             goto memerr;
163         asn1_do_lock(pval, 0, it);
164         asn1_enc_init(pval, it);
165         for (i = 0, tt = it->templates; i < it->tcount; tt++, i++) {
166             pseqval = asn1_get_field_ptr(pval, tt);
167             if (!asn1_template_new(pseqval, tt))
168                 goto memerr;
169         }
170         if (asn1_cb && !asn1_cb(ASN1_OP_NEW_POST, pval, it, NULL))
171             goto auxerr;
172         break;
173     }
174 #ifdef CRYPTO_MDEBUG
175     if (it->sname)
176         CRYPTO_pop_info();
177 #endif
178     return 1;
179
180  memerr:
181     ASN1err(ASN1_F_ASN1_ITEM_EX_NEW, ERR_R_MALLOC_FAILURE);
182 #ifdef CRYPTO_MDEBUG
183     if (it->sname)
184         CRYPTO_pop_info();
185 #endif
186     return 0;
187
188  auxerr:
189     ASN1err(ASN1_F_ASN1_ITEM_EX_NEW, ASN1_R_AUX_ERROR);
190     ASN1_item_ex_free(pval, it);
191 #ifdef CRYPTO_MDEBUG
192     if (it->sname)
193         CRYPTO_pop_info();
194 #endif
195     return 0;
196
197 }
198
199 static void asn1_item_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
200 {
201     const ASN1_EXTERN_FUNCS *ef;
202
203     switch (it->itype) {
204
205     case ASN1_ITYPE_EXTERN:
206         ef = it->funcs;
207         if (ef && ef->asn1_ex_clear)
208             ef->asn1_ex_clear(pval, it);
209         else
210             *pval = NULL;
211         break;
212
213     case ASN1_ITYPE_PRIMITIVE:
214         if (it->templates)
215             asn1_template_clear(pval, it->templates);
216         else
217             asn1_primitive_clear(pval, it);
218         break;
219
220     case ASN1_ITYPE_MSTRING:
221         asn1_primitive_clear(pval, it);
222         break;
223
224     case ASN1_ITYPE_CHOICE:
225     case ASN1_ITYPE_SEQUENCE:
226     case ASN1_ITYPE_NDEF_SEQUENCE:
227         *pval = NULL;
228         break;
229     }
230 }
231
232 static int asn1_template_new(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
233 {
234     const ASN1_ITEM *it = ASN1_ITEM_ptr(tt->item);
235     int ret;
236     if (tt->flags & ASN1_TFLG_OPTIONAL) {
237         asn1_template_clear(pval, tt);
238         return 1;
239     }
240     /* If ANY DEFINED BY nothing to do */
241
242     if (tt->flags & ASN1_TFLG_ADB_MASK) {
243         *pval = NULL;
244         return 1;
245     }
246 #ifdef CRYPTO_MDEBUG
247     if (tt->field_name)
248         CRYPTO_push_info(tt->field_name);
249 #endif
250     /* If SET OF or SEQUENCE OF, its a STACK */
251     if (tt->flags & ASN1_TFLG_SK_MASK) {
252         STACK_OF(ASN1_VALUE) *skval;
253         skval = sk_ASN1_VALUE_new_null();
254         if (!skval) {
255             ASN1err(ASN1_F_ASN1_TEMPLATE_NEW, ERR_R_MALLOC_FAILURE);
256             ret = 0;
257             goto done;
258         }
259         *pval = (ASN1_VALUE *)skval;
260         ret = 1;
261         goto done;
262     }
263     /* Otherwise pass it back to the item routine */
264     ret = ASN1_item_ex_new(pval, it);
265  done:
266 #ifdef CRYPTO_MDEBUG
267     if (it->sname)
268         CRYPTO_pop_info();
269 #endif
270     return ret;
271 }
272
273 static void asn1_template_clear(ASN1_VALUE **pval, const ASN1_TEMPLATE *tt)
274 {
275     /* If ADB or STACK just NULL the field */
276     if (tt->flags & (ASN1_TFLG_ADB_MASK | ASN1_TFLG_SK_MASK))
277         *pval = NULL;
278     else
279         asn1_item_clear(pval, ASN1_ITEM_ptr(tt->item));
280 }
281
282 /*
283  * NB: could probably combine most of the real XXX_new() behaviour and junk
284  * all the old functions.
285  */
286
287 static int asn1_primitive_new(ASN1_VALUE **pval, const ASN1_ITEM *it)
288 {
289     ASN1_TYPE *typ;
290     ASN1_STRING *str;
291     int utype;
292
293     if (!it)
294         return 0;
295
296     if (it->funcs) {
297         const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;
298         if (pf->prim_new)
299             return pf->prim_new(pval, it);
300     }
301
302     if (it->itype == ASN1_ITYPE_MSTRING)
303         utype = -1;
304     else
305         utype = it->utype;
306     switch (utype) {
307     case V_ASN1_OBJECT:
308         *pval = (ASN1_VALUE *)OBJ_nid2obj(NID_undef);
309         return 1;
310
311     case V_ASN1_BOOLEAN:
312         *(ASN1_BOOLEAN *)pval = it->size;
313         return 1;
314
315     case V_ASN1_NULL:
316         *pval = (ASN1_VALUE *)1;
317         return 1;
318
319     case V_ASN1_ANY:
320         typ = OPENSSL_malloc(sizeof(*typ));
321         if (!typ)
322             return 0;
323         typ->value.ptr = NULL;
324         typ->type = -1;
325         *pval = (ASN1_VALUE *)typ;
326         break;
327
328     default:
329         str = ASN1_STRING_type_new(utype);
330         if (it->itype == ASN1_ITYPE_MSTRING && str)
331             str->flags |= ASN1_STRING_FLAG_MSTRING;
332         *pval = (ASN1_VALUE *)str;
333         break;
334     }
335     if (*pval)
336         return 1;
337     return 0;
338 }
339
340 static void asn1_primitive_clear(ASN1_VALUE **pval, const ASN1_ITEM *it)
341 {
342     int utype;
343     if (it && it->funcs) {
344         const ASN1_PRIMITIVE_FUNCS *pf = it->funcs;
345         if (pf->prim_clear)
346             pf->prim_clear(pval, it);
347         else
348             *pval = NULL;
349         return;
350     }
351     if (!it || (it->itype == ASN1_ITYPE_MSTRING))
352         utype = -1;
353     else
354         utype = it->utype;
355     if (utype == V_ASN1_BOOLEAN)
356         *(ASN1_BOOLEAN *)pval = it->size;
357     else
358         *pval = NULL;
359 }