crypto/libressl/crypto/objects/obj_dat.c

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