release/src/router/openssl/crypto/objects/o_names.c

   1 #include <stdio.h>
   2 #include <stdlib.h>
   3 #include <string.h>
   4
   5 #include <openssl/err.h>
   6 #include <openssl/lhash.h>
   7 #include <openssl/objects.h>
   8 #include <openssl/safestack.h>
   9 #include <openssl/e_os2.h>
  10
  11 /* Later versions of DEC C has started to add lnkage information to certain
  12  * functions, which makes it tricky to use them as values to regular function
  13  * pointers.  One way is to define a macro that takes care of casting them
  14  * correctly.
  15  */
  16 #ifdef OPENSSL_SYS_VMS_DECC
  17 # define OPENSSL_strcmp (int (*)(const char *,const char *))strcmp
  18 #else
  19 # define OPENSSL_strcmp strcmp
  20 #endif
  21
  22 /* I use the ex_data stuff to manage the identifiers for the obj_name_types
  23  * that applications may define.  I only really use the free function field.
  24  */
  25 DECLARE_LHASH_OF(OBJ_NAME);
  26 static LHASH_OF(OBJ_NAME) *names_lh=NULL;
  27 static int names_type_num=OBJ_NAME_TYPE_NUM;
  28
  29 typedef struct name_funcs_st
  30         {
  31         unsigned long (*hash_func)(const char *name);
  32         int (*cmp_func)(const char *a,const char *b);
  33         void (*free_func)(const char *, int, const char *);
  34         } NAME_FUNCS;
  35
  36 DECLARE_STACK_OF(NAME_FUNCS)
  37 IMPLEMENT_STACK_OF(NAME_FUNCS)
  38
  39 static STACK_OF(NAME_FUNCS) *name_funcs_stack;
  40
  41 /* The LHASH callbacks now use the raw "void *" prototypes and do per-variable
  42  * casting in the functions. This prevents function pointer casting without the
  43  * need for macro-generated wrapper functions. */
  44
  45 /* static unsigned long obj_name_hash(OBJ_NAME *a); */
  46 static unsigned long obj_name_hash(const void *a_void);
  47 /* static int obj_name_cmp(OBJ_NAME *a,OBJ_NAME *b); */
  48 static int obj_name_cmp(const void *a_void,const void *b_void);
  49
  50 static IMPLEMENT_LHASH_HASH_FN(obj_name, OBJ_NAME)
  51 static IMPLEMENT_LHASH_COMP_FN(obj_name, OBJ_NAME)
  52
  53 int OBJ_NAME_init(void)
  54         {
  55         if (names_lh != NULL) return(1);
  56         MemCheck_off();
  57         names_lh=lh_OBJ_NAME_new();
  58         MemCheck_on();
  59         return(names_lh != NULL);
  60         }
  61
  62 int OBJ_NAME_new_index(unsigned long (*hash_func)(const char *),
  63         int (*cmp_func)(const char *, const char *),
  64         void (*free_func)(const char *, int, const char *))
  65         {
  66         int ret;
  67         int i;
  68         NAME_FUNCS *name_funcs;
  69
  70         if (name_funcs_stack == NULL)
  71                 {
  72                 MemCheck_off();
  73                 name_funcs_stack=sk_NAME_FUNCS_new_null();
  74                 MemCheck_on();
  75                 }
  76         if (name_funcs_stack == NULL)
  77                 {
  78                 /* ERROR */
  79                 return(0);
  80                 }
  81         ret=names_type_num;
  82         names_type_num++;
  83         for (i=sk_NAME_FUNCS_num(name_funcs_stack); i<names_type_num; i++)
  84                 {
  85                 MemCheck_off();
  86                 name_funcs = OPENSSL_malloc(sizeof(NAME_FUNCS));
  87                 MemCheck_on();
  88                 if (!name_funcs)
  89                         {
  90                         OBJerr(OBJ_F_OBJ_NAME_NEW_INDEX,ERR_R_MALLOC_FAILURE);
  91                         return(0);
  92                         }
  93                 name_funcs->hash_func = lh_strhash;
  94                 name_funcs->cmp_func = OPENSSL_strcmp;
  95                 name_funcs->free_func = 0; /* NULL is often declared to
  96                                                 * ((void *)0), which according
  97                                                 * to Compaq C is not really
  98                                                 * compatible with a function
  99                                                 * pointer.      -- Richard Levitte*/
 100                 MemCheck_off();
 101                 sk_NAME_FUNCS_push(name_funcs_stack,name_funcs);
 102                 MemCheck_on();
 103                 }
 104         name_funcs = sk_NAME_FUNCS_value(name_funcs_stack, ret);
 105         if (hash_func != NULL)
 106                 name_funcs->hash_func = hash_func;
 107         if (cmp_func != NULL)
 108                 name_funcs->cmp_func = cmp_func;
 109         if (free_func != NULL)
 110                 name_funcs->free_func = free_func;
 111         return(ret);
 112         }
 113
 114 /* static int obj_name_cmp(OBJ_NAME *a, OBJ_NAME *b) */
 115 static int obj_name_cmp(const void *a_void, const void *b_void)
 116         {
 117         int ret;
 118         const OBJ_NAME *a = (const OBJ_NAME *)a_void;
 119         const OBJ_NAME *b = (const OBJ_NAME *)b_void;
 120
 121         ret=a->type-b->type;
 122         if (ret == 0)
 123                 {
 124                 if ((name_funcs_stack != NULL)
 125                         && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type))
 126                         {
 127                         ret=sk_NAME_FUNCS_value(name_funcs_stack,
 128                                 a->type)->cmp_func(a->name,b->name);
 129                         }
 130                 else
 131                         ret=strcmp(a->name,b->name);
 132                 }
 133         return(ret);
 134         }
 135
 136 /* static unsigned long obj_name_hash(OBJ_NAME *a) */
 137 static unsigned long obj_name_hash(const void *a_void)
 138         {
 139         unsigned long ret;
 140         const OBJ_NAME *a = (const OBJ_NAME *)a_void;
 141
 142         if ((name_funcs_stack != NULL) && (sk_NAME_FUNCS_num(name_funcs_stack) > a->type))
 143                 {
 144                 ret=sk_NAME_FUNCS_value(name_funcs_stack,
 145                         a->type)->hash_func(a->name);
 146                 }
 147         else
 148                 {
 149                 ret=lh_strhash(a->name);
 150                 }
 151         ret^=a->type;
 152         return(ret);
 153         }
 154
 155 const char *OBJ_NAME_get(const char *name, int type)
 156         {
 157         OBJ_NAME on,*ret;
 158         int num=0,alias;
 159
 160         if (name == NULL) return(NULL);
 161         if ((names_lh == NULL) && !OBJ_NAME_init()) return(NULL);
 162
 163         alias=type&OBJ_NAME_ALIAS;
 164         type&= ~OBJ_NAME_ALIAS;
 165
 166         on.name=name;
 167         on.type=type;
 168
 169         for (;;)
 170         {
 171                 ret=lh_OBJ_NAME_retrieve(names_lh,&on);
 172                 if (ret == NULL) return(NULL);
 173                 if ((ret->alias) && !alias)
 174                         {
 175                         if (++num > 10) return(NULL);
 176                         on.name=ret->data;
 177                         }
 178                 else
 179                         {
 180                         return(ret->data);
 181                         }
 182                 }
 183         }
 184
 185 int OBJ_NAME_add(const char *name, int type, const char *data)
 186         {
 187         OBJ_NAME *onp,*ret;
 188         int alias;
 189
 190         if ((names_lh == NULL) && !OBJ_NAME_init()) return(0);
 191
 192         alias=type&OBJ_NAME_ALIAS;
 193         type&= ~OBJ_NAME_ALIAS;
 194
 195         onp=(OBJ_NAME *)OPENSSL_malloc(sizeof(OBJ_NAME));
 196         if (onp == NULL)
 197                 {
 198                 /* ERROR */
 199                 return(0);
 200                 }
 201
 202         onp->name=name;
 203         onp->alias=alias;
 204         onp->type=type;
 205         onp->data=data;
 206
 207         ret=lh_OBJ_NAME_insert(names_lh,onp);
 208         if (ret != NULL)
 209                 {
 210                 /* free things */
 211                 if ((name_funcs_stack != NULL) && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type))
 212                         {
 213                         /* XXX: I'm not sure I understand why the free
 214                          * function should get three arguments...
 215                          * -- Richard Levitte
 216                          */
 217                         sk_NAME_FUNCS_value(name_funcs_stack,
 218                                 ret->type)->free_func(ret->name,ret->type,ret->data);
 219                         }
 220                 OPENSSL_free(ret);
 221                 }
 222         else
 223                 {
 224                 if (lh_OBJ_NAME_error(names_lh))
 225                         {
 226                         /* ERROR */
 227                         return(0);
 228                         }
 229                 }
 230         return(1);
 231         }
 232
 233 int OBJ_NAME_remove(const char *name, int type)
 234         {
 235         OBJ_NAME on,*ret;
 236
 237         if (names_lh == NULL) return(0);
 238
 239         type&= ~OBJ_NAME_ALIAS;
 240         on.name=name;
 241         on.type=type;
 242         ret=lh_OBJ_NAME_delete(names_lh,&on);
 243         if (ret != NULL)
 244                 {
 245                 /* free things */
 246                 if ((name_funcs_stack != NULL) && (sk_NAME_FUNCS_num(name_funcs_stack) > ret->type))
 247                         {
 248                         /* XXX: I'm not sure I understand why the free
 249                          * function should get three arguments...
 250                          * -- Richard Levitte
 251                          */
 252                         sk_NAME_FUNCS_value(name_funcs_stack,
 253                                 ret->type)->free_func(ret->name,ret->type,ret->data);
 254                         }
 255                 OPENSSL_free(ret);
 256                 return(1);
 257                 }
 258         else
 259                 return(0);
 260         }
 261
 262 struct doall
 263         {
 264         int type;
 265         void (*fn)(const OBJ_NAME *,void *arg);
 266         void *arg;
 267         };
 268
 269 static void do_all_fn_doall_arg(const OBJ_NAME *name,struct doall *d)
 270         {
 271         if(name->type == d->type)
 272                 d->fn(name,d->arg);
 273         }
 274
 275 static IMPLEMENT_LHASH_DOALL_ARG_FN(do_all_fn, const OBJ_NAME, struct doall)
 276
 277 void OBJ_NAME_do_all(int type,void (*fn)(const OBJ_NAME *,void *arg),void *arg)
 278         {
 279         struct doall d;
 280
 281         d.type=type;
 282         d.fn=fn;
 283         d.arg=arg;
 284
 285         lh_OBJ_NAME_doall_arg(names_lh, LHASH_DOALL_ARG_FN(do_all_fn),
 286                               struct doall, &d);
 287         }
 288
 289 struct doall_sorted
 290         {
 291         int type;
 292         int n;
 293         const OBJ_NAME **names;
 294         };
 295
 296 static void do_all_sorted_fn(const OBJ_NAME *name,void *d_)
 297         {
 298         struct doall_sorted *d=d_;
 299
 300         if(name->type != d->type)
 301                 return;
 302
 303         d->names[d->n++]=name;
 304         }
 305
 306 static int do_all_sorted_cmp(const void *n1_,const void *n2_)
 307         {
 308         const OBJ_NAME * const *n1=n1_;
 309         const OBJ_NAME * const *n2=n2_;
 310
 311         return strcmp((*n1)->name,(*n2)->name);
 312         }
 313
 314 void OBJ_NAME_do_all_sorted(int type,void (*fn)(const OBJ_NAME *,void *arg),
 315                                 void *arg)
 316         {
 317         struct doall_sorted d;
 318         int n;
 319
 320         d.type=type;
 321         d.names=OPENSSL_malloc(lh_OBJ_NAME_num_items(names_lh)*sizeof *d.names);
 322         d.n=0;
 323         OBJ_NAME_do_all(type,do_all_sorted_fn,&d);
 324
 325         qsort((void *)d.names,d.n,sizeof *d.names,do_all_sorted_cmp);
 326
 327         for(n=0 ; n < d.n ; ++n)
 328                 fn(d.names[n],arg);
 329
 330         OPENSSL_free((void *)d.names);
 331         }
 332
 333 static int free_type;
 334
 335 static void names_lh_free_doall(OBJ_NAME *onp)
 336         {
 337         if (onp == NULL)
 338                 return;
 339
 340         if (free_type < 0 || free_type == onp->type)
 341                 OBJ_NAME_remove(onp->name,onp->type);
 342         }
 343
 344 static IMPLEMENT_LHASH_DOALL_FN(names_lh_free, OBJ_NAME)
 345
 346 static void name_funcs_free(NAME_FUNCS *ptr)
 347         {
 348         OPENSSL_free(ptr);
 349         }
 350
 351 void OBJ_NAME_cleanup(int type)
 352         {
 353         unsigned long down_load;
 354
 355         if (names_lh == NULL) return;
 356
 357         free_type=type;
 358         down_load=lh_OBJ_NAME_down_load(names_lh);
 359         lh_OBJ_NAME_down_load(names_lh)=0;
 360
 361         lh_OBJ_NAME_doall(names_lh,LHASH_DOALL_FN(names_lh_free));
 362         if (type < 0)
 363                 {
 364                 lh_OBJ_NAME_free(names_lh);
 365                 sk_NAME_FUNCS_pop_free(name_funcs_stack,name_funcs_free);
 366                 names_lh=NULL;
 367                 name_funcs_stack = NULL;
 368                 }
 369         else
 370                 lh_OBJ_NAME_down_load(names_lh)=down_load;
 371         }
 372