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