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