make X509_NAME opaque
[openssl.git] / crypto / x509 / x509name.c
1 /* crypto/x509/x509name.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 "internal/x509_int.h"
67
68 int X509_NAME_get_text_by_NID(X509_NAME *name, int nid, char *buf, int len)
69 {
70     ASN1_OBJECT *obj;
71
72     obj = OBJ_nid2obj(nid);
73     if (obj == NULL)
74         return (-1);
75     return (X509_NAME_get_text_by_OBJ(name, obj, buf, len));
76 }
77
78 int X509_NAME_get_text_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, char *buf,
79                               int len)
80 {
81     int i;
82     ASN1_STRING *data;
83
84     i = X509_NAME_get_index_by_OBJ(name, obj, -1);
85     if (i < 0)
86         return (-1);
87     data = X509_NAME_ENTRY_get_data(X509_NAME_get_entry(name, i));
88     i = (data->length > (len - 1)) ? (len - 1) : data->length;
89     if (buf == NULL)
90         return (data->length);
91     memcpy(buf, data->data, i);
92     buf[i] = '\0';
93     return (i);
94 }
95
96 int X509_NAME_entry_count(X509_NAME *name)
97 {
98     if (name == NULL)
99         return (0);
100     return (sk_X509_NAME_ENTRY_num(name->entries));
101 }
102
103 int X509_NAME_get_index_by_NID(X509_NAME *name, int nid, int lastpos)
104 {
105     ASN1_OBJECT *obj;
106
107     obj = OBJ_nid2obj(nid);
108     if (obj == NULL)
109         return (-2);
110     return (X509_NAME_get_index_by_OBJ(name, obj, lastpos));
111 }
112
113 /* NOTE: you should be passsing -1, not 0 as lastpos */
114 int X509_NAME_get_index_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, int lastpos)
115 {
116     int n;
117     X509_NAME_ENTRY *ne;
118     STACK_OF(X509_NAME_ENTRY) *sk;
119
120     if (name == NULL)
121         return (-1);
122     if (lastpos < 0)
123         lastpos = -1;
124     sk = name->entries;
125     n = sk_X509_NAME_ENTRY_num(sk);
126     for (lastpos++; lastpos < n; lastpos++) {
127         ne = sk_X509_NAME_ENTRY_value(sk, lastpos);
128         if (OBJ_cmp(ne->object, obj) == 0)
129             return (lastpos);
130     }
131     return (-1);
132 }
133
134 X509_NAME_ENTRY *X509_NAME_get_entry(X509_NAME *name, int loc)
135 {
136     if (name == NULL || sk_X509_NAME_ENTRY_num(name->entries) <= loc
137         || loc < 0)
138         return (NULL);
139     else
140         return (sk_X509_NAME_ENTRY_value(name->entries, loc));
141 }
142
143 X509_NAME_ENTRY *X509_NAME_delete_entry(X509_NAME *name, int loc)
144 {
145     X509_NAME_ENTRY *ret;
146     int i, n, set_prev, set_next;
147     STACK_OF(X509_NAME_ENTRY) *sk;
148
149     if (name == NULL || sk_X509_NAME_ENTRY_num(name->entries) <= loc
150         || loc < 0)
151         return (NULL);
152     sk = name->entries;
153     ret = sk_X509_NAME_ENTRY_delete(sk, loc);
154     n = sk_X509_NAME_ENTRY_num(sk);
155     name->modified = 1;
156     if (loc == n)
157         return (ret);
158
159     /* else we need to fixup the set field */
160     if (loc != 0)
161         set_prev = (sk_X509_NAME_ENTRY_value(sk, loc - 1))->set;
162     else
163         set_prev = ret->set - 1;
164     set_next = sk_X509_NAME_ENTRY_value(sk, loc)->set;
165
166     /*-
167      * set_prev is the previous set
168      * set is the current set
169      * set_next is the following
170      * prev  1 1    1 1     1 1     1 1
171      * set   1      1       2       2
172      * next  1 1    2 2     2 2     3 2
173      * so basically only if prev and next differ by 2, then
174      * re-number down by 1
175      */
176     if (set_prev + 1 < set_next)
177         for (i = loc; i < n; i++)
178             sk_X509_NAME_ENTRY_value(sk, i)->set--;
179     return (ret);
180 }
181
182 int X509_NAME_add_entry_by_OBJ(X509_NAME *name, ASN1_OBJECT *obj, int type,
183                                unsigned char *bytes, int len, int loc,
184                                int set)
185 {
186     X509_NAME_ENTRY *ne;
187     int ret;
188     ne = X509_NAME_ENTRY_create_by_OBJ(NULL, obj, type, bytes, len);
189     if (!ne)
190         return 0;
191     ret = X509_NAME_add_entry(name, ne, loc, set);
192     X509_NAME_ENTRY_free(ne);
193     return ret;
194 }
195
196 int X509_NAME_add_entry_by_NID(X509_NAME *name, int nid, int type,
197                                unsigned char *bytes, int len, int loc,
198                                int set)
199 {
200     X509_NAME_ENTRY *ne;
201     int ret;
202     ne = X509_NAME_ENTRY_create_by_NID(NULL, nid, type, bytes, len);
203     if (!ne)
204         return 0;
205     ret = X509_NAME_add_entry(name, ne, loc, set);
206     X509_NAME_ENTRY_free(ne);
207     return ret;
208 }
209
210 int X509_NAME_add_entry_by_txt(X509_NAME *name, const char *field, int type,
211                                const unsigned char *bytes, int len, int loc,
212                                int set)
213 {
214     X509_NAME_ENTRY *ne;
215     int ret;
216     ne = X509_NAME_ENTRY_create_by_txt(NULL, field, type, bytes, len);
217     if (!ne)
218         return 0;
219     ret = X509_NAME_add_entry(name, ne, loc, set);
220     X509_NAME_ENTRY_free(ne);
221     return ret;
222 }
223
224 /*
225  * if set is -1, append to previous set, 0 'a new one', and 1, prepend to the
226  * guy we are about to stomp on.
227  */
228 int X509_NAME_add_entry(X509_NAME *name, X509_NAME_ENTRY *ne, int loc,
229                         int set)
230 {
231     X509_NAME_ENTRY *new_name = NULL;
232     int n, i, inc;
233     STACK_OF(X509_NAME_ENTRY) *sk;
234
235     if (name == NULL)
236         return (0);
237     sk = name->entries;
238     n = sk_X509_NAME_ENTRY_num(sk);
239     if (loc > n)
240         loc = n;
241     else if (loc < 0)
242         loc = n;
243
244     name->modified = 1;
245
246     if (set == -1) {
247         if (loc == 0) {
248             set = 0;
249             inc = 1;
250         } else {
251             set = sk_X509_NAME_ENTRY_value(sk, loc - 1)->set;
252             inc = 0;
253         }
254     } else {                    /* if (set >= 0) */
255
256         if (loc >= n) {
257             if (loc != 0)
258                 set = sk_X509_NAME_ENTRY_value(sk, loc - 1)->set + 1;
259             else
260                 set = 0;
261         } else
262             set = sk_X509_NAME_ENTRY_value(sk, loc)->set;
263         inc = (set == 0) ? 1 : 0;
264     }
265
266     if ((new_name = X509_NAME_ENTRY_dup(ne)) == NULL)
267         goto err;
268     new_name->set = set;
269     if (!sk_X509_NAME_ENTRY_insert(sk, new_name, loc)) {
270         X509err(X509_F_X509_NAME_ADD_ENTRY, ERR_R_MALLOC_FAILURE);
271         goto err;
272     }
273     if (inc) {
274         n = sk_X509_NAME_ENTRY_num(sk);
275         for (i = loc + 1; i < n; i++)
276             sk_X509_NAME_ENTRY_value(sk, i - 1)->set += 1;
277     }
278     return (1);
279  err:
280     if (new_name != NULL)
281         X509_NAME_ENTRY_free(new_name);
282     return (0);
283 }
284
285 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_txt(X509_NAME_ENTRY **ne,
286                                                const char *field, int type,
287                                                const unsigned char *bytes,
288                                                int len)
289 {
290     ASN1_OBJECT *obj;
291     X509_NAME_ENTRY *nentry;
292
293     obj = OBJ_txt2obj(field, 0);
294     if (obj == NULL) {
295         X509err(X509_F_X509_NAME_ENTRY_CREATE_BY_TXT,
296                 X509_R_INVALID_FIELD_NAME);
297         ERR_add_error_data(2, "name=", field);
298         return (NULL);
299     }
300     nentry = X509_NAME_ENTRY_create_by_OBJ(ne, obj, type, bytes, len);
301     ASN1_OBJECT_free(obj);
302     return nentry;
303 }
304
305 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_NID(X509_NAME_ENTRY **ne, int nid,
306                                                int type, unsigned char *bytes,
307                                                int len)
308 {
309     ASN1_OBJECT *obj;
310     X509_NAME_ENTRY *nentry;
311
312     obj = OBJ_nid2obj(nid);
313     if (obj == NULL) {
314         X509err(X509_F_X509_NAME_ENTRY_CREATE_BY_NID, X509_R_UNKNOWN_NID);
315         return (NULL);
316     }
317     nentry = X509_NAME_ENTRY_create_by_OBJ(ne, obj, type, bytes, len);
318     ASN1_OBJECT_free(obj);
319     return nentry;
320 }
321
322 X509_NAME_ENTRY *X509_NAME_ENTRY_create_by_OBJ(X509_NAME_ENTRY **ne,
323                                                ASN1_OBJECT *obj, int type,
324                                                const unsigned char *bytes,
325                                                int len)
326 {
327     X509_NAME_ENTRY *ret;
328
329     if ((ne == NULL) || (*ne == NULL)) {
330         if ((ret = X509_NAME_ENTRY_new()) == NULL)
331             return (NULL);
332     } else
333         ret = *ne;
334
335     if (!X509_NAME_ENTRY_set_object(ret, obj))
336         goto err;
337     if (!X509_NAME_ENTRY_set_data(ret, type, bytes, len))
338         goto err;
339
340     if ((ne != NULL) && (*ne == NULL))
341         *ne = ret;
342     return (ret);
343  err:
344     if ((ne == NULL) || (ret != *ne))
345         X509_NAME_ENTRY_free(ret);
346     return (NULL);
347 }
348
349 int X509_NAME_ENTRY_set_object(X509_NAME_ENTRY *ne, ASN1_OBJECT *obj)
350 {
351     if ((ne == NULL) || (obj == NULL)) {
352         X509err(X509_F_X509_NAME_ENTRY_SET_OBJECT,
353                 ERR_R_PASSED_NULL_PARAMETER);
354         return (0);
355     }
356     ASN1_OBJECT_free(ne->object);
357     ne->object = OBJ_dup(obj);
358     return ((ne->object == NULL) ? 0 : 1);
359 }
360
361 int X509_NAME_ENTRY_set_data(X509_NAME_ENTRY *ne, int type,
362                              const unsigned char *bytes, int len)
363 {
364     int i;
365
366     if ((ne == NULL) || ((bytes == NULL) && (len != 0)))
367         return (0);
368     if ((type > 0) && (type & MBSTRING_FLAG))
369         return ASN1_STRING_set_by_NID(&ne->value, bytes,
370                                       len, type,
371                                       OBJ_obj2nid(ne->object)) ? 1 : 0;
372     if (len < 0)
373         len = strlen((const char *)bytes);
374     i = ASN1_STRING_set(ne->value, bytes, len);
375     if (!i)
376         return (0);
377     if (type != V_ASN1_UNDEF) {
378         if (type == V_ASN1_APP_CHOOSE)
379             ne->value->type = ASN1_PRINTABLE_type(bytes, len);
380         else
381             ne->value->type = type;
382     }
383     return (1);
384 }
385
386 ASN1_OBJECT *X509_NAME_ENTRY_get_object(X509_NAME_ENTRY *ne)
387 {
388     if (ne == NULL)
389         return (NULL);
390     return (ne->object);
391 }
392
393 ASN1_STRING *X509_NAME_ENTRY_get_data(X509_NAME_ENTRY *ne)
394 {
395     if (ne == NULL)
396         return (NULL);
397     return (ne->value);
398 }
399
400 int X509_NAME_ENTRY_set(const X509_NAME_ENTRY *ne)
401 {
402     return ne->set;
403 }