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