98ff0bca948c3bada54d5b3e1aeb8b5b3a5deb92
[openssl.git] / crypto / x509 / v3_alt.c
1 /*
2  * Copyright 1999-2017 The OpenSSL Project Authors. All Rights Reserved.
3  *
4  * Licensed under the Apache License 2.0 (the "License").  You may not use
5  * this file except in compliance with the License.  You can obtain a copy
6  * in the file LICENSE in the source distribution or at
7  * https://www.openssl.org/source/license.html
8  */
9
10 #include <stdio.h>
11 #include "internal/cryptlib.h"
12 #include <openssl/conf.h>
13 #include <openssl/x509v3.h>
14 #include <openssl/bio.h>
15 #include "ext_dat.h"
16
17 DEFINE_STACK_OF(CONF_VALUE)
18 DEFINE_STACK_OF(GENERAL_NAME)
19
20 static GENERAL_NAMES *v2i_subject_alt(X509V3_EXT_METHOD *method,
21                                       X509V3_CTX *ctx,
22                                       STACK_OF(CONF_VALUE) *nval);
23 static GENERAL_NAMES *v2i_issuer_alt(X509V3_EXT_METHOD *method,
24                                      X509V3_CTX *ctx,
25                                      STACK_OF(CONF_VALUE) *nval);
26 static int copy_email(X509V3_CTX *ctx, GENERAL_NAMES *gens, int move_p);
27 static int copy_issuer(X509V3_CTX *ctx, GENERAL_NAMES *gens);
28 static int do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx);
29 static int do_dirname(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx);
30
31 const X509V3_EXT_METHOD v3_alt[3] = {
32     {NID_subject_alt_name, 0, ASN1_ITEM_ref(GENERAL_NAMES),
33      0, 0, 0, 0,
34      0, 0,
35      (X509V3_EXT_I2V) i2v_GENERAL_NAMES,
36      (X509V3_EXT_V2I)v2i_subject_alt,
37      NULL, NULL, NULL},
38
39     {NID_issuer_alt_name, 0, ASN1_ITEM_ref(GENERAL_NAMES),
40      0, 0, 0, 0,
41      0, 0,
42      (X509V3_EXT_I2V) i2v_GENERAL_NAMES,
43      (X509V3_EXT_V2I)v2i_issuer_alt,
44      NULL, NULL, NULL},
45
46     {NID_certificate_issuer, 0, ASN1_ITEM_ref(GENERAL_NAMES),
47      0, 0, 0, 0,
48      0, 0,
49      (X509V3_EXT_I2V) i2v_GENERAL_NAMES,
50      NULL, NULL, NULL, NULL},
51 };
52
53 STACK_OF(CONF_VALUE) *i2v_GENERAL_NAMES(X509V3_EXT_METHOD *method,
54                                         GENERAL_NAMES *gens,
55                                         STACK_OF(CONF_VALUE) *ret)
56 {
57     int i;
58     GENERAL_NAME *gen;
59     STACK_OF(CONF_VALUE) *tmpret = NULL, *origret = ret;
60
61     for (i = 0; i < sk_GENERAL_NAME_num(gens); i++) {
62         gen = sk_GENERAL_NAME_value(gens, i);
63         /*
64          * i2v_GENERAL_NAME allocates ret if it is NULL. If something goes
65          * wrong we need to free the stack - but only if it was empty when we
66          * originally entered this function.
67          */
68         tmpret = i2v_GENERAL_NAME(method, gen, ret);
69         if (tmpret == NULL) {
70             if (origret == NULL)
71                 sk_CONF_VALUE_pop_free(ret, X509V3_conf_free);
72             return NULL;
73         }
74         ret = tmpret;
75     }
76     if (ret == NULL)
77         return sk_CONF_VALUE_new_null();
78     return ret;
79 }
80
81 STACK_OF(CONF_VALUE) *i2v_GENERAL_NAME(X509V3_EXT_METHOD *method,
82                                        GENERAL_NAME *gen,
83                                        STACK_OF(CONF_VALUE) *ret)
84 {
85     unsigned char *p;
86     char othername[300];
87     char oline[256], htmp[5];
88     int i;
89
90     switch (gen->type) {
91     case GEN_OTHERNAME:
92         switch (OBJ_obj2nid(gen->d.otherName->type_id)) {
93         case NID_id_on_SmtpUTF8Mailbox:
94             if (gen->d.otherName->value->type != V_ASN1_UTF8STRING
95                     || !X509V3_add_value_uchar("othername: SmtpUTF8Mailbox:",
96                             gen->d.otherName->value->value.utf8string->data,
97                             &ret))
98                 return NULL;
99             break;
100         case NID_XmppAddr:
101             if (gen->d.otherName->value->type != V_ASN1_UTF8STRING
102                     || !X509V3_add_value_uchar("othername: XmppAddr:",
103                             gen->d.otherName->value->value.utf8string->data,
104                             &ret))
105                 return NULL;
106             break;
107         case NID_SRVName:
108             if (gen->d.otherName->value->type != V_ASN1_IA5STRING
109                     || !X509V3_add_value_uchar("othername: SRVName:",
110                             gen->d.otherName->value->value.ia5string->data,
111                             &ret))
112                 return NULL;
113             break;
114         case NID_ms_upn:
115             if (gen->d.otherName->value->type != V_ASN1_UTF8STRING
116                     || !X509V3_add_value_uchar("othername: UPN:",
117                             gen->d.otherName->value->value.utf8string->data,
118                             &ret))
119                 return NULL;
120             break;
121         case NID_NAIRealm:
122             if (gen->d.otherName->value->type != V_ASN1_UTF8STRING
123                     || !X509V3_add_value_uchar("othername: NAIRealm:",
124                             gen->d.otherName->value->value.utf8string->data,
125                             &ret))
126                 return NULL;
127             break;
128         default:
129             if (OBJ_obj2txt(oline, sizeof(oline), gen->d.otherName->type_id, 0) > 0) 
130                 BIO_snprintf(othername, sizeof(othername), "othername: %s:",
131                              oline);
132             else
133                 strncpy(othername, "othername:", sizeof(othername));
134
135             /* check if the value is something printable */
136             if (gen->d.otherName->value->type == V_ASN1_IA5STRING) {
137                 if (X509V3_add_value_uchar(othername,
138                              gen->d.otherName->value->value.ia5string->data,
139                              &ret)) 
140                     return ret;
141             }
142             if (gen->d.otherName->value->type == V_ASN1_UTF8STRING) {
143                 if (X509V3_add_value_uchar(othername,
144                              gen->d.otherName->value->value.utf8string->data,
145                              &ret)) 
146                     return ret;
147             }
148             if (!X509V3_add_value(othername, "<unsupported>", &ret))
149                 return NULL;
150             break;
151         }
152         break;
153
154     case GEN_X400:
155         if (!X509V3_add_value("X400Name", "<unsupported>", &ret))
156             return NULL;
157         break;
158
159     case GEN_EDIPARTY:
160         if (!X509V3_add_value("EdiPartyName", "<unsupported>", &ret))
161             return NULL;
162         break;
163
164     case GEN_EMAIL:
165         if (!X509V3_add_value_uchar("email", gen->d.ia5->data, &ret))
166             return NULL;
167         break;
168
169     case GEN_DNS:
170         if (!X509V3_add_value_uchar("DNS", gen->d.ia5->data, &ret))
171             return NULL;
172         break;
173
174     case GEN_URI:
175         if (!X509V3_add_value_uchar("URI", gen->d.ia5->data, &ret))
176             return NULL;
177         break;
178
179     case GEN_DIRNAME:
180         if (X509_NAME_oneline(gen->d.dirn, oline, sizeof(oline)) == NULL
181                 || !X509V3_add_value("DirName", oline, &ret))
182             return NULL;
183         break;
184
185     case GEN_IPADD:
186         p = gen->d.ip->data;
187         if (gen->d.ip->length == 4)
188             BIO_snprintf(oline, sizeof(oline), "%d.%d.%d.%d",
189                          p[0], p[1], p[2], p[3]);
190         else if (gen->d.ip->length == 16) {
191             oline[0] = 0;
192             for (i = 0; i < 8; i++) {
193                 BIO_snprintf(htmp, sizeof(htmp), "%X", p[0] << 8 | p[1]);
194                 p += 2;
195                 strcat(oline, htmp);
196                 if (i != 7)
197                     strcat(oline, ":");
198             }
199         } else {
200             if (!X509V3_add_value("IP Address", "<invalid>", &ret))
201                 return NULL;
202             break;
203         }
204         if (!X509V3_add_value("IP Address", oline, &ret))
205             return NULL;
206         break;
207
208     case GEN_RID:
209         i2t_ASN1_OBJECT(oline, 256, gen->d.rid);
210         if (!X509V3_add_value("Registered ID", oline, &ret))
211             return NULL;
212         break;
213     }
214     return ret;
215 }
216
217 int GENERAL_NAME_print(BIO *out, GENERAL_NAME *gen)
218 {
219     unsigned char *p;
220     int i, nid;
221
222     switch (gen->type) {
223     case GEN_OTHERNAME:
224         nid = OBJ_obj2nid(gen->d.otherName->type_id);
225         /* Validate the types are as we expect before we use them */
226         if ((nid == NID_SRVName
227              && gen->d.otherName->value->type != V_ASN1_IA5STRING)
228                 || (nid != NID_SRVName
229                     && gen->d.otherName->value->type != V_ASN1_UTF8STRING)) {
230             BIO_printf(out, "othername:<unsupported>");
231             break;
232         }
233
234         switch (nid) {
235         case NID_id_on_SmtpUTF8Mailbox:
236             BIO_printf(out, "othername:SmtpUTF8Mailbox:%s",
237                        gen->d.otherName->value->value.utf8string->data);
238             break;
239         case NID_XmppAddr:
240             BIO_printf(out, "othername:XmppAddr:%s",
241                        gen->d.otherName->value->value.utf8string->data);
242             break;
243         case NID_SRVName:
244             BIO_printf(out, "othername:SRVName:%s",
245                        gen->d.otherName->value->value.ia5string->data);
246             break;
247         case NID_ms_upn:
248             BIO_printf(out, "othername:UPN:%s",
249                        gen->d.otherName->value->value.utf8string->data);
250             break;
251         case NID_NAIRealm:
252             BIO_printf(out, "othername:NAIRealm:%s",
253                        gen->d.otherName->value->value.utf8string->data);
254             break;
255         default:
256             BIO_printf(out, "othername:<unsupported>");
257             break;
258         }
259         break;
260
261     case GEN_X400:
262         BIO_printf(out, "X400Name:<unsupported>");
263         break;
264
265     case GEN_EDIPARTY:
266         /* Maybe fix this: it is supported now */
267         BIO_printf(out, "EdiPartyName:<unsupported>");
268         break;
269
270     case GEN_EMAIL:
271         BIO_printf(out, "email:");
272         ASN1_STRING_print(out, gen->d.ia5);
273         break;
274
275     case GEN_DNS:
276         BIO_printf(out, "DNS:");
277         ASN1_STRING_print(out, gen->d.ia5);
278         break;
279
280     case GEN_URI:
281         BIO_printf(out, "URI:");
282         ASN1_STRING_print(out, gen->d.ia5);
283         break;
284
285     case GEN_DIRNAME:
286         BIO_printf(out, "DirName:");
287         X509_NAME_print_ex(out, gen->d.dirn, 0, XN_FLAG_ONELINE);
288         break;
289
290     case GEN_IPADD:
291         p = gen->d.ip->data;
292         if (gen->d.ip->length == 4)
293             BIO_printf(out, "IP Address:%d.%d.%d.%d", p[0], p[1], p[2], p[3]);
294         else if (gen->d.ip->length == 16) {
295             BIO_printf(out, "IP Address");
296             for (i = 0; i < 8; i++) {
297                 BIO_printf(out, ":%X", p[0] << 8 | p[1]);
298                 p += 2;
299             }
300         } else {
301             BIO_printf(out, "IP Address:<invalid>");
302             break;
303         }
304         break;
305
306     case GEN_RID:
307         BIO_printf(out, "Registered ID:");
308         i2a_ASN1_OBJECT(out, gen->d.rid);
309         break;
310     }
311     return 1;
312 }
313
314 static GENERAL_NAMES *v2i_issuer_alt(X509V3_EXT_METHOD *method,
315                                      X509V3_CTX *ctx,
316                                      STACK_OF(CONF_VALUE) *nval)
317 {
318     const int num = sk_CONF_VALUE_num(nval);
319     GENERAL_NAMES *gens = sk_GENERAL_NAME_new_reserve(NULL, num);
320     int i;
321
322     if (gens == NULL) {
323         X509V3err(X509V3_F_V2I_ISSUER_ALT, ERR_R_MALLOC_FAILURE);
324         sk_GENERAL_NAME_free(gens);
325         return NULL;
326     }
327     for (i = 0; i < num; i++) {
328         CONF_VALUE *cnf = sk_CONF_VALUE_value(nval, i);
329
330         if (!v3_name_cmp(cnf->name, "issuer")
331             && cnf->value && strcmp(cnf->value, "copy") == 0) {
332             if (!copy_issuer(ctx, gens))
333                 goto err;
334         } else {
335             GENERAL_NAME *gen = v2i_GENERAL_NAME(method, ctx, cnf);
336
337             if (gen == NULL)
338                 goto err;
339             sk_GENERAL_NAME_push(gens, gen); /* no failure as it was reserved */
340         }
341     }
342     return gens;
343  err:
344     sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
345     return NULL;
346 }
347
348 /* Append subject altname of issuer to issuer alt name of subject */
349
350 static int copy_issuer(X509V3_CTX *ctx, GENERAL_NAMES *gens)
351 {
352     GENERAL_NAMES *ialt;
353     GENERAL_NAME *gen;
354     X509_EXTENSION *ext;
355     int i, num;
356
357     if (ctx && (ctx->flags == CTX_TEST))
358         return 1;
359     if (!ctx || !ctx->issuer_cert) {
360         X509V3err(X509V3_F_COPY_ISSUER, X509V3_R_NO_ISSUER_DETAILS);
361         goto err;
362     }
363     i = X509_get_ext_by_NID(ctx->issuer_cert, NID_subject_alt_name, -1);
364     if (i < 0)
365         return 1;
366     if ((ext = X509_get_ext(ctx->issuer_cert, i)) == NULL
367         || (ialt = X509V3_EXT_d2i(ext)) == NULL) {
368         X509V3err(X509V3_F_COPY_ISSUER, X509V3_R_ISSUER_DECODE_ERROR);
369         goto err;
370     }
371
372     num = sk_GENERAL_NAME_num(ialt);
373     if (!sk_GENERAL_NAME_reserve(gens, num)) {
374         X509V3err(X509V3_F_COPY_ISSUER, ERR_R_MALLOC_FAILURE);
375         goto err;
376     }
377
378     for (i = 0; i < num; i++) {
379         gen = sk_GENERAL_NAME_value(ialt, i);
380         sk_GENERAL_NAME_push(gens, gen);     /* no failure as it was reserved */
381     }
382     sk_GENERAL_NAME_free(ialt);
383
384     return 1;
385
386  err:
387     return 0;
388
389 }
390
391 static GENERAL_NAMES *v2i_subject_alt(X509V3_EXT_METHOD *method,
392                                       X509V3_CTX *ctx,
393                                       STACK_OF(CONF_VALUE) *nval)
394 {
395     GENERAL_NAMES *gens;
396     CONF_VALUE *cnf;
397     const int num = sk_CONF_VALUE_num(nval);
398     int i;
399
400     gens = sk_GENERAL_NAME_new_reserve(NULL, num);
401     if (gens == NULL) {
402         X509V3err(X509V3_F_V2I_SUBJECT_ALT, ERR_R_MALLOC_FAILURE);
403         sk_GENERAL_NAME_free(gens);
404         return NULL;
405     }
406
407     for (i = 0; i < num; i++) {
408         cnf = sk_CONF_VALUE_value(nval, i);
409         if (!v3_name_cmp(cnf->name, "email")
410             && cnf->value && strcmp(cnf->value, "copy") == 0) {
411             if (!copy_email(ctx, gens, 0))
412                 goto err;
413         } else if (!v3_name_cmp(cnf->name, "email")
414                    && cnf->value && strcmp(cnf->value, "move") == 0) {
415             if (!copy_email(ctx, gens, 1))
416                 goto err;
417         } else {
418             GENERAL_NAME *gen;
419             if ((gen = v2i_GENERAL_NAME(method, ctx, cnf)) == NULL)
420                 goto err;
421             sk_GENERAL_NAME_push(gens, gen); /* no failure as it was reserved */
422         }
423     }
424     return gens;
425  err:
426     sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
427     return NULL;
428 }
429
430 /*
431  * Copy any email addresses in a certificate or request to GENERAL_NAMES
432  */
433
434 static int copy_email(X509V3_CTX *ctx, GENERAL_NAMES *gens, int move_p)
435 {
436     X509_NAME *nm;
437     ASN1_IA5STRING *email = NULL;
438     X509_NAME_ENTRY *ne;
439     GENERAL_NAME *gen = NULL;
440     int i = -1;
441
442     if (ctx != NULL && ctx->flags == CTX_TEST)
443         return 1;
444     if (ctx == NULL
445         || (ctx->subject_cert == NULL && ctx->subject_req == NULL)) {
446         X509V3err(X509V3_F_COPY_EMAIL, X509V3_R_NO_SUBJECT_DETAILS);
447         goto err;
448     }
449     /* Find the subject name */
450     if (ctx->subject_cert)
451         nm = X509_get_subject_name(ctx->subject_cert);
452     else
453         nm = X509_REQ_get_subject_name(ctx->subject_req);
454
455     /* Now add any email address(es) to STACK */
456     while ((i = X509_NAME_get_index_by_NID(nm,
457                                            NID_pkcs9_emailAddress, i)) >= 0) {
458         ne = X509_NAME_get_entry(nm, i);
459         email = ASN1_STRING_dup(X509_NAME_ENTRY_get_data(ne));
460         if (move_p) {
461             X509_NAME_delete_entry(nm, i);
462             X509_NAME_ENTRY_free(ne);
463             i--;
464         }
465         if (email == NULL || (gen = GENERAL_NAME_new()) == NULL) {
466             X509V3err(X509V3_F_COPY_EMAIL, ERR_R_MALLOC_FAILURE);
467             goto err;
468         }
469         gen->d.ia5 = email;
470         email = NULL;
471         gen->type = GEN_EMAIL;
472         if (!sk_GENERAL_NAME_push(gens, gen)) {
473             X509V3err(X509V3_F_COPY_EMAIL, ERR_R_MALLOC_FAILURE);
474             goto err;
475         }
476         gen = NULL;
477     }
478
479     return 1;
480
481  err:
482     GENERAL_NAME_free(gen);
483     ASN1_IA5STRING_free(email);
484     return 0;
485
486 }
487
488 GENERAL_NAMES *v2i_GENERAL_NAMES(const X509V3_EXT_METHOD *method,
489                                  X509V3_CTX *ctx, STACK_OF(CONF_VALUE) *nval)
490 {
491     GENERAL_NAME *gen;
492     GENERAL_NAMES *gens;
493     CONF_VALUE *cnf;
494     const int num = sk_CONF_VALUE_num(nval);
495     int i;
496
497     gens = sk_GENERAL_NAME_new_reserve(NULL, num);
498     if (gens == NULL) {
499         X509V3err(X509V3_F_V2I_GENERAL_NAMES, ERR_R_MALLOC_FAILURE);
500         sk_GENERAL_NAME_free(gens);
501         return NULL;
502     }
503
504     for (i = 0; i < num; i++) {
505         cnf = sk_CONF_VALUE_value(nval, i);
506         if ((gen = v2i_GENERAL_NAME(method, ctx, cnf)) == NULL)
507             goto err;
508         sk_GENERAL_NAME_push(gens, gen);    /* no failure as it was reserved */
509     }
510     return gens;
511  err:
512     sk_GENERAL_NAME_pop_free(gens, GENERAL_NAME_free);
513     return NULL;
514 }
515
516 GENERAL_NAME *v2i_GENERAL_NAME(const X509V3_EXT_METHOD *method,
517                                X509V3_CTX *ctx, CONF_VALUE *cnf)
518 {
519     return v2i_GENERAL_NAME_ex(NULL, method, ctx, cnf, 0);
520 }
521
522 GENERAL_NAME *a2i_GENERAL_NAME(GENERAL_NAME *out,
523                                const X509V3_EXT_METHOD *method,
524                                X509V3_CTX *ctx, int gen_type, const char *value,
525                                int is_nc)
526 {
527     char is_string = 0;
528     GENERAL_NAME *gen = NULL;
529
530     if (!value) {
531         X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_MISSING_VALUE);
532         return NULL;
533     }
534
535     if (out)
536         gen = out;
537     else {
538         gen = GENERAL_NAME_new();
539         if (gen == NULL) {
540             X509V3err(X509V3_F_A2I_GENERAL_NAME, ERR_R_MALLOC_FAILURE);
541             return NULL;
542         }
543     }
544
545     switch (gen_type) {
546     case GEN_URI:
547     case GEN_EMAIL:
548     case GEN_DNS:
549         is_string = 1;
550         break;
551
552     case GEN_RID:
553         {
554             ASN1_OBJECT *obj;
555             if ((obj = OBJ_txt2obj(value, 0)) == NULL) {
556                 X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_BAD_OBJECT);
557                 ERR_add_error_data(2, "value=", value);
558                 goto err;
559             }
560             gen->d.rid = obj;
561         }
562         break;
563
564     case GEN_IPADD:
565         if (is_nc)
566             gen->d.ip = a2i_IPADDRESS_NC(value);
567         else
568             gen->d.ip = a2i_IPADDRESS(value);
569         if (gen->d.ip == NULL) {
570             X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_BAD_IP_ADDRESS);
571             ERR_add_error_data(2, "value=", value);
572             goto err;
573         }
574         break;
575
576     case GEN_DIRNAME:
577         if (!do_dirname(gen, value, ctx)) {
578             X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_DIRNAME_ERROR);
579             goto err;
580         }
581         break;
582
583     case GEN_OTHERNAME:
584         if (!do_othername(gen, value, ctx)) {
585             X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_OTHERNAME_ERROR);
586             goto err;
587         }
588         break;
589     default:
590         X509V3err(X509V3_F_A2I_GENERAL_NAME, X509V3_R_UNSUPPORTED_TYPE);
591         goto err;
592     }
593
594     if (is_string) {
595         if ((gen->d.ia5 = ASN1_IA5STRING_new()) == NULL ||
596             !ASN1_STRING_set(gen->d.ia5, (unsigned char *)value,
597                              strlen(value))) {
598             X509V3err(X509V3_F_A2I_GENERAL_NAME, ERR_R_MALLOC_FAILURE);
599             goto err;
600         }
601     }
602
603     gen->type = gen_type;
604
605     return gen;
606
607  err:
608     if (!out)
609         GENERAL_NAME_free(gen);
610     return NULL;
611 }
612
613 GENERAL_NAME *v2i_GENERAL_NAME_ex(GENERAL_NAME *out,
614                                   const X509V3_EXT_METHOD *method,
615                                   X509V3_CTX *ctx, CONF_VALUE *cnf, int is_nc)
616 {
617     int type;
618
619     char *name, *value;
620
621     name = cnf->name;
622     value = cnf->value;
623
624     if (!value) {
625         X509V3err(X509V3_F_V2I_GENERAL_NAME_EX, X509V3_R_MISSING_VALUE);
626         return NULL;
627     }
628
629     if (!v3_name_cmp(name, "email"))
630         type = GEN_EMAIL;
631     else if (!v3_name_cmp(name, "URI"))
632         type = GEN_URI;
633     else if (!v3_name_cmp(name, "DNS"))
634         type = GEN_DNS;
635     else if (!v3_name_cmp(name, "RID"))
636         type = GEN_RID;
637     else if (!v3_name_cmp(name, "IP"))
638         type = GEN_IPADD;
639     else if (!v3_name_cmp(name, "dirName"))
640         type = GEN_DIRNAME;
641     else if (!v3_name_cmp(name, "otherName"))
642         type = GEN_OTHERNAME;
643     else {
644         X509V3err(X509V3_F_V2I_GENERAL_NAME_EX, X509V3_R_UNSUPPORTED_OPTION);
645         ERR_add_error_data(2, "name=", name);
646         return NULL;
647     }
648
649     return a2i_GENERAL_NAME(out, method, ctx, type, value, is_nc);
650
651 }
652
653 static int do_othername(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx)
654 {
655     char *objtmp = NULL, *p;
656     int objlen;
657
658     if ((p = strchr(value, ';')) == NULL)
659         return 0;
660     if ((gen->d.otherName = OTHERNAME_new()) == NULL)
661         return 0;
662     /*
663      * Free this up because we will overwrite it. no need to free type_id
664      * because it is static
665      */
666     ASN1_TYPE_free(gen->d.otherName->value);
667     if ((gen->d.otherName->value = ASN1_generate_v3(p + 1, ctx)) == NULL)
668         return 0;
669     objlen = p - value;
670     objtmp = OPENSSL_strndup(value, objlen);
671     if (objtmp == NULL)
672         return 0;
673     gen->d.otherName->type_id = OBJ_txt2obj(objtmp, 0);
674     OPENSSL_free(objtmp);
675     if (!gen->d.otherName->type_id)
676         return 0;
677     return 1;
678 }
679
680 static int do_dirname(GENERAL_NAME *gen, const char *value, X509V3_CTX *ctx)
681 {
682     int ret = 0;
683     STACK_OF(CONF_VALUE) *sk = NULL;
684     X509_NAME *nm;
685
686     if ((nm = X509_NAME_new()) == NULL)
687         goto err;
688     sk = X509V3_get_section(ctx, value);
689     if (!sk) {
690         X509V3err(X509V3_F_DO_DIRNAME, X509V3_R_SECTION_NOT_FOUND);
691         ERR_add_error_data(2, "section=", value);
692         goto err;
693     }
694     /* FIXME: should allow other character types... */
695     ret = X509V3_NAME_from_section(nm, sk, MBSTRING_ASC);
696     if (!ret)
697         goto err;
698     gen->d.dirn = nm;
699
700 err:
701     if (ret == 0)
702         X509_NAME_free(nm);
703     X509V3_section_free(ctx, sk);
704     return ret;
705 }