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 */
25DECLARE_LHASH_OF(OBJ_NAME);
26static LHASH_OF(OBJ_NAME) *names_lh=NULL;
27static int names_type_num=OBJ_NAME_TYPE_NUM;
28
29typedef 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
36DECLARE_STACK_OF(NAME_FUNCS)
37IMPLEMENT_STACK_OF(NAME_FUNCS)
38
39static 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); */
46static unsigned long obj_name_hash(const void *a_void);
47/* static int obj_name_cmp(OBJ_NAME *a,OBJ_NAME *b); */
48static int obj_name_cmp(const void *a_void,const void *b_void);
49
50static IMPLEMENT_LHASH_HASH_FN(obj_name, OBJ_NAME)
51static IMPLEMENT_LHASH_COMP_FN(obj_name, OBJ_NAME)
52
53int 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
62int 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) */
115static 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) */
137static 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
155const 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
185int 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
233int 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
262struct doall
263	{
264	int type;
265	void (*fn)(const OBJ_NAME *,void *arg);
266	void *arg;
267	};
268
269static 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
275static IMPLEMENT_LHASH_DOALL_ARG_FN(do_all_fn, const OBJ_NAME, struct doall)
276
277void 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
289struct doall_sorted
290	{
291	int type;
292	int n;
293	const OBJ_NAME **names;
294	};
295
296static 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
306static 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
314void 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
333static int free_type;
334
335static 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
344static IMPLEMENT_LHASH_DOALL_FN(names_lh_free, OBJ_NAME)
345
346static void name_funcs_free(NAME_FUNCS *ptr)
347	{
348	OPENSSL_free(ptr);
349	}
350
351void 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
373