bda955651e8f13a2e1f2d1f2f78d4622220481f2
[openssl.git] / crypto / objects / obj_dat.c
1 /* crypto/objects/obj_dat.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 <ctype.h>
61 #include <limits.h>
62 #include "internal/cryptlib.h"
63 #include <openssl/lhash.h>
64 #include <openssl/asn1.h>
65 #include <openssl/objects.h>
66 #include <openssl/bn.h>
67 #include "internal/asn1_int.h"
68
69 /* obj_dat.h is generated from objects.h by obj_dat.pl */
70 #include "obj_dat.h"
71
72 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
73 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
74 DECLARE_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
75
76 #define ADDED_DATA      0
77 #define ADDED_SNAME     1
78 #define ADDED_LNAME     2
79 #define ADDED_NID       3
80
81 typedef struct added_obj_st {
82     int type;
83     ASN1_OBJECT *obj;
84 } ADDED_OBJ;
85 DECLARE_LHASH_OF(ADDED_OBJ);
86
87 static int new_nid = NUM_NID;
88 static LHASH_OF(ADDED_OBJ) *added = NULL;
89
90 static int sn_cmp(const ASN1_OBJECT *const *a, const unsigned int *b)
91 {
92     return (strcmp((*a)->sn, nid_objs[*b].sn));
93 }
94
95 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, sn);
96
97 static int ln_cmp(const ASN1_OBJECT *const *a, const unsigned int *b)
98 {
99     return (strcmp((*a)->ln, nid_objs[*b].ln));
100 }
101
102 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, ln);
103
104 static unsigned long added_obj_hash(const ADDED_OBJ *ca)
105 {
106     const ASN1_OBJECT *a;
107     int i;
108     unsigned long ret = 0;
109     unsigned char *p;
110
111     a = ca->obj;
112     switch (ca->type) {
113     case ADDED_DATA:
114         ret = a->length << 20L;
115         p = (unsigned char *)a->data;
116         for (i = 0; i < a->length; i++)
117             ret ^= p[i] << ((i * 3) % 24);
118         break;
119     case ADDED_SNAME:
120         ret = lh_strhash(a->sn);
121         break;
122     case ADDED_LNAME:
123         ret = lh_strhash(a->ln);
124         break;
125     case ADDED_NID:
126         ret = a->nid;
127         break;
128     default:
129         /* abort(); */
130         return 0;
131     }
132     ret &= 0x3fffffffL;
133     ret |= ((unsigned long)ca->type) << 30L;
134     return (ret);
135 }
136
137 static IMPLEMENT_LHASH_HASH_FN(added_obj, ADDED_OBJ)
138
139 static int added_obj_cmp(const ADDED_OBJ *ca, const ADDED_OBJ *cb)
140 {
141     ASN1_OBJECT *a, *b;
142     int i;
143
144     i = ca->type - cb->type;
145     if (i)
146         return (i);
147     a = ca->obj;
148     b = cb->obj;
149     switch (ca->type) {
150     case ADDED_DATA:
151         i = (a->length - b->length);
152         if (i)
153             return (i);
154         return (memcmp(a->data, b->data, (size_t)a->length));
155     case ADDED_SNAME:
156         if (a->sn == NULL)
157             return (-1);
158         else if (b->sn == NULL)
159             return (1);
160         else
161             return (strcmp(a->sn, b->sn));
162     case ADDED_LNAME:
163         if (a->ln == NULL)
164             return (-1);
165         else if (b->ln == NULL)
166             return (1);
167         else
168             return (strcmp(a->ln, b->ln));
169     case ADDED_NID:
170         return (a->nid - b->nid);
171     default:
172         /* abort(); */
173         return 0;
174     }
175 }
176
177 static IMPLEMENT_LHASH_COMP_FN(added_obj, ADDED_OBJ)
178
179 static int init_added(void)
180 {
181     if (added != NULL)
182         return (1);
183     added = lh_ADDED_OBJ_new();
184     return (added != NULL);
185 }
186
187 static void cleanup1_doall(ADDED_OBJ *a)
188 {
189     a->obj->nid = 0;
190     a->obj->flags |= ASN1_OBJECT_FLAG_DYNAMIC |
191         ASN1_OBJECT_FLAG_DYNAMIC_STRINGS | ASN1_OBJECT_FLAG_DYNAMIC_DATA;
192 }
193
194 static void cleanup2_doall(ADDED_OBJ *a)
195 {
196     a->obj->nid++;
197 }
198
199 static void cleanup3_doall(ADDED_OBJ *a)
200 {
201     if (--a->obj->nid == 0)
202         ASN1_OBJECT_free(a->obj);
203     OPENSSL_free(a);
204 }
205
206 static IMPLEMENT_LHASH_DOALL_FN(cleanup1, ADDED_OBJ)
207 static IMPLEMENT_LHASH_DOALL_FN(cleanup2, ADDED_OBJ)
208 static IMPLEMENT_LHASH_DOALL_FN(cleanup3, ADDED_OBJ)
209
210 /*
211  * The purpose of obj_cleanup_defer is to avoid EVP_cleanup() attempting to
212  * use freed up OIDs. If necessary the actual freeing up of OIDs is delayed.
213  */
214 int obj_cleanup_defer = 0;
215
216 void check_defer(int nid)
217 {
218     if (!obj_cleanup_defer && nid >= NUM_NID)
219         obj_cleanup_defer = 1;
220 }
221
222 void OBJ_cleanup(void)
223 {
224     if (obj_cleanup_defer) {
225         obj_cleanup_defer = 2;
226         return;
227     }
228     if (added == NULL)
229         return;
230     lh_ADDED_OBJ_down_load(added) = 0;
231     lh_ADDED_OBJ_doall(added, LHASH_DOALL_FN(cleanup1)); /* zero counters */
232     lh_ADDED_OBJ_doall(added, LHASH_DOALL_FN(cleanup2)); /* set counters */
233     lh_ADDED_OBJ_doall(added, LHASH_DOALL_FN(cleanup3)); /* free objects */
234     lh_ADDED_OBJ_free(added);
235     added = NULL;
236 }
237
238 int OBJ_new_nid(int num)
239 {
240     int i;
241
242     i = new_nid;
243     new_nid += num;
244     return (i);
245 }
246
247 int OBJ_add_object(const ASN1_OBJECT *obj)
248 {
249     ASN1_OBJECT *o;
250     ADDED_OBJ *ao[4] = { NULL, NULL, NULL, NULL }, *aop;
251     int i;
252
253     if (added == NULL)
254         if (!init_added())
255             return (0);
256     if ((o = OBJ_dup(obj)) == NULL)
257         goto err;
258     if ((ao[ADDED_NID] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
259         goto err2;
260     if ((o->length != 0) && (obj->data != NULL))
261         if ((ao[ADDED_DATA] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
262             goto err2;
263     if (o->sn != NULL)
264         if ((ao[ADDED_SNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
265             goto err2;
266     if (o->ln != NULL)
267         if ((ao[ADDED_LNAME] = OPENSSL_malloc(sizeof(*ao[0]))) == NULL)
268             goto err2;
269
270     for (i = ADDED_DATA; i <= ADDED_NID; i++) {
271         if (ao[i] != NULL) {
272             ao[i]->type = i;
273             ao[i]->obj = o;
274             aop = lh_ADDED_OBJ_insert(added, ao[i]);
275             /* memory leak, buit should not normally matter */
276             OPENSSL_free(aop);
277         }
278     }
279     o->flags &=
280         ~(ASN1_OBJECT_FLAG_DYNAMIC | ASN1_OBJECT_FLAG_DYNAMIC_STRINGS |
281           ASN1_OBJECT_FLAG_DYNAMIC_DATA);
282
283     return (o->nid);
284  err2:
285     OBJerr(OBJ_F_OBJ_ADD_OBJECT, ERR_R_MALLOC_FAILURE);
286  err:
287     for (i = ADDED_DATA; i <= ADDED_NID; i++)
288         OPENSSL_free(ao[i]);
289     OPENSSL_free(o);
290     return (NID_undef);
291 }
292
293 ASN1_OBJECT *OBJ_nid2obj(int n)
294 {
295     ADDED_OBJ ad, *adp;
296     ASN1_OBJECT ob;
297
298     if ((n >= 0) && (n < NUM_NID)) {
299         if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) {
300             OBJerr(OBJ_F_OBJ_NID2OBJ, OBJ_R_UNKNOWN_NID);
301             return (NULL);
302         }
303         return ((ASN1_OBJECT *)&(nid_objs[n]));
304     } else if (added == NULL)
305         return (NULL);
306     else {
307         ad.type = ADDED_NID;
308         ad.obj = &ob;
309         ob.nid = n;
310         adp = lh_ADDED_OBJ_retrieve(added, &ad);
311         if (adp != NULL)
312             return (adp->obj);
313         else {
314             OBJerr(OBJ_F_OBJ_NID2OBJ, OBJ_R_UNKNOWN_NID);
315             return (NULL);
316         }
317     }
318 }
319
320 const char *OBJ_nid2sn(int n)
321 {
322     ADDED_OBJ ad, *adp;
323     ASN1_OBJECT ob;
324
325     if ((n >= 0) && (n < NUM_NID)) {
326         if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) {
327             OBJerr(OBJ_F_OBJ_NID2SN, OBJ_R_UNKNOWN_NID);
328             return (NULL);
329         }
330         return (nid_objs[n].sn);
331     } else if (added == NULL)
332         return (NULL);
333     else {
334         ad.type = ADDED_NID;
335         ad.obj = &ob;
336         ob.nid = n;
337         adp = lh_ADDED_OBJ_retrieve(added, &ad);
338         if (adp != NULL)
339             return (adp->obj->sn);
340         else {
341             OBJerr(OBJ_F_OBJ_NID2SN, OBJ_R_UNKNOWN_NID);
342             return (NULL);
343         }
344     }
345 }
346
347 const char *OBJ_nid2ln(int n)
348 {
349     ADDED_OBJ ad, *adp;
350     ASN1_OBJECT ob;
351
352     if ((n >= 0) && (n < NUM_NID)) {
353         if ((n != NID_undef) && (nid_objs[n].nid == NID_undef)) {
354             OBJerr(OBJ_F_OBJ_NID2LN, OBJ_R_UNKNOWN_NID);
355             return (NULL);
356         }
357         return (nid_objs[n].ln);
358     } else if (added == NULL)
359         return (NULL);
360     else {
361         ad.type = ADDED_NID;
362         ad.obj = &ob;
363         ob.nid = n;
364         adp = lh_ADDED_OBJ_retrieve(added, &ad);
365         if (adp != NULL)
366             return (adp->obj->ln);
367         else {
368             OBJerr(OBJ_F_OBJ_NID2LN, OBJ_R_UNKNOWN_NID);
369             return (NULL);
370         }
371     }
372 }
373
374 static int obj_cmp(const ASN1_OBJECT *const *ap, const unsigned int *bp)
375 {
376     int j;
377     const ASN1_OBJECT *a = *ap;
378     const ASN1_OBJECT *b = &nid_objs[*bp];
379
380     j = (a->length - b->length);
381     if (j)
382         return (j);
383     if (a->length == 0)
384         return 0;
385     return (memcmp(a->data, b->data, a->length));
386 }
387
388 IMPLEMENT_OBJ_BSEARCH_CMP_FN(const ASN1_OBJECT *, unsigned int, obj);
389
390 int OBJ_obj2nid(const ASN1_OBJECT *a)
391 {
392     const unsigned int *op;
393     ADDED_OBJ ad, *adp;
394
395     if (a == NULL)
396         return (NID_undef);
397     if (a->nid != 0)
398         return (a->nid);
399
400     if (a->length == 0)
401         return NID_undef;
402
403     if (added != NULL) {
404         ad.type = ADDED_DATA;
405         ad.obj = (ASN1_OBJECT *)a; /* XXX: ugly but harmless */
406         adp = lh_ADDED_OBJ_retrieve(added, &ad);
407         if (adp != NULL)
408             return (adp->obj->nid);
409     }
410     op = OBJ_bsearch_obj(&a, obj_objs, NUM_OBJ);
411     if (op == NULL)
412         return (NID_undef);
413     return (nid_objs[*op].nid);
414 }
415
416 /*
417  * Convert an object name into an ASN1_OBJECT if "noname" is not set then
418  * search for short and long names first. This will convert the "dotted" form
419  * into an object: unlike OBJ_txt2nid it can be used with any objects, not
420  * just registered ones.
421  */
422
423 ASN1_OBJECT *OBJ_txt2obj(const char *s, int no_name)
424 {
425     int nid = NID_undef;
426     ASN1_OBJECT *op = NULL;
427     unsigned char *buf;
428     unsigned char *p;
429     const unsigned char *cp;
430     int i, j;
431
432     if (!no_name) {
433         if (((nid = OBJ_sn2nid(s)) != NID_undef) ||
434             ((nid = OBJ_ln2nid(s)) != NID_undef))
435             return OBJ_nid2obj(nid);
436     }
437
438     /* Work out size of content octets */
439     i = a2d_ASN1_OBJECT(NULL, 0, s, -1);
440     if (i <= 0) {
441         /* Don't clear the error */
442         /*
443          * ERR_clear_error();
444          */
445         return NULL;
446     }
447     /* Work out total size */
448     j = ASN1_object_size(0, i, V_ASN1_OBJECT);
449
450     if ((buf = OPENSSL_malloc(j)) == NULL)
451         return NULL;
452
453     p = buf;
454     /* Write out tag+length */
455     ASN1_put_object(&p, 0, i, V_ASN1_OBJECT, V_ASN1_UNIVERSAL);
456     /* Write out contents */
457     a2d_ASN1_OBJECT(p, i, s, -1);
458
459     cp = buf;
460     op = d2i_ASN1_OBJECT(NULL, &cp, j);
461     OPENSSL_free(buf);
462     return op;
463 }
464
465 int OBJ_obj2txt(char *buf, int buf_len, const ASN1_OBJECT *a, int no_name)
466 {
467     int i, n = 0, len, nid, first, use_bn;
468     BIGNUM *bl;
469     unsigned long l;
470     const unsigned char *p;
471     char tbuf[DECIMAL_SIZE(i) + DECIMAL_SIZE(l) + 2];
472
473     /* Ensure that, at every state, |buf| is NUL-terminated. */
474     if (buf && buf_len > 0)
475         buf[0] = '\0';
476
477     if ((a == NULL) || (a->data == NULL))
478         return (0);
479
480     if (!no_name && (nid = OBJ_obj2nid(a)) != NID_undef) {
481         const char *s;
482         s = OBJ_nid2ln(nid);
483         if (s == NULL)
484             s = OBJ_nid2sn(nid);
485         if (s) {
486             if (buf)
487                 OPENSSL_strlcpy(buf, s, buf_len);
488             n = strlen(s);
489             return n;
490         }
491     }
492
493     len = a->length;
494     p = a->data;
495
496     first = 1;
497     bl = NULL;
498
499     while (len > 0) {
500         l = 0;
501         use_bn = 0;
502         for (;;) {
503             unsigned char c = *p++;
504             len--;
505             if ((len == 0) && (c & 0x80))
506                 goto err;
507             if (use_bn) {
508                 if (!BN_add_word(bl, c & 0x7f))
509                     goto err;
510             } else
511                 l |= c & 0x7f;
512             if (!(c & 0x80))
513                 break;
514             if (!use_bn && (l > (ULONG_MAX >> 7L))) {
515                 if (bl == NULL && (bl = BN_new()) == NULL)
516                     goto err;
517                 if (!BN_set_word(bl, l))
518                     goto err;
519                 use_bn = 1;
520             }
521             if (use_bn) {
522                 if (!BN_lshift(bl, bl, 7))
523                     goto err;
524             } else
525                 l <<= 7L;
526         }
527
528         if (first) {
529             first = 0;
530             if (l >= 80) {
531                 i = 2;
532                 if (use_bn) {
533                     if (!BN_sub_word(bl, 80))
534                         goto err;
535                 } else
536                     l -= 80;
537             } else {
538                 i = (int)(l / 40);
539                 l -= (long)(i * 40);
540             }
541             if (buf && (buf_len > 1)) {
542                 *buf++ = i + '0';
543                 *buf = '\0';
544                 buf_len--;
545             }
546             n++;
547         }
548
549         if (use_bn) {
550             char *bndec;
551             bndec = BN_bn2dec(bl);
552             if (!bndec)
553                 goto err;
554             i = strlen(bndec);
555             if (buf) {
556                 if (buf_len > 1) {
557                     *buf++ = '.';
558                     *buf = '\0';
559                     buf_len--;
560                 }
561                 OPENSSL_strlcpy(buf, bndec, buf_len);
562                 if (i > buf_len) {
563                     buf += buf_len;
564                     buf_len = 0;
565                 } else {
566                     buf += i;
567                     buf_len -= i;
568                 }
569             }
570             n++;
571             n += i;
572             OPENSSL_free(bndec);
573         } else {
574             BIO_snprintf(tbuf, sizeof tbuf, ".%lu", l);
575             i = strlen(tbuf);
576             if (buf && (buf_len > 0)) {
577                 OPENSSL_strlcpy(buf, tbuf, buf_len);
578                 if (i > buf_len) {
579                     buf += buf_len;
580                     buf_len = 0;
581                 } else {
582                     buf += i;
583                     buf_len -= i;
584                 }
585             }
586             n += i;
587             l = 0;
588         }
589     }
590
591     BN_free(bl);
592     return n;
593
594  err:
595     BN_free(bl);
596     return -1;
597 }
598
599 int OBJ_txt2nid(const char *s)
600 {
601     ASN1_OBJECT *obj;
602     int nid;
603     obj = OBJ_txt2obj(s, 0);
604     nid = OBJ_obj2nid(obj);
605     ASN1_OBJECT_free(obj);
606     return nid;
607 }
608
609 int OBJ_ln2nid(const char *s)
610 {
611     ASN1_OBJECT o;
612     const ASN1_OBJECT *oo = &o;
613     ADDED_OBJ ad, *adp;
614     const unsigned int *op;
615
616     o.ln = s;
617     if (added != NULL) {
618         ad.type = ADDED_LNAME;
619         ad.obj = &o;
620         adp = lh_ADDED_OBJ_retrieve(added, &ad);
621         if (adp != NULL)
622             return (adp->obj->nid);
623     }
624     op = OBJ_bsearch_ln(&oo, ln_objs, NUM_LN);
625     if (op == NULL)
626         return (NID_undef);
627     return (nid_objs[*op].nid);
628 }
629
630 int OBJ_sn2nid(const char *s)
631 {
632     ASN1_OBJECT o;
633     const ASN1_OBJECT *oo = &o;
634     ADDED_OBJ ad, *adp;
635     const unsigned int *op;
636
637     o.sn = s;
638     if (added != NULL) {
639         ad.type = ADDED_SNAME;
640         ad.obj = &o;
641         adp = lh_ADDED_OBJ_retrieve(added, &ad);
642         if (adp != NULL)
643             return (adp->obj->nid);
644     }
645     op = OBJ_bsearch_sn(&oo, sn_objs, NUM_SN);
646     if (op == NULL)
647         return (NID_undef);
648     return (nid_objs[*op].nid);
649 }
650
651 const void *OBJ_bsearch_(const void *key, const void *base, int num, int size,
652                          int (*cmp) (const void *, const void *))
653 {
654     return OBJ_bsearch_ex_(key, base, num, size, cmp, 0);
655 }
656
657 const void *OBJ_bsearch_ex_(const void *key, const void *base_, int num,
658                             int size,
659                             int (*cmp) (const void *, const void *),
660                             int flags)
661 {
662     const char *base = base_;
663     int l, h, i = 0, c = 0;
664     const char *p = NULL;
665
666     if (num == 0)
667         return (NULL);
668     l = 0;
669     h = num;
670     while (l < h) {
671         i = (l + h) / 2;
672         p = &(base[i * size]);
673         c = (*cmp) (key, p);
674         if (c < 0)
675             h = i;
676         else if (c > 0)
677             l = i + 1;
678         else
679             break;
680     }
681 #ifdef CHARSET_EBCDIC
682     /*
683      * THIS IS A KLUDGE - Because the *_obj is sorted in ASCII order, and I
684      * don't have perl (yet), we revert to a *LINEAR* search when the object
685      * wasn't found in the binary search.
686      */
687     if (c != 0) {
688         for (i = 0; i < num; ++i) {
689             p = &(base[i * size]);
690             c = (*cmp) (key, p);
691             if (c == 0 || (c < 0 && (flags & OBJ_BSEARCH_VALUE_ON_NOMATCH)))
692                 return p;
693         }
694     }
695 #endif
696     if (c != 0 && !(flags & OBJ_BSEARCH_VALUE_ON_NOMATCH))
697         p = NULL;
698     else if (c == 0 && (flags & OBJ_BSEARCH_FIRST_VALUE_ON_MATCH)) {
699         while (i > 0 && (*cmp) (key, &(base[(i - 1) * size])) == 0)
700             i--;
701         p = &(base[i * size]);
702     }
703     return (p);
704 }
705
706 int OBJ_create_objects(BIO *in)
707 {
708     char buf[512];
709     int i, num = 0;
710     char *o, *s, *l = NULL;
711
712     for (;;) {
713         s = o = NULL;
714         i = BIO_gets(in, buf, 512);
715         if (i <= 0)
716             return (num);
717         buf[i - 1] = '\0';
718         if (!isalnum((unsigned char)buf[0]))
719             return (num);
720         o = s = buf;
721         while (isdigit((unsigned char)*s) || (*s == '.'))
722             s++;
723         if (*s != '\0') {
724             *(s++) = '\0';
725             while (isspace((unsigned char)*s))
726                 s++;
727             if (*s == '\0')
728                 s = NULL;
729             else {
730                 l = s;
731                 while ((*l != '\0') && !isspace((unsigned char)*l))
732                     l++;
733                 if (*l != '\0') {
734                     *(l++) = '\0';
735                     while (isspace((unsigned char)*l))
736                         l++;
737                     if (*l == '\0')
738                         l = NULL;
739                 } else
740                     l = NULL;
741             }
742         } else
743             s = NULL;
744         if ((o == NULL) || (*o == '\0'))
745             return (num);
746         if (!OBJ_create(o, s, l))
747             return (num);
748         num++;
749     }
750     /* return(num); */
751 }
752
753 int OBJ_create(const char *oid, const char *sn, const char *ln)
754 {
755     int ok = 0;
756     ASN1_OBJECT *op = NULL;
757     unsigned char *buf;
758     int i;
759
760     i = a2d_ASN1_OBJECT(NULL, 0, oid, -1);
761     if (i <= 0)
762         return (0);
763
764     if ((buf = OPENSSL_malloc(i)) == NULL) {
765         OBJerr(OBJ_F_OBJ_CREATE, ERR_R_MALLOC_FAILURE);
766         return (0);
767     }
768     i = a2d_ASN1_OBJECT(buf, i, oid, -1);
769     if (i == 0)
770         goto err;
771     op = (ASN1_OBJECT *)ASN1_OBJECT_create(OBJ_new_nid(1), buf, i, sn, ln);
772     if (op == NULL)
773         goto err;
774     ok = OBJ_add_object(op);
775  err:
776     ASN1_OBJECT_free(op);
777     OPENSSL_free(buf);
778     return (ok);
779 }
780
781 size_t OBJ_length(const ASN1_OBJECT *obj)
782 {
783     if (obj == NULL)
784         return 0;
785     return obj->length;
786 }
787
788 const unsigned char *OBJ_get0_data(const ASN1_OBJECT *obj)
789 {
790     if (obj == NULL)
791         return NULL;
792     return obj->data;
793 }