generic-library/openssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

PR: 1996

Browse Source 
Submitted by: steve@openssl.org

Change conflicting name "BLOCK" to "OPENSSL_BLOCK".
This commit is contained in:
Dr. Stephen Henson 2009-07-27 21:21:25 +00:00
parent 4386445c18
commit ec6158d029
4 changed files with 54 additions and 52 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
crypto/asn1/a_set.c
View File

@ -85,7 +85,7 @@ static int SetBlobCmp(const void *elem1, const void *elem2 )
} }
/* int is_set: if TRUE, then sort the contents (i.e. it isn't a SEQUENCE) */ /* int is_set: if TRUE, then sort the contents (i.e. it isn't a SEQUENCE) */
int i2d_ASN1_SET(STACK_OF(BLOCK) *a, unsigned char **pp, int i2d_ASN1_SET(STACK_OF(OPENSSL_BLOCK) *a, unsigned char **pp,
i2d_of_void *i2d, int ex_tag, int ex_class, i2d_of_void *i2d, int ex_tag, int ex_class,
int is_set) int is_set)
{ {
@ -97,8 +97,8 @@ int i2d_ASN1_SET(STACK_OF(BLOCK) *a, unsigned char **pp,
int totSize; int totSize;
if (a == NULL) return(0); if (a == NULL) return(0);
for (i=sk_BLOCK_num(a)-1; i>=0; i--) for (i=sk_OPENSSL_BLOCK_num(a)-1; i>=0; i--)
ret+=i2d(sk_BLOCK_value(a,i),NULL); ret+=i2d(sk_OPENSSL_BLOCK_value(a,i),NULL);
r=ASN1_object_size(1,ret,ex_tag); r=ASN1_object_size(1,ret,ex_tag);
if (pp == NULL) return(r); if (pp == NULL) return(r);
@ -109,10 +109,10 @@ int i2d_ASN1_SET(STACK_OF(BLOCK) *a, unsigned char **pp,
/* And then again by Ben */ /* And then again by Ben */
/* And again by Steve */ /* And again by Steve */
if(!is_set || (sk_BLOCK_num(a) < 2)) if(!is_set || (sk_OPENSSL_BLOCK_num(a) < 2))
{ {
for (i=0; i<sk_BLOCK_num(a); i++) for (i=0; i<sk_OPENSSL_BLOCK_num(a); i++)
i2d(sk_BLOCK_value(a,i),&p); i2d(sk_OPENSSL_BLOCK_value(a,i),&p);
*pp=p; *pp=p;
return(r); return(r);
@ -120,17 +120,17 @@ int i2d_ASN1_SET(STACK_OF(BLOCK) *a, unsigned char **pp,
pStart = p; /* Catch the beg of Setblobs*/ pStart = p; /* Catch the beg of Setblobs*/
/* In this array we will store the SET blobs */ /* In this array we will store the SET blobs */
rgSetBlob = OPENSSL_malloc(sk_BLOCK_num(a) * sizeof(MYBLOB)); rgSetBlob = OPENSSL_malloc(sk_OPENSSL_BLOCK_num(a) * sizeof(MYBLOB));
if (rgSetBlob == NULL) if (rgSetBlob == NULL)
{ {
ASN1err(ASN1_F_I2D_ASN1_SET,ERR_R_MALLOC_FAILURE); ASN1err(ASN1_F_I2D_ASN1_SET,ERR_R_MALLOC_FAILURE);
return(0); return(0);
} }
for (i=0; i<sk_BLOCK_num(a); i++) for (i=0; i<sk_OPENSSL_BLOCK_num(a); i++)
{ {
rgSetBlob[i].pbData = p; /* catch each set encode blob */ rgSetBlob[i].pbData = p; /* catch each set encode blob */
i2d(sk_BLOCK_value(a,i),&p); i2d(sk_OPENSSL_BLOCK_value(a,i),&p);
rgSetBlob[i].cbData = p - rgSetBlob[i].pbData; /* Length of this rgSetBlob[i].cbData = p - rgSetBlob[i].pbData; /* Length of this
SetBlob SetBlob
*/ */
@ -140,7 +140,7 @@ SetBlob
/* Now we have to sort the blobs. I am using a simple algo. /* Now we have to sort the blobs. I am using a simple algo.
*Sort ptrs *Copy to temp-mem *Copy from temp-mem to user-mem*/ *Sort ptrs *Copy to temp-mem *Copy from temp-mem to user-mem*/
qsort( rgSetBlob, sk_BLOCK_num(a), sizeof(MYBLOB), SetBlobCmp); qsort( rgSetBlob, sk_OPENSSL_BLOCK_num(a), sizeof(MYBLOB), SetBlobCmp);
if (!(pTempMem = OPENSSL_malloc(totSize))) if (!(pTempMem = OPENSSL_malloc(totSize)))
{ {
ASN1err(ASN1_F_I2D_ASN1_SET,ERR_R_MALLOC_FAILURE); ASN1err(ASN1_F_I2D_ASN1_SET,ERR_R_MALLOC_FAILURE);
@ -149,7 +149,7 @@ SetBlob
/* Copy to temp mem */ /* Copy to temp mem */
p = pTempMem; p = pTempMem;
for(i=0; i<sk_BLOCK_num(a); ++i) for(i=0; i<sk_OPENSSL_BLOCK_num(a); ++i)
{ {
memcpy(p, rgSetBlob[i].pbData, rgSetBlob[i].cbData); memcpy(p, rgSetBlob[i].pbData, rgSetBlob[i].cbData);
p += rgSetBlob[i].cbData; p += rgSetBlob[i].cbData;
@ -163,17 +163,18 @@ SetBlob
return(r); return(r);
} }
STACK_OF(BLOCK) *d2i_ASN1_SET(STACK_OF(BLOCK) **a, const unsigned char **pp, STACK_OF(OPENSSL_BLOCK) *d2i_ASN1_SET(STACK_OF(OPENSSL_BLOCK) **a,
const unsigned char **pp,
long length, d2i_of_void *d2i, long length, d2i_of_void *d2i,
void (*free_func)(BLOCK), int ex_tag, void (*free_func)(OPENSSL_BLOCK), int ex_tag,
int ex_class) int ex_class)
{ {
ASN1_const_CTX c; ASN1_const_CTX c;
STACK_OF(BLOCK) *ret=NULL; STACK_OF(OPENSSL_BLOCK) *ret=NULL;
if ((a == NULL) || ((*a) == NULL)) if ((a == NULL) || ((*a) == NULL))
{ {
if ((ret=sk_BLOCK_new_null()) == NULL) if ((ret=sk_OPENSSL_BLOCK_new_null()) == NULL)
{ {
ASN1err(ASN1_F_D2I_ASN1_SET,ERR_R_MALLOC_FAILURE); ASN1err(ASN1_F_D2I_ASN1_SET,ERR_R_MALLOC_FAILURE);
goto err; goto err;
@ -221,7 +222,7 @@ STACK_OF(BLOCK) *d2i_ASN1_SET(STACK_OF(BLOCK) **a, const unsigned char **pp,
asn1_add_error(*pp,(int)(c.p- *pp)); asn1_add_error(*pp,(int)(c.p- *pp));
goto err; goto err;
} }
if (!sk_BLOCK_push(ret,s)) goto err; if (!sk_OPENSSL_BLOCK_push(ret,s)) goto err;
} }
if (a != NULL) (*a)=ret; if (a != NULL) (*a)=ret;
*pp=c.p; *pp=c.p;
@ -230,9 +231,9 @@ err:
if ((ret != NULL) && ((a == NULL) || (*a != ret))) if ((ret != NULL) && ((a == NULL) || (*a != ret)))
{ {
if (free_func != NULL) if (free_func != NULL)
sk_BLOCK_pop_free(ret,free_func); sk_OPENSSL_BLOCK_pop_free(ret,free_func);
else else
sk_BLOCK_free(ret); sk_OPENSSL_BLOCK_free(ret);
} }
return(NULL); return(NULL);
} }

13
crypto/asn1/asn1.h
View File

@ -887,12 +887,13 @@ int ASN1_TIME_check(ASN1_TIME *t);
ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t, ASN1_GENERALIZEDTIME **out); ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t, ASN1_GENERALIZEDTIME **out);
int ASN1_TIME_set_string(ASN1_TIME *s, const char *str); int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
int i2d_ASN1_SET(STACK_OF(BLOCK) *a, unsigned char **pp, int i2d_ASN1_SET(STACK_OF(OPENSSL_BLOCK) *a, unsigned char **pp,
i2d_of_void *i2d, int ex_tag, int ex_class, i2d_of_void *i2d, int ex_tag, int ex_class,
int is_set); int is_set);
STACK_OF(BLOCK) *d2i_ASN1_SET(STACK_OF(BLOCK) **a, const unsigned char **pp, STACK_OF(OPENSSL_BLOCK) *d2i_ASN1_SET(STACK_OF(OPENSSL_BLOCK) **a,
const unsigned char **pp,
long length, d2i_of_void *d2i, long length, d2i_of_void *d2i,
void (*free_func)(BLOCK), int ex_tag, void (*free_func)(OPENSSL_BLOCK), int ex_tag,
int ex_class); int ex_class);
#ifndef OPENSSL_NO_BIO #ifndef OPENSSL_NO_BIO
@ -1045,9 +1046,9 @@ int ASN1_TYPE_set_int_octetstring(ASN1_TYPE *a, long num,
int ASN1_TYPE_get_int_octetstring(ASN1_TYPE *a,long *num, int ASN1_TYPE_get_int_octetstring(ASN1_TYPE *a,long *num,
unsigned char *data, int max_len); unsigned char *data, int max_len);
STACK_OF(BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len, STACK_OF(OPENSSL_BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len,
d2i_of_void *d2i, void (*free_func)(BLOCK)); d2i_of_void *d2i, void (*free_func)(OPENSSL_BLOCK));
unsigned char *ASN1_seq_pack(STACK_OF(BLOCK) *safes, i2d_of_void *i2d, unsigned char *ASN1_seq_pack(STACK_OF(OPENSSL_BLOCK) *safes, i2d_of_void *i2d,
unsigned char **buf, int *len ); unsigned char **buf, int *len );
void *ASN1_unpack_string(ASN1_STRING *oct, d2i_of_void *d2i); void *ASN1_unpack_string(ASN1_STRING *oct, d2i_of_void *d2i);
void *ASN1_item_unpack(ASN1_STRING *oct, const ASN1_ITEM *it); void *ASN1_item_unpack(ASN1_STRING *oct, const ASN1_ITEM *it);

8
crypto/asn1/asn_pack.c
View File

@ -66,10 +66,10 @@
/* Turn an ASN1 encoded SEQUENCE OF into a STACK of structures */ /* Turn an ASN1 encoded SEQUENCE OF into a STACK of structures */
STACK_OF(BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len, STACK_OF(OPENSSL_BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len,
d2i_of_void *d2i, void (*free_func)(BLOCK)) d2i_of_void *d2i, void (*free_func)(OPENSSL_BLOCK))
{ {
STACK_OF(BLOCK) *sk; STACK_OF(OPENSSL_BLOCK) *sk;
const unsigned char *pbuf; const unsigned char *pbuf;
pbuf = buf; pbuf = buf;
if (!(sk = d2i_ASN1_SET(NULL, &pbuf, len, d2i, free_func, if (!(sk = d2i_ASN1_SET(NULL, &pbuf, len, d2i, free_func,
@ -82,7 +82,7 @@ STACK_OF(BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len,
* OPENSSL_malloc'ed buffer * OPENSSL_malloc'ed buffer
*/ */
unsigned char *ASN1_seq_pack(STACK_OF(BLOCK) *safes, i2d_of_void *i2d, unsigned char *ASN1_seq_pack(STACK_OF(OPENSSL_BLOCK) *safes, i2d_of_void *i2d,
unsigned char **buf, int *len) unsigned char **buf, int *len)
{ {
int safelen; int safelen;

48
crypto/stack/safestack.h
View File

@ -128,8 +128,8 @@ DECLARE_SPECIAL_STACK_OF(OPENSSL_STRING, char)
* nul-terminated. These should also be distinguished from "normal" * nul-terminated. These should also be distinguished from "normal"
* stacks. */ * stacks. */
typedef void *BLOCK; typedef void *OPENSSL_BLOCK;
DECLARE_SPECIAL_STACK_OF(BLOCK, void) DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
/* SKM_sk_... stack macros are internal to safestack.h: /* SKM_sk_... stack macros are internal to safestack.h:
* never use them directly, use sk_<type>_... instead */ * never use them directly, use sk_<type>_... instead */
@ -2055,29 +2055,29 @@ DECLARE_SPECIAL_STACK_OF(BLOCK, void)
#define sk_OPENSSL_STRING_is_sorted(st) SKM_sk_is_sorted(OPENSSL_STRING, (st)) #define sk_OPENSSL_STRING_is_sorted(st) SKM_sk_is_sorted(OPENSSL_STRING, (st))
#define sk_BLOCK_new(cmp) ((STACK_OF(BLOCK) *)sk_new(CHECKED_SK_CMP_FUNC(void, cmp))) #define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_SK_CMP_FUNC(void, cmp)))
#define sk_BLOCK_new_null() ((STACK_OF(BLOCK) *)sk_new_null()) #define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null())
#define sk_BLOCK_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, val)) #define sk_OPENSSL_BLOCK_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val))
#define sk_BLOCK_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, val)) #define sk_OPENSSL_BLOCK_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val))
#define sk_BLOCK_value(st, i) ((BLOCK)sk_value(CHECKED_PTR_OF(STACK_OF(BLOCK), st), i)) #define sk_OPENSSL_BLOCK_value(st, i) ((OPENSSL_BLOCK)sk_value(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), i))
#define sk_BLOCK_num(st) SKM_sk_num(BLOCK, st) #define sk_OPENSSL_BLOCK_num(st) SKM_sk_num(OPENSSL_BLOCK, st)
#define sk_BLOCK_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_SK_FREE_FUNC2(BLOCK, free_func)) #define sk_OPENSSL_BLOCK_pop_free(st, free_func) sk_pop_free(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_SK_FREE_FUNC2(OPENSSL_BLOCK, free_func))
#define sk_BLOCK_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, val), i) #define sk_OPENSSL_BLOCK_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val), i)
#define sk_BLOCK_free(st) SKM_sk_free(BLOCK, st) #define sk_OPENSSL_BLOCK_free(st) SKM_sk_free(OPENSSL_BLOCK, st)
#define sk_BLOCK_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st), i, CHECKED_PTR_OF(void, val)) #define sk_OPENSSL_BLOCK_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), i, CHECKED_PTR_OF(void, val))
#define sk_BLOCK_zero(st) SKM_sk_zero(BLOCK, (st)) #define sk_OPENSSL_BLOCK_zero(st) SKM_sk_zero(OPENSSL_BLOCK, (st))
#define sk_BLOCK_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, val)) #define sk_OPENSSL_BLOCK_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val))
#define sk_BLOCK_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(BLOCK), st), CHECKED_CONST_PTR_OF(void, val)) #define sk_OPENSSL_BLOCK_find_ex(st, val) sk_find_ex((_STACK *)CHECKED_CONST_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_CONST_PTR_OF(void, val))
#define sk_BLOCK_delete(st, i) SKM_sk_delete(BLOCK, (st), (i)) #define sk_OPENSSL_BLOCK_delete(st, i) SKM_sk_delete(OPENSSL_BLOCK, (st), (i))
#define sk_BLOCK_delete_ptr(st, ptr) (BLOCK *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, ptr)) #define sk_OPENSSL_BLOCK_delete_ptr(st, ptr) (OPENSSL_BLOCK *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, ptr))
#define sk_BLOCK_set_cmp_func(st, cmp) \ #define sk_OPENSSL_BLOCK_set_cmp_func(st, cmp) \
((int (*)(const void * const *,const void * const *)) \ ((int (*)(const void * const *,const void * const *)) \
sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_SK_CMP_FUNC(void, cmp))) sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_SK_CMP_FUNC(void, cmp)))
#define sk_BLOCK_dup(st) SKM_sk_dup(BLOCK, st) #define sk_OPENSSL_BLOCK_dup(st) SKM_sk_dup(OPENSSL_BLOCK, st)
#define sk_BLOCK_shift(st) SKM_sk_shift(BLOCK, (st)) #define sk_OPENSSL_BLOCK_shift(st) SKM_sk_shift(OPENSSL_BLOCK, (st))
#define sk_BLOCK_pop(st) (void *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st)) #define sk_OPENSSL_BLOCK_pop(st) (void *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st))
#define sk_BLOCK_sort(st) SKM_sk_sort(BLOCK, (st)) #define sk_OPENSSL_BLOCK_sort(st) SKM_sk_sort(OPENSSL_BLOCK, (st))
#define sk_BLOCK_is_sorted(st) SKM_sk_is_sorted(BLOCK, (st)) #define sk_OPENSSL_BLOCK_is_sorted(st) SKM_sk_is_sorted(OPENSSL_BLOCK, (st))
#define sk_OPENSSL_PSTRING_new(cmp) ((STACK_OF(OPENSSL_PSTRING) *)sk_new(CHECKED_SK_CMP_FUNC(OPENSSL_STRING, cmp))) #define sk_OPENSSL_PSTRING_new(cmp) ((STACK_OF(OPENSSL_PSTRING) *)sk_new(CHECKED_SK_CMP_FUNC(OPENSSL_STRING, cmp)))