| 1 |
Index: openssl/crypto/asn1/a_set.c
|
| 2 |
RCS File: /v/openssl/cvs/openssl/crypto/asn1/a_set.c,v
|
| 3 |
rcsdiff -q -kk '-r1.20' '-r1.20.2.1' -u '/v/openssl/cvs/openssl/crypto/asn1/a_set.c,v' 2>/dev/null
|
| 4 |
--- openssl/crypto/asn1/a_set.c 2009/01/01 18:30:50 1.20
|
| 5 |
+++ openssl/crypto/asn1/a_set.c 2009/07/27 21:21:25 1.20.2.1
|
| 6 |
@@ -85,7 +85,7 @@
|
| 7 |
}
|
| 8 |
|
| 9 |
/* int is_set: if TRUE, then sort the contents (i.e. it isn't a SEQUENCE) */
|
| 10 |
-int i2d_ASN1_SET(STACK_OF(BLOCK) *a, unsigned char **pp,
|
| 11 |
+int i2d_ASN1_SET(STACK_OF(OPENSSL_BLOCK) *a, unsigned char **pp,
|
| 12 |
i2d_of_void *i2d, int ex_tag, int ex_class,
|
| 13 |
int is_set)
|
| 14 |
{
|
| 15 |
@@ -97,8 +97,8 @@
|
| 16 |
int totSize;
|
| 17 |
|
| 18 |
if (a == NULL) return(0);
|
| 19 |
- for (i=sk_BLOCK_num(a)-1; i>=0; i--)
|
| 20 |
- ret+=i2d(sk_BLOCK_value(a,i),NULL);
|
| 21 |
+ for (i=sk_OPENSSL_BLOCK_num(a)-1; i>=0; i--)
|
| 22 |
+ ret+=i2d(sk_OPENSSL_BLOCK_value(a,i),NULL);
|
| 23 |
r=ASN1_object_size(1,ret,ex_tag);
|
| 24 |
if (pp == NULL) return(r);
|
| 25 |
|
| 26 |
@@ -109,10 +109,10 @@
|
| 27 |
/* And then again by Ben */
|
| 28 |
/* And again by Steve */
|
| 29 |
|
| 30 |
- if(!is_set || (sk_BLOCK_num(a) < 2))
|
| 31 |
+ if(!is_set || (sk_OPENSSL_BLOCK_num(a) < 2))
|
| 32 |
{
|
| 33 |
- for (i=0; i<sk_BLOCK_num(a); i++)
|
| 34 |
- i2d(sk_BLOCK_value(a,i),&p);
|
| 35 |
+ for (i=0; i<sk_OPENSSL_BLOCK_num(a); i++)
|
| 36 |
+ i2d(sk_OPENSSL_BLOCK_value(a,i),&p);
|
| 37 |
|
| 38 |
*pp=p;
|
| 39 |
return(r);
|
| 40 |
@@ -120,17 +120,17 @@
|
| 41 |
|
| 42 |
pStart = p; /* Catch the beg of Setblobs*/
|
| 43 |
/* In this array we will store the SET blobs */
|
| 44 |
- rgSetBlob = OPENSSL_malloc(sk_BLOCK_num(a) * sizeof(MYBLOB));
|
| 45 |
+ rgSetBlob = OPENSSL_malloc(sk_OPENSSL_BLOCK_num(a) * sizeof(MYBLOB));
|
| 46 |
if (rgSetBlob == NULL)
|
| 47 |
{
|
| 48 |
ASN1err(ASN1_F_I2D_ASN1_SET,ERR_R_MALLOC_FAILURE);
|
| 49 |
return(0);
|
| 50 |
}
|
| 51 |
|
| 52 |
- for (i=0; i<sk_BLOCK_num(a); i++)
|
| 53 |
+ for (i=0; i<sk_OPENSSL_BLOCK_num(a); i++)
|
| 54 |
{
|
| 55 |
rgSetBlob[i].pbData = p; /* catch each set encode blob */
|
| 56 |
- i2d(sk_BLOCK_value(a,i),&p);
|
| 57 |
+ i2d(sk_OPENSSL_BLOCK_value(a,i),&p);
|
| 58 |
rgSetBlob[i].cbData = p - rgSetBlob[i].pbData; /* Length of this
|
| 59 |
SetBlob
|
| 60 |
*/
|
| 61 |
@@ -140,7 +140,7 @@
|
| 62 |
|
| 63 |
/* Now we have to sort the blobs. I am using a simple algo.
|
| 64 |
*Sort ptrs *Copy to temp-mem *Copy from temp-mem to user-mem*/
|
| 65 |
- qsort( rgSetBlob, sk_BLOCK_num(a), sizeof(MYBLOB), SetBlobCmp);
|
| 66 |
+ qsort( rgSetBlob, sk_OPENSSL_BLOCK_num(a), sizeof(MYBLOB), SetBlobCmp);
|
| 67 |
if (!(pTempMem = OPENSSL_malloc(totSize)))
|
| 68 |
{
|
| 69 |
ASN1err(ASN1_F_I2D_ASN1_SET,ERR_R_MALLOC_FAILURE);
|
| 70 |
@@ -149,7 +149,7 @@
|
| 71 |
|
| 72 |
/* Copy to temp mem */
|
| 73 |
p = pTempMem;
|
| 74 |
- for(i=0; i<sk_BLOCK_num(a); ++i)
|
| 75 |
+ for(i=0; i<sk_OPENSSL_BLOCK_num(a); ++i)
|
| 76 |
{
|
| 77 |
memcpy(p, rgSetBlob[i].pbData, rgSetBlob[i].cbData);
|
| 78 |
p += rgSetBlob[i].cbData;
|
| 79 |
@@ -163,17 +163,18 @@
|
| 80 |
return(r);
|
| 81 |
}
|
| 82 |
|
| 83 |
-STACK_OF(BLOCK) *d2i_ASN1_SET(STACK_OF(BLOCK) **a, const unsigned char **pp,
|
| 84 |
+STACK_OF(OPENSSL_BLOCK) *d2i_ASN1_SET(STACK_OF(OPENSSL_BLOCK) **a,
|
| 85 |
+ const unsigned char **pp,
|
| 86 |
long length, d2i_of_void *d2i,
|
| 87 |
- void (*free_func)(BLOCK), int ex_tag,
|
| 88 |
+ void (*free_func)(OPENSSL_BLOCK), int ex_tag,
|
| 89 |
int ex_class)
|
| 90 |
{
|
| 91 |
ASN1_const_CTX c;
|
| 92 |
- STACK_OF(BLOCK) *ret=NULL;
|
| 93 |
+ STACK_OF(OPENSSL_BLOCK) *ret=NULL;
|
| 94 |
|
| 95 |
if ((a == NULL) || ((*a) == NULL))
|
| 96 |
{
|
| 97 |
- if ((ret=sk_BLOCK_new_null()) == NULL)
|
| 98 |
+ if ((ret=sk_OPENSSL_BLOCK_new_null()) == NULL)
|
| 99 |
{
|
| 100 |
ASN1err(ASN1_F_D2I_ASN1_SET,ERR_R_MALLOC_FAILURE);
|
| 101 |
goto err;
|
| 102 |
@@ -221,7 +222,7 @@
|
| 103 |
asn1_add_error(*pp,(int)(c.p- *pp));
|
| 104 |
goto err;
|
| 105 |
}
|
| 106 |
- if (!sk_BLOCK_push(ret,s)) goto err;
|
| 107 |
+ if (!sk_OPENSSL_BLOCK_push(ret,s)) goto err;
|
| 108 |
}
|
| 109 |
if (a != NULL) (*a)=ret;
|
| 110 |
*pp=c.p;
|
| 111 |
@@ -230,9 +231,9 @@
|
| 112 |
if ((ret != NULL) && ((a == NULL) || (*a != ret)))
|
| 113 |
{
|
| 114 |
if (free_func != NULL)
|
| 115 |
- sk_BLOCK_pop_free(ret,free_func);
|
| 116 |
+ sk_OPENSSL_BLOCK_pop_free(ret,free_func);
|
| 117 |
else
|
| 118 |
- sk_BLOCK_free(ret);
|
| 119 |
+ sk_OPENSSL_BLOCK_free(ret);
|
| 120 |
}
|
| 121 |
return(NULL);
|
| 122 |
}
|
| 123 |
Index: openssl/crypto/asn1/asn1.h
|
| 124 |
RCS File: /v/openssl/cvs/openssl/crypto/asn1/asn1.h,v
|
| 125 |
rcsdiff -q -kk '-r1.166.2.3' '-r1.166.2.4' -u '/v/openssl/cvs/openssl/crypto/asn1/asn1.h,v' 2>/dev/null
|
| 126 |
--- openssl/crypto/asn1/asn1.h 2009/07/24 11:15:55 1.166.2.3
|
| 127 |
+++ openssl/crypto/asn1/asn1.h 2009/07/27 21:21:25 1.166.2.4
|
| 128 |
@@ -887,12 +887,13 @@
|
| 129 |
ASN1_GENERALIZEDTIME *ASN1_TIME_to_generalizedtime(ASN1_TIME *t, ASN1_GENERALIZEDTIME **out);
|
| 130 |
int ASN1_TIME_set_string(ASN1_TIME *s, const char *str);
|
| 131 |
|
| 132 |
-int i2d_ASN1_SET(STACK_OF(BLOCK) *a, unsigned char **pp,
|
| 133 |
+int i2d_ASN1_SET(STACK_OF(OPENSSL_BLOCK) *a, unsigned char **pp,
|
| 134 |
i2d_of_void *i2d, int ex_tag, int ex_class,
|
| 135 |
int is_set);
|
| 136 |
-STACK_OF(BLOCK) *d2i_ASN1_SET(STACK_OF(BLOCK) **a, const unsigned char **pp,
|
| 137 |
+STACK_OF(OPENSSL_BLOCK) *d2i_ASN1_SET(STACK_OF(OPENSSL_BLOCK) **a,
|
| 138 |
+ const unsigned char **pp,
|
| 139 |
long length, d2i_of_void *d2i,
|
| 140 |
- void (*free_func)(BLOCK), int ex_tag,
|
| 141 |
+ void (*free_func)(OPENSSL_BLOCK), int ex_tag,
|
| 142 |
int ex_class);
|
| 143 |
|
| 144 |
#ifndef OPENSSL_NO_BIO
|
| 145 |
@@ -1045,9 +1046,9 @@
|
| 146 |
int ASN1_TYPE_get_int_octetstring(ASN1_TYPE *a,long *num,
|
| 147 |
unsigned char *data, int max_len);
|
| 148 |
|
| 149 |
-STACK_OF(BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len,
|
| 150 |
- d2i_of_void *d2i, void (*free_func)(BLOCK));
|
| 151 |
-unsigned char *ASN1_seq_pack(STACK_OF(BLOCK) *safes, i2d_of_void *i2d,
|
| 152 |
+STACK_OF(OPENSSL_BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len,
|
| 153 |
+ d2i_of_void *d2i, void (*free_func)(OPENSSL_BLOCK));
|
| 154 |
+unsigned char *ASN1_seq_pack(STACK_OF(OPENSSL_BLOCK) *safes, i2d_of_void *i2d,
|
| 155 |
unsigned char **buf, int *len );
|
| 156 |
void *ASN1_unpack_string(ASN1_STRING *oct, d2i_of_void *d2i);
|
| 157 |
void *ASN1_item_unpack(ASN1_STRING *oct, const ASN1_ITEM *it);
|
| 158 |
Index: openssl/crypto/asn1/asn_pack.c
|
| 159 |
RCS File: /v/openssl/cvs/openssl/crypto/asn1/asn_pack.c,v
|
| 160 |
rcsdiff -q -kk '-r1.19' '-r1.19.2.1' -u '/v/openssl/cvs/openssl/crypto/asn1/asn_pack.c,v' 2>/dev/null
|
| 161 |
--- openssl/crypto/asn1/asn_pack.c 2008/11/12 03:57:49 1.19
|
| 162 |
+++ openssl/crypto/asn1/asn_pack.c 2009/07/27 21:21:25 1.19.2.1
|
| 163 |
@@ -66,10 +66,10 @@
|
| 164 |
|
| 165 |
/* Turn an ASN1 encoded SEQUENCE OF into a STACK of structures */
|
| 166 |
|
| 167 |
-STACK_OF(BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len,
|
| 168 |
- d2i_of_void *d2i, void (*free_func)(BLOCK))
|
| 169 |
+STACK_OF(OPENSSL_BLOCK) *ASN1_seq_unpack(const unsigned char *buf, int len,
|
| 170 |
+ d2i_of_void *d2i, void (*free_func)(OPENSSL_BLOCK))
|
| 171 |
{
|
| 172 |
- STACK_OF(BLOCK) *sk;
|
| 173 |
+ STACK_OF(OPENSSL_BLOCK) *sk;
|
| 174 |
const unsigned char *pbuf;
|
| 175 |
pbuf = buf;
|
| 176 |
if (!(sk = d2i_ASN1_SET(NULL, &pbuf, len, d2i, free_func,
|
| 177 |
@@ -82,7 +82,7 @@
|
| 178 |
* OPENSSL_malloc'ed buffer
|
| 179 |
*/
|
| 180 |
|
| 181 |
-unsigned char *ASN1_seq_pack(STACK_OF(BLOCK) *safes, i2d_of_void *i2d,
|
| 182 |
+unsigned char *ASN1_seq_pack(STACK_OF(OPENSSL_BLOCK) *safes, i2d_of_void *i2d,
|
| 183 |
unsigned char **buf, int *len)
|
| 184 |
{
|
| 185 |
int safelen;
|
| 186 |
Index: openssl/crypto/stack/safestack.h
|
| 187 |
RCS File: /v/openssl/cvs/openssl/crypto/stack/safestack.h,v
|
| 188 |
rcsdiff -q -kk '-r1.72.2.4' '-r1.72.2.5' -u '/v/openssl/cvs/openssl/crypto/stack/safestack.h,v' 2>/dev/null
|
| 189 |
--- openssl/crypto/stack/safestack.h 2009/07/27 21:08:50 1.72.2.4
|
| 190 |
+++ openssl/crypto/stack/safestack.h 2009/07/27 21:21:25 1.72.2.5
|
| 191 |
@@ -128,8 +128,8 @@
|
| 192 |
* nul-terminated. These should also be distinguished from "normal"
|
| 193 |
* stacks. */
|
| 194 |
|
| 195 |
-typedef void *BLOCK;
|
| 196 |
-DECLARE_SPECIAL_STACK_OF(BLOCK, void)
|
| 197 |
+typedef void *OPENSSL_BLOCK;
|
| 198 |
+DECLARE_SPECIAL_STACK_OF(OPENSSL_BLOCK, void)
|
| 199 |
|
| 200 |
/* SKM_sk_... stack macros are internal to safestack.h:
|
| 201 |
* never use them directly, use sk_<type>_... instead */
|
| 202 |
@@ -2055,29 +2055,29 @@
|
| 203 |
#define sk_OPENSSL_STRING_is_sorted(st) SKM_sk_is_sorted(OPENSSL_STRING, (st))
|
| 204 |
|
| 205 |
|
| 206 |
-#define sk_BLOCK_new(cmp) ((STACK_OF(BLOCK) *)sk_new(CHECKED_SK_CMP_FUNC(void, cmp)))
|
| 207 |
-#define sk_BLOCK_new_null() ((STACK_OF(BLOCK) *)sk_new_null())
|
| 208 |
-#define sk_BLOCK_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, val))
|
| 209 |
-#define sk_BLOCK_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, val))
|
| 210 |
-#define sk_BLOCK_value(st, i) ((BLOCK)sk_value(CHECKED_PTR_OF(STACK_OF(BLOCK), st), i))
|
| 211 |
-#define sk_BLOCK_num(st) SKM_sk_num(BLOCK, st)
|
| 212 |
-#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))
|
| 213 |
-#define sk_BLOCK_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, val), i)
|
| 214 |
-#define sk_BLOCK_free(st) SKM_sk_free(BLOCK, st)
|
| 215 |
-#define sk_BLOCK_set(st, i, val) sk_set((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st), i, CHECKED_PTR_OF(void, val))
|
| 216 |
-#define sk_BLOCK_zero(st) SKM_sk_zero(BLOCK, (st))
|
| 217 |
-#define sk_BLOCK_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, val))
|
| 218 |
-#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))
|
| 219 |
-#define sk_BLOCK_delete(st, i) SKM_sk_delete(BLOCK, (st), (i))
|
| 220 |
-#define sk_BLOCK_delete_ptr(st, ptr) (BLOCK *)sk_delete_ptr((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_PTR_OF(void, ptr))
|
| 221 |
-#define sk_BLOCK_set_cmp_func(st, cmp) \
|
| 222 |
+#define sk_OPENSSL_BLOCK_new(cmp) ((STACK_OF(OPENSSL_BLOCK) *)sk_new(CHECKED_SK_CMP_FUNC(void, cmp)))
|
| 223 |
+#define sk_OPENSSL_BLOCK_new_null() ((STACK_OF(OPENSSL_BLOCK) *)sk_new_null())
|
| 224 |
+#define sk_OPENSSL_BLOCK_push(st, val) sk_push(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val))
|
| 225 |
+#define sk_OPENSSL_BLOCK_find(st, val) sk_find(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val))
|
| 226 |
+#define sk_OPENSSL_BLOCK_value(st, i) ((OPENSSL_BLOCK)sk_value(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), i))
|
| 227 |
+#define sk_OPENSSL_BLOCK_num(st) SKM_sk_num(OPENSSL_BLOCK, st)
|
| 228 |
+#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))
|
| 229 |
+#define sk_OPENSSL_BLOCK_insert(st, val, i) sk_insert(CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val), i)
|
| 230 |
+#define sk_OPENSSL_BLOCK_free(st) SKM_sk_free(OPENSSL_BLOCK, st)
|
| 231 |
+#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))
|
| 232 |
+#define sk_OPENSSL_BLOCK_zero(st) SKM_sk_zero(OPENSSL_BLOCK, (st))
|
| 233 |
+#define sk_OPENSSL_BLOCK_unshift(st, val) sk_unshift((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_PTR_OF(void, val))
|
| 234 |
+#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))
|
| 235 |
+#define sk_OPENSSL_BLOCK_delete(st, i) SKM_sk_delete(OPENSSL_BLOCK, (st), (i))
|
| 236 |
+#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))
|
| 237 |
+#define sk_OPENSSL_BLOCK_set_cmp_func(st, cmp) \
|
| 238 |
((int (*)(const void * const *,const void * const *)) \
|
| 239 |
- sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st), CHECKED_SK_CMP_FUNC(void, cmp)))
|
| 240 |
-#define sk_BLOCK_dup(st) SKM_sk_dup(BLOCK, st)
|
| 241 |
-#define sk_BLOCK_shift(st) SKM_sk_shift(BLOCK, (st))
|
| 242 |
-#define sk_BLOCK_pop(st) (void *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(BLOCK), st))
|
| 243 |
-#define sk_BLOCK_sort(st) SKM_sk_sort(BLOCK, (st))
|
| 244 |
-#define sk_BLOCK_is_sorted(st) SKM_sk_is_sorted(BLOCK, (st))
|
| 245 |
+ sk_set_cmp_func((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st), CHECKED_SK_CMP_FUNC(void, cmp)))
|
| 246 |
+#define sk_OPENSSL_BLOCK_dup(st) SKM_sk_dup(OPENSSL_BLOCK, st)
|
| 247 |
+#define sk_OPENSSL_BLOCK_shift(st) SKM_sk_shift(OPENSSL_BLOCK, (st))
|
| 248 |
+#define sk_OPENSSL_BLOCK_pop(st) (void *)sk_pop((_STACK *)CHECKED_PTR_OF(STACK_OF(OPENSSL_BLOCK), st))
|
| 249 |
+#define sk_OPENSSL_BLOCK_sort(st) SKM_sk_sort(OPENSSL_BLOCK, (st))
|
| 250 |
+#define sk_OPENSSL_BLOCK_is_sorted(st) SKM_sk_is_sorted(OPENSSL_BLOCK, (st))
|
| 251 |
|
| 252 |
|
| 253 |
#define sk_OPENSSL_PSTRING_new(cmp) ((STACK_OF(OPENSSL_PSTRING) *)sk_new(CHECKED_SK_CMP_FUNC(OPENSSL_STRING, cmp)))
|
Parent Directory
| 
Revision Log