wbrawner/openssl
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

This is the first of two commits (didn't want to dump them all into the

Browse source 
same one). However, the first will temporarily break things until the
second comes through. :-)

The safestack.h handling was mapping compare callbacks that externally
are of the type (int (*)(type **,type **)) into the underlying callback
type used by stack.[ch], which is (int (*)(void *,void *)). After some
degree of digging, it appears that the callback type in the underlying
stack code should use double pointers too - when the compare operations
are invoked (from sk_find and sk_sort), they are being used by bsearch
and qsort to compare two pointers to pointers. This change corrects the
prototyping (by only casting to the (void*,void*) form at the moment
it is needed by bsearch and qsort) and makes the mapping in safestack.h
more transparent. It also changes from "void*" to "char*" to stay in
keeping with stack.[ch]'s assumed base type of "char".

Also - the "const" situation was that safestack.h was throwing away
"const"s, and to compound the problem - a close examination of stack.c
showed that (const char **) is not really achieving what it is supposed
to when the callback is being invoked, what is needed is
(const char * const *). So the underlying stack.[ch] and the mapping
macros in safestack.h have all been altered to correct this.

What will follow are the vast quantities of "const" corrections required
in stack-dependant code that was being let "slip" through when
safestack.h was discarding "const"s. These now all come up as compiler
warnings.
This commit is contained in:
Geoff Thorpe 2000-06-01 02:15:40 +00:00
parent f3e9b338e0
commit 7bb7043580
3 changed files with 45 additions and 20 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

24
crypto/stack/safestack.h
View file

@ -65,7 +65,8 @@ STACK_OF(type) \
{ \
STACK stack; \
}; \
STACK_OF(type) *sk_##type##_new(int (*cmp)(type **,type **)); \
STACK_OF(type) *sk_##type##_new(int (*cmp)(const type * const *, \
const type * const *)); \
STACK_OF(type) *sk_##type##_new_null(void); \
void sk_##type##_free(STACK_OF(type) *sk); \
int sk_##type##_num(const STACK_OF(type) *sk); \
@ -76,10 +77,11 @@ int sk_##type##_push(STACK_OF(type) *sk,type *v); \
int sk_##type##_unshift(STACK_OF(type) *sk,type *v); \
int sk_##type##_find(STACK_OF(type) *sk,type *v); \
type *sk_##type##_delete(STACK_OF(type) *sk,int n); \
void sk_##type##_delete_ptr(STACK_OF(type) *sk,type *v); \
type *sk_##type##_delete_ptr(STACK_OF(type) *sk,type *v); \
int sk_##type##_insert(STACK_OF(type) *sk,type *v,int n); \
int (*sk_##type##_set_cmp_func(STACK_OF(type) *sk, \
int (*cmp)(type **,type **)))(type **,type **); \
int (*cmp)(const type * const *,const type * const *))) \
(const type * const *,const type * const *); \
STACK_OF(type) *sk_##type##_dup(STACK_OF(type) *sk); \
void sk_##type##_pop_free(STACK_OF(type) *sk,void (*func)(type *)); \
type *sk_##type##_shift(STACK_OF(type) *sk); \
@ -87,8 +89,10 @@ type *sk_##type##_pop(STACK_OF(type) *sk); \
void sk_##type##_sort(STACK_OF(type) *sk);
#define IMPLEMENT_STACK_OF(type) \
STACK_OF(type) *sk_##type##_new(int (*cmp)(type **,type **)) \
{ return (STACK_OF(type) *)sk_new((int (*)())cmp); } \
STACK_OF(type) *sk_##type##_new(int (*cmp)(const type * const *, \
const type * const *)) \
{ return (STACK_OF(type) *)sk_new( \
(int (*)(const char * const *,const char * const *))cmp); } \
STACK_OF(type) *sk_##type##_new_null() \
{ return (STACK_OF(type) *)sk_new_null(); } \
void sk_##type##_free(STACK_OF(type) *sk) \
@ -109,13 +113,15 @@ int sk_##type##_find(STACK_OF(type) *sk,type *v) \
{ return sk_find((STACK *)sk,(char *)v); } \
type *sk_##type##_delete(STACK_OF(type) *sk,int n) \
{ return (type *)sk_delete((STACK *)sk,n); } \
void sk_##type##_delete_ptr(STACK_OF(type) *sk,type *v) \
{ sk_delete_ptr((STACK *)sk,(char *)v); } \
type *sk_##type##_delete_ptr(STACK_OF(type) *sk,type *v) \
{ return (type *)sk_delete_ptr((STACK *)sk,(char *)v); } \
int sk_##type##_insert(STACK_OF(type) *sk,type *v,int n) \
{ return sk_insert((STACK *)sk,(char *)v,n); } \
int (*sk_##type##_set_cmp_func(STACK_OF(type) *sk, \
int (*cmp)(type **,type **)))(type **,type **) \
{ return (int (*)(type **,type **))sk_set_cmp_func((STACK *)sk,(int(*)(const void *, const void *))cmp); } \
int (*cmp)(const type * const *,const type * const *))) \
(const type * const *,const type * const *) \
{ return (int (*)(const type * const *,const type * const *))sk_set_cmp_func( \
(STACK *)sk, (int(*)(const char * const *, const char * const *))cmp); } \
STACK_OF(type) *sk_##type##_dup(STACK_OF(type) *sk) \
{ return (STACK_OF(type) *)sk_dup((STACK *)sk); } \
void sk_##type##_pop_free(STACK_OF(type) *sk,void (*func)(type *)) \

29
crypto/stack/stack.c
View file

@ -76,9 +76,10 @@ const char *STACK_version="Stack" OPENSSL_VERSION_PTEXT;
#include <errno.h>
int (*sk_set_cmp_func(STACK *sk, int (*c)(const void *,const void *)))(const void *, const void *)
int (*sk_set_cmp_func(STACK *sk, int (*c)(const char * const *,const char * const *)))
(const char * const *, const char * const *)
{
int (*old)(const void *,const void *)=sk->comp;
int (*old)(const char * const *,const char * const *)=sk->comp;
if (sk->comp != c)
sk->sorted=0;
@ -108,7 +109,7 @@ err:
return(NULL);
}
STACK *sk_new(int (*c)(const void *, const void *))
STACK *sk_new(int (*c)(const char * const *, const char * const *))
{
STACK *ret;
int i;
@ -218,13 +219,24 @@ int sk_find(STACK *st, char *data)
}
sk_sort(st);
if (data == NULL) return(-1);
comp_func=st->comp;
/* This (and the "qsort" below) are the two places in OpenSSL
* where we need to convert from our standard (type **,type **)
* compare callback type to the (void *,void *) type required by
* bsearch. However, the "data" it is being called(back) with are
* not (type *) pointers, but the *pointers* to (type *) pointers,
* so we get our extra level of pointer dereferencing that way. */
comp_func=(int (*)(const void *,const void *))(st->comp);
r=(char **)bsearch(&data,(char *)st->data,
st->num,sizeof(char *), comp_func);
if (r == NULL) return(-1);
i=(int)(r-st->data);
for ( ; i>0; i--)
if ((*st->comp)(&(st->data[i-1]),&data) < 0)
/* This needs a cast because the type being pointed to from
* the "&" expressions are (char *) rather than (const char *).
* For an explanation, read:
* http://www.eskimo.com/~scs/C-faq/q11.10.html :-) */
if ((*st->comp)((const char * const *)&(st->data[i-1]),
(const char * const *)&data) < 0)
break;
return(i);
}
@ -303,7 +315,12 @@ void sk_sort(STACK *st)
{
int (*comp_func)(const void *,const void *);
comp_func=st->comp;
/* same comment as in sk_find ... previously st->comp was declared
* as a (void*,void*) callback type, but this made the population
* of the callback pointer illogical - our callbacks compare
* type** with type**, so we leave the casting until absolutely
* necessary (ie. "now"). */
comp_func=(int (*)(const void *,const void *))(st->comp);
qsort(st->data,st->num,sizeof(char *), comp_func);
st->sorted=1;
}

12
crypto/stack/stack.h
View file

@ -70,11 +70,11 @@ typedef struct stack_st
int sorted;
int num_alloc;
int (*comp)(const void *, const void *);
int (*comp)(const char * const *, const char * const *);
} STACK;
#define sk_new_null() sk_new(NULL)
#define sk_new_null() sk_new((int (*)(const char * const *, \
const char * const *))NULL)
#define M_sk_num(sk) ((sk) ? (sk)->num:-1)
#define M_sk_value(sk,n) ((sk) ? (sk)->data[n] : NULL)
@ -84,7 +84,7 @@ char *sk_value(const STACK *, int);
char *sk_set(STACK *, int, char *);
STACK *sk_new(int (*cmp)(const void *, const void *));
STACK *sk_new(int (*cmp)(const char * const *, const char * const *));
void sk_free(STACK *);
void sk_pop_free(STACK *st, void (*func)(void *));
int sk_insert(STACK *sk,char *data,int where);
@ -96,7 +96,9 @@ int sk_unshift(STACK *st,char *data);
char *sk_shift(STACK *st);
char *sk_pop(STACK *st);
void sk_zero(STACK *st);
int (*sk_set_cmp_func(STACK *sk, int (*c)(const void *,const void *)))(const void *, const void *);
int (*sk_set_cmp_func(STACK *sk, int (*c)(const char * const *,
const char * const *)))
(const char * const *, const char * const *);
STACK *sk_dup(STACK *st);
void sk_sort(STACK *st);