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
sn_cmp(const ASN1_OBJECT * const * a,const unsigned int * b)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
sn_cmp_BSEARCH_CMP_FN(const void * a_,const void * b_)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 *
OBJ_bsearch_sn(const ASN1_OBJECT ** key,unsigned int const * base,int num)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
ln_cmp(const ASN1_OBJECT * const * a,const unsigned int * b)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
ln_cmp_BSEARCH_CMP_FN(const void * a_,const void * b_)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 *
OBJ_bsearch_ln(const ASN1_OBJECT ** key,unsigned int const * base,int num)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
added_obj_hash(const ADDED_OBJ * ca)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 }
IMPLEMENT_LHASH_HASH_FN(added_obj,ADDED_OBJ)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 }
IMPLEMENT_LHASH_COMP_FN(added_obj,ADDED_OBJ)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
cleanup1_doall(ADDED_OBJ * a)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
cleanup2_doall(ADDED_OBJ * a)236 static void cleanup2_doall(ADDED_OBJ *a)
237 {
238 a->obj->nid++;
239 }
240
241 static void
cleanup3_doall(ADDED_OBJ * a)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
check_defer(int nid)261 check_defer(int nid)
262 {
263 if (!obj_cleanup_defer && nid >= NUM_NID)
264 obj_cleanup_defer = 1;
265 }
266
267 void
OBJ_cleanup(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
OBJ_new_nid(int num)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
OBJ_add_object(const ASN1_OBJECT * obj)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 *
OBJ_nid2obj(int n)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 *
OBJ_nid2sn(int n)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 *
OBJ_nid2ln(int n)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
obj_cmp(const ASN1_OBJECT * const * ap,const unsigned int * bp)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
obj_cmp_BSEARCH_CMP_FN(const void * a_,const void * b_)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 *
OBJ_bsearch_obj(const ASN1_OBJECT ** key,unsigned int const * base,int num)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
OBJ_obj2nid(const ASN1_OBJECT * a)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 *
OBJ_txt2obj(const char * s,int no_name)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
OBJ_obj2txt(char * buf,int buf_len,const ASN1_OBJECT * aobj,int no_name)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
OBJ_txt2nid(const char * s)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
OBJ_ln2nid(const char * s)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
OBJ_sn2nid(const char * s)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 *
OBJ_bsearch_(const void * key,const void * base,int num,int size,int (* cmp)(const void *,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 *
OBJ_bsearch_ex_(const void * key,const void * base_,int num,int size,int (* cmp)(const void *,const void *),int flags)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
OBJ_create_objects(BIO * in)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
OBJ_create(const char * oid,const char * sn,const char * ln)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
OBJ_length(const ASN1_OBJECT * obj)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 *
OBJ_get0_data(const ASN1_OBJECT * obj)696 OBJ_get0_data(const ASN1_OBJECT *obj)
697 {
698 if (obj == NULL)
699 return NULL;
700
701 return obj->data;
702 }
703