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 "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
 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
 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
 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
 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
 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
 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
 206 static void cleanup2_doall(ADDED_OBJ *a)
 207 {
 208     a->obj->nid++;
 209 }
 210
 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
 228 void check_defer(int nid)
 229 {
 230     if (!obj_cleanup_defer && nid >= NUM_NID)
 231         obj_cleanup_defer = 1;
 232 }
 233
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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
 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  */
 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
 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 }