free NULL cleanup
[openssl.git] / crypto / x509 / x509_att.c
1 /* crypto/x509/x509_att.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 <openssl/stack.h>
61 #include "cryptlib.h"
62 #include <openssl/asn1.h>
63 #include <openssl/objects.h>
64 #include <openssl/evp.h>
65 #include <openssl/x509.h>
66 #include <openssl/x509v3.h>
67 #include "x509_lcl.h"
68
69 int X509at_get_attr_count(const STACK_OF(X509_ATTRIBUTE) *x)
70 {
71     return sk_X509_ATTRIBUTE_num(x);
72 }
73
74 int X509at_get_attr_by_NID(const STACK_OF(X509_ATTRIBUTE) *x, int nid,
75                            int lastpos)
76 {
77     ASN1_OBJECT *obj;
78
79     obj = OBJ_nid2obj(nid);
80     if (obj == NULL)
81         return (-2);
82     return (X509at_get_attr_by_OBJ(x, obj, lastpos));
83 }
84
85 int X509at_get_attr_by_OBJ(const STACK_OF(X509_ATTRIBUTE) *sk,
86                            ASN1_OBJECT *obj, int lastpos)
87 {
88     int n;
89     X509_ATTRIBUTE *ex;
90
91     if (sk == NULL)
92         return (-1);
93     lastpos++;
94     if (lastpos < 0)
95         lastpos = 0;
96     n = sk_X509_ATTRIBUTE_num(sk);
97     for (; lastpos < n; lastpos++) {
98         ex = sk_X509_ATTRIBUTE_value(sk, lastpos);
99         if (OBJ_cmp(ex->object, obj) == 0)
100             return (lastpos);
101     }
102     return (-1);
103 }
104
105 X509_ATTRIBUTE *X509at_get_attr(const STACK_OF(X509_ATTRIBUTE) *x, int loc)
106 {
107     if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
108         return NULL;
109     else
110         return sk_X509_ATTRIBUTE_value(x, loc);
111 }
112
113 X509_ATTRIBUTE *X509at_delete_attr(STACK_OF(X509_ATTRIBUTE) *x, int loc)
114 {
115     X509_ATTRIBUTE *ret;
116
117     if (x == NULL || sk_X509_ATTRIBUTE_num(x) <= loc || loc < 0)
118         return (NULL);
119     ret = sk_X509_ATTRIBUTE_delete(x, loc);
120     return (ret);
121 }
122
123 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr(STACK_OF(X509_ATTRIBUTE) **x,
124                                            X509_ATTRIBUTE *attr)
125 {
126     X509_ATTRIBUTE *new_attr = NULL;
127     STACK_OF(X509_ATTRIBUTE) *sk = NULL;
128
129     if (x == NULL) {
130         X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_PASSED_NULL_PARAMETER);
131         goto err2;
132     }
133
134     if (*x == NULL) {
135         if ((sk = sk_X509_ATTRIBUTE_new_null()) == NULL)
136             goto err;
137     } else
138         sk = *x;
139
140     if ((new_attr = X509_ATTRIBUTE_dup(attr)) == NULL)
141         goto err2;
142     if (!sk_X509_ATTRIBUTE_push(sk, new_attr))
143         goto err;
144     if (*x == NULL)
145         *x = sk;
146     return (sk);
147  err:
148     X509err(X509_F_X509AT_ADD1_ATTR, ERR_R_MALLOC_FAILURE);
149  err2:
150     if (new_attr != NULL)
151         X509_ATTRIBUTE_free(new_attr);
152     if (sk != NULL)
153         sk_X509_ATTRIBUTE_free(sk);
154     return (NULL);
155 }
156
157 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_OBJ(STACK_OF(X509_ATTRIBUTE)
158                                                   **x, const ASN1_OBJECT *obj,
159                                                   int type,
160                                                   const unsigned char *bytes,
161                                                   int len)
162 {
163     X509_ATTRIBUTE *attr;
164     STACK_OF(X509_ATTRIBUTE) *ret;
165     attr = X509_ATTRIBUTE_create_by_OBJ(NULL, obj, type, bytes, len);
166     if (!attr)
167         return 0;
168     ret = X509at_add1_attr(x, attr);
169     X509_ATTRIBUTE_free(attr);
170     return ret;
171 }
172
173 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_NID(STACK_OF(X509_ATTRIBUTE)
174                                                   **x, int nid, int type,
175                                                   const unsigned char *bytes,
176                                                   int len)
177 {
178     X509_ATTRIBUTE *attr;
179     STACK_OF(X509_ATTRIBUTE) *ret;
180     attr = X509_ATTRIBUTE_create_by_NID(NULL, nid, type, bytes, len);
181     if (!attr)
182         return 0;
183     ret = X509at_add1_attr(x, attr);
184     X509_ATTRIBUTE_free(attr);
185     return ret;
186 }
187
188 STACK_OF(X509_ATTRIBUTE) *X509at_add1_attr_by_txt(STACK_OF(X509_ATTRIBUTE)
189                                                   **x, const char *attrname,
190                                                   int type,
191                                                   const unsigned char *bytes,
192                                                   int len)
193 {
194     X509_ATTRIBUTE *attr;
195     STACK_OF(X509_ATTRIBUTE) *ret;
196     attr = X509_ATTRIBUTE_create_by_txt(NULL, attrname, type, bytes, len);
197     if (!attr)
198         return 0;
199     ret = X509at_add1_attr(x, attr);
200     X509_ATTRIBUTE_free(attr);
201     return ret;
202 }
203
204 void *X509at_get0_data_by_OBJ(STACK_OF(X509_ATTRIBUTE) *x,
205                               ASN1_OBJECT *obj, int lastpos, int type)
206 {
207     int i;
208     X509_ATTRIBUTE *at;
209     i = X509at_get_attr_by_OBJ(x, obj, lastpos);
210     if (i == -1)
211         return NULL;
212     if ((lastpos <= -2) && (X509at_get_attr_by_OBJ(x, obj, i) != -1))
213         return NULL;
214     at = X509at_get_attr(x, i);
215     if (lastpos <= -3 && (X509_ATTRIBUTE_count(at) != 1))
216         return NULL;
217     return X509_ATTRIBUTE_get0_data(at, 0, type, NULL);
218 }
219
220 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_NID(X509_ATTRIBUTE **attr, int nid,
221                                              int atrtype, const void *data,
222                                              int len)
223 {
224     ASN1_OBJECT *obj;
225     X509_ATTRIBUTE *ret;
226
227     obj = OBJ_nid2obj(nid);
228     if (obj == NULL) {
229         X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_NID, X509_R_UNKNOWN_NID);
230         return (NULL);
231     }
232     ret = X509_ATTRIBUTE_create_by_OBJ(attr, obj, atrtype, data, len);
233     if (ret == NULL)
234         ASN1_OBJECT_free(obj);
235     return (ret);
236 }
237
238 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_OBJ(X509_ATTRIBUTE **attr,
239                                              const ASN1_OBJECT *obj,
240                                              int atrtype, const void *data,
241                                              int len)
242 {
243     X509_ATTRIBUTE *ret;
244
245     if ((attr == NULL) || (*attr == NULL)) {
246         if ((ret = X509_ATTRIBUTE_new()) == NULL) {
247             X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_OBJ,
248                     ERR_R_MALLOC_FAILURE);
249             return (NULL);
250         }
251     } else
252         ret = *attr;
253
254     if (!X509_ATTRIBUTE_set1_object(ret, obj))
255         goto err;
256     if (!X509_ATTRIBUTE_set1_data(ret, atrtype, data, len))
257         goto err;
258
259     if ((attr != NULL) && (*attr == NULL))
260         *attr = ret;
261     return (ret);
262  err:
263     if ((attr == NULL) || (ret != *attr))
264         X509_ATTRIBUTE_free(ret);
265     return (NULL);
266 }
267
268 X509_ATTRIBUTE *X509_ATTRIBUTE_create_by_txt(X509_ATTRIBUTE **attr,
269                                              const char *atrname, int type,
270                                              const unsigned char *bytes,
271                                              int len)
272 {
273     ASN1_OBJECT *obj;
274     X509_ATTRIBUTE *nattr;
275
276     obj = OBJ_txt2obj(atrname, 0);
277     if (obj == NULL) {
278         X509err(X509_F_X509_ATTRIBUTE_CREATE_BY_TXT,
279                 X509_R_INVALID_FIELD_NAME);
280         ERR_add_error_data(2, "name=", atrname);
281         return (NULL);
282     }
283     nattr = X509_ATTRIBUTE_create_by_OBJ(attr, obj, type, bytes, len);
284     ASN1_OBJECT_free(obj);
285     return nattr;
286 }
287
288 int X509_ATTRIBUTE_set1_object(X509_ATTRIBUTE *attr, const ASN1_OBJECT *obj)
289 {
290     if ((attr == NULL) || (obj == NULL))
291         return (0);
292     ASN1_OBJECT_free(attr->object);
293     attr->object = OBJ_dup(obj);
294     return (1);
295 }
296
297 int X509_ATTRIBUTE_set1_data(X509_ATTRIBUTE *attr, int attrtype,
298                              const void *data, int len)
299 {
300     ASN1_TYPE *ttmp;
301     ASN1_STRING *stmp = NULL;
302     int atype = 0;
303     if (!attr)
304         return 0;
305     if (attrtype & MBSTRING_FLAG) {
306         stmp = ASN1_STRING_set_by_NID(NULL, data, len, attrtype,
307                                       OBJ_obj2nid(attr->object));
308         if (!stmp) {
309             X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_ASN1_LIB);
310             return 0;
311         }
312         atype = stmp->type;
313     } else if (len != -1) {
314         if (!(stmp = ASN1_STRING_type_new(attrtype)))
315             goto err;
316         if (!ASN1_STRING_set(stmp, data, len))
317             goto err;
318         atype = attrtype;
319     }
320     if (!(attr->value.set = sk_ASN1_TYPE_new_null()))
321         goto err;
322     attr->single = 0;
323     /*
324      * This is a bit naughty because the attribute should really have at
325      * least one value but some types use and zero length SET and require
326      * this.
327      */
328     if (attrtype == 0)
329         return 1;
330     if (!(ttmp = ASN1_TYPE_new()))
331         goto err;
332     if ((len == -1) && !(attrtype & MBSTRING_FLAG)) {
333         if (!ASN1_TYPE_set1(ttmp, attrtype, data))
334             goto err;
335     } else
336         ASN1_TYPE_set(ttmp, atype, stmp);
337     if (!sk_ASN1_TYPE_push(attr->value.set, ttmp))
338         goto err;
339     return 1;
340  err:
341     X509err(X509_F_X509_ATTRIBUTE_SET1_DATA, ERR_R_MALLOC_FAILURE);
342     return 0;
343 }
344
345 int X509_ATTRIBUTE_count(X509_ATTRIBUTE *attr)
346 {
347     if (!attr->single)
348         return sk_ASN1_TYPE_num(attr->value.set);
349     if (attr->value.single)
350         return 1;
351     return 0;
352 }
353
354 ASN1_OBJECT *X509_ATTRIBUTE_get0_object(X509_ATTRIBUTE *attr)
355 {
356     if (attr == NULL)
357         return (NULL);
358     return (attr->object);
359 }
360
361 void *X509_ATTRIBUTE_get0_data(X509_ATTRIBUTE *attr, int idx,
362                                int atrtype, void *data)
363 {
364     ASN1_TYPE *ttmp;
365     ttmp = X509_ATTRIBUTE_get0_type(attr, idx);
366     if (!ttmp)
367         return NULL;
368     if (atrtype != ASN1_TYPE_get(ttmp)) {
369         X509err(X509_F_X509_ATTRIBUTE_GET0_DATA, X509_R_WRONG_TYPE);
370         return NULL;
371     }
372     return ttmp->value.ptr;
373 }
374
375 ASN1_TYPE *X509_ATTRIBUTE_get0_type(X509_ATTRIBUTE *attr, int idx)
376 {
377     if (attr == NULL)
378         return (NULL);
379     if (idx >= X509_ATTRIBUTE_count(attr))
380         return NULL;
381     if (!attr->single)
382         return sk_ASN1_TYPE_value(attr->value.set, idx);
383     else
384         return attr->value.single;
385 }