lib/libcrypto/objects/obj_dat.c

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