X-Git-Url: https://git.librecmc.org/?a=blobdiff_plain;f=crypto%2Fobjects%2Fo_names.c;h=84380a96a98c71109ed821c522f4c500363f1a18;hb=df4c395c6d344bff7f73f8eddaaf4dbd9889a014;hp=a3b05d2dee9ed16d9d0ec228eef7d62b0a77a2f9;hpb=f9e6fac357a42cdcc1b838582825aedad7c920e4;p=oweals%2Fopenssl.git diff --git a/crypto/objects/o_names.c b/crypto/objects/o_names.c index a3b05d2dee..84380a96a9 100644 --- a/crypto/objects/o_names.c +++ b/crypto/objects/o_names.c @@ -2,84 +2,130 @@ #include #include -#include "lhash.h" -#include "objects.h" +#include +#include +#include +#include +#include + +/* Later versions of DEC C has started to add lnkage information to certain + * functions, which makes it tricky to use them as values to regular function + * pointers. One way is to define a macro that takes care of casting them + * correctly. + */ +#ifdef OPENSSL_SYS_VMS_DECC +# define OPENSSL_strcmp (int (*)(const char *,const char *))strcmp +#else +# define OPENSSL_strcmp strcmp +#endif /* I use the ex_data stuff to manage the identifiers for the obj_name_types * that applications may define. I only really use the free function field. */ -static LHASH *names_lh=NULL; +DECLARE_LHASH_OF(OBJ_NAME); +static LHASH_OF(OBJ_NAME) *names_lh=NULL; static int names_type_num=OBJ_NAME_TYPE_NUM; -static STACK *names_cmp=NULL; -static STACK *names_hash=NULL; -static STACK *names_free=NULL; -static unsigned long obj_name_hash(OBJ_NAME *a); -static int obj_name_cmp(OBJ_NAME *a,OBJ_NAME *b); +typedef struct name_funcs_st + { + unsigned long (*hash_func)(const char *name); + int (*cmp_func)(const char *a,const char *b); + void (*free_func)(const char *, int, const char *); + } NAME_FUNCS; + +DECLARE_STACK_OF(NAME_FUNCS) +IMPLEMENT_STACK_OF(NAME_FUNCS) + +static STACK_OF(NAME_FUNCS) *name_funcs_stack; + +/* The LHASH callbacks now use the raw "void *" prototypes and do per-variable + * casting in the functions. This prevents function pointer casting without the + * need for macro-generated wrapper functions. */ + +/* static unsigned long obj_name_hash(OBJ_NAME *a); */ +static unsigned long obj_name_hash(const void *a_void); +/* static int obj_name_cmp(OBJ_NAME *a,OBJ_NAME *b); */ +static int obj_name_cmp(const void *a_void,const void *b_void); + +static IMPLEMENT_LHASH_HASH_FN(obj_name, OBJ_NAME) +static IMPLEMENT_LHASH_COMP_FN(obj_name, OBJ_NAME) -int OBJ_NAME_init() +int OBJ_NAME_init(void) { if (names_lh != NULL) return(1); MemCheck_off(); - names_lh=lh_new(obj_name_hash,obj_name_cmp); + names_lh=lh_OBJ_NAME_new(); MemCheck_on(); return(names_lh != NULL); } -int OBJ_NAME_new_index(hash_func,cmp_func,free_func) -unsigned long (*hash_func)(); -int (*cmp_func)(); -void (*free_func)(); +int OBJ_NAME_new_index(unsigned long (*hash_func)(const char *), + int (*cmp_func)(const char *, const char *), + void (*free_func)(const char *, int, const char *)) { int ret; int i; + NAME_FUNCS *name_funcs; - if (names_free == NULL) + if (name_funcs_stack == NULL) { MemCheck_off(); - names_hash=sk_new_null(); - names_cmp=sk_new_null(); - names_free=sk_new_null(); + name_funcs_stack=sk_NAME_FUNCS_new_null(); MemCheck_on(); } - if ((names_free == NULL) || (names_hash == NULL) || (names_cmp == NULL)) + if ((name_funcs_stack == NULL)) { /* ERROR */ return(0); } ret=names_type_num; names_type_num++; - for (i=sk_num(names_free); ihash_func = lh_strhash; + name_funcs->cmp_func = OPENSSL_strcmp; + name_funcs->free_func = 0; /* NULL is often declared to + * ((void *)0), which according + * to Compaq C is not really + * compatible with a function + * pointer. -- Richard Levitte*/ + MemCheck_off(); + sk_NAME_FUNCS_push(name_funcs_stack,name_funcs); MemCheck_on(); } + name_funcs = sk_NAME_FUNCS_value(name_funcs_stack, ret); if (hash_func != NULL) - sk_value(names_hash,ret)=(char *)hash_func; + name_funcs->hash_func = hash_func; if (cmp_func != NULL) - sk_value(names_cmp,ret)= (char *)cmp_func; + name_funcs->cmp_func = cmp_func; if (free_func != NULL) - sk_value(names_free,ret)=(char *)free_func; + name_funcs->free_func = free_func; return(ret); } -static int obj_name_cmp(a,b) -OBJ_NAME *a; -OBJ_NAME *b; +/* static int obj_name_cmp(OBJ_NAME *a, OBJ_NAME *b) */ +static int obj_name_cmp(const void *a_void, const void *b_void) { int ret; - int (*cmp)(); + const OBJ_NAME *a = (const OBJ_NAME *)a_void; + const OBJ_NAME *b = (const OBJ_NAME *)b_void; ret=a->type-b->type; if (ret == 0) { - if ((names_cmp != NULL) && (sk_num(names_cmp) > a->type)) + if ((name_funcs_stack != NULL) + && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type)) { - cmp=(int (*)())sk_value(names_cmp,a->type); - ret=cmp(a->name,b->name); + ret=sk_NAME_FUNCS_value(name_funcs_stack, + a->type)->cmp_func(a->name,b->name); } else ret=strcmp(a->name,b->name); @@ -87,16 +133,16 @@ OBJ_NAME *b; return(ret); } -static unsigned long obj_name_hash(a) -OBJ_NAME *a; +/* static unsigned long obj_name_hash(OBJ_NAME *a) */ +static unsigned long obj_name_hash(const void *a_void) { unsigned long ret; - unsigned long (*hash)(); + const OBJ_NAME *a = (const OBJ_NAME *)a_void; - if ((names_hash != NULL) && (sk_num(names_hash) > a->type)) + if ((name_funcs_stack != NULL) && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type)) { - hash=(unsigned long (*)())sk_value(names_hash,a->type); - ret=hash(a->name); + ret=sk_NAME_FUNCS_value(name_funcs_stack, + a->type)->hash_func(a->name); } else { @@ -106,9 +152,7 @@ OBJ_NAME *a; return(ret); } -char *OBJ_NAME_get(name,type) -char *name; -int type; +const char *OBJ_NAME_get(const char *name, int type) { OBJ_NAME on,*ret; int num=0,alias; @@ -123,8 +167,8 @@ int type; on.type=type; for (;;) - { - ret=(OBJ_NAME *)lh_retrieve(names_lh,(char *)&on); + { + ret=lh_OBJ_NAME_retrieve(names_lh,&on); if (ret == NULL) return(NULL); if ((ret->alias) && !alias) { @@ -138,12 +182,8 @@ int type; } } -int OBJ_NAME_add(name,type,data) -char *name; -int type; -char *data; +int OBJ_NAME_add(const char *name, int type, const char *data) { - void (*f)(); OBJ_NAME *onp,*ret; int alias; @@ -152,7 +192,7 @@ char *data; alias=type&OBJ_NAME_ALIAS; type&= ~OBJ_NAME_ALIAS; - onp=(OBJ_NAME *)Malloc(sizeof(OBJ_NAME)); + onp=(OBJ_NAME *)OPENSSL_malloc(sizeof(OBJ_NAME)); if (onp == NULL) { /* ERROR */ @@ -164,20 +204,24 @@ char *data; onp->type=type; onp->data=data; - ret=(OBJ_NAME *)lh_insert(names_lh,(char *)onp); + ret=lh_OBJ_NAME_insert(names_lh,onp); if (ret != NULL) { /* free things */ - if ((names_free != NULL) && (sk_num(names_free) > ret->type)) + if ((name_funcs_stack != NULL) && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type)) { - f=(void (*)())sk_value(names_free,ret->type); - f(ret->name,ret->type,ret->data); + /* XXX: I'm not sure I understand why the free + * function should get three arguments... + * -- Richard Levitte + */ + sk_NAME_FUNCS_value(name_funcs_stack, + ret->type)->free_func(ret->name,ret->type,ret->data); } - Free((char *)ret); + OPENSSL_free(ret); } else { - if (lh_error(names_lh)) + if (lh_OBJ_NAME_error(names_lh)) { /* ERROR */ return(0); @@ -186,72 +230,143 @@ char *data; return(1); } -int OBJ_NAME_remove(name,type) -char *name; -int type; +int OBJ_NAME_remove(const char *name, int type) { OBJ_NAME on,*ret; - void (*f)(); if (names_lh == NULL) return(0); type&= ~OBJ_NAME_ALIAS; on.name=name; on.type=type; - ret=(OBJ_NAME *)lh_delete(names_lh,(char *)&on); + ret=lh_OBJ_NAME_delete(names_lh,&on); if (ret != NULL) { /* free things */ - if ((names_free != NULL) && (sk_num(names_free) > type)) + if ((name_funcs_stack != NULL) && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type)) { - f=(void (*)())sk_value(names_free,type); - f(ret->name,ret->type,ret->data); + /* XXX: I'm not sure I understand why the free + * function should get three arguments... + * -- Richard Levitte + */ + sk_NAME_FUNCS_value(name_funcs_stack, + ret->type)->free_func(ret->name,ret->type,ret->data); } - Free((char *)ret); + OPENSSL_free(ret); return(1); } else return(0); } +struct doall + { + int type; + void (*fn)(const OBJ_NAME *,void *arg); + void *arg; + }; + +static void do_all_fn_doall_arg(const OBJ_NAME *name,struct doall *d) + { + if(name->type == d->type) + d->fn(name,d->arg); + } + +static IMPLEMENT_LHASH_DOALL_ARG_FN(do_all_fn, const OBJ_NAME, struct doall) + +void OBJ_NAME_do_all(int type,void (*fn)(const OBJ_NAME *,void *arg),void *arg) + { + struct doall d; + + d.type=type; + d.fn=fn; + d.arg=arg; + + lh_OBJ_NAME_doall_arg(names_lh, LHASH_DOALL_ARG_FN(do_all_fn), + struct doall, &d); + } + +struct doall_sorted + { + int type; + int n; + const OBJ_NAME **names; + }; + +static void do_all_sorted_fn(const OBJ_NAME *name,void *d_) + { + struct doall_sorted *d=d_; + + if(name->type != d->type) + return; + + d->names[d->n++]=name; + } + +static int do_all_sorted_cmp(const void *n1_,const void *n2_) + { + const OBJ_NAME * const *n1=n1_; + const OBJ_NAME * const *n2=n2_; + + return strcmp((*n1)->name,(*n2)->name); + } + +void OBJ_NAME_do_all_sorted(int type,void (*fn)(const OBJ_NAME *,void *arg), + void *arg) + { + struct doall_sorted d; + int n; + + d.type=type; + d.names=OPENSSL_malloc(lh_OBJ_NAME_num_items(names_lh)*sizeof *d.names); + d.n=0; + OBJ_NAME_do_all(type,do_all_sorted_fn,&d); + + qsort((void *)d.names,d.n,sizeof *d.names,do_all_sorted_cmp); + + for(n=0 ; n < d.n ; ++n) + fn(d.names[n],arg); + + OPENSSL_free((void *)d.names); + } + static int free_type; -static void names_lh_free(onp,type) -OBJ_NAME *onp; +static void names_lh_free_doall(OBJ_NAME *onp) { - if(onp == NULL) - return; + if (onp == NULL) + return; - if ((free_type < 0) || (free_type == onp->type)) - { + if (free_type < 0 || free_type == onp->type) OBJ_NAME_remove(onp->name,onp->type); - } } -void OBJ_NAME_cleanup(type) -int type; +static IMPLEMENT_LHASH_DOALL_FN(names_lh_free, OBJ_NAME) + +static void name_funcs_free(NAME_FUNCS *ptr) + { + OPENSSL_free(ptr); + } + +void OBJ_NAME_cleanup(int type) { unsigned long down_load; if (names_lh == NULL) return; free_type=type; - down_load=names_lh->down_load; - names_lh->down_load=0; + down_load=lh_OBJ_NAME_down_load(names_lh); + lh_OBJ_NAME_down_load(names_lh)=0; - lh_doall(names_lh,names_lh_free); + lh_OBJ_NAME_doall(names_lh,LHASH_DOALL_FN(names_lh_free)); if (type < 0) { - lh_free(names_lh); - sk_free(names_hash); - sk_free(names_cmp); - sk_free(names_free); + lh_OBJ_NAME_free(names_lh); + sk_NAME_FUNCS_pop_free(name_funcs_stack,name_funcs_free); names_lh=NULL; - names_hash=NULL; - names_cmp=NULL; - names_free=NULL; + name_funcs_stack = NULL; } else - names_lh->down_load=down_load; + lh_OBJ_NAME_down_load(names_lh)=down_load; }