PR: 2091
[openssl.git] / 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