root / lab4 / .minix-src / include / openssl / asn1_mac.h @ 13
History | View | Annotate | Download (23.9 KB)
| 1 |
/* crypto/asn1/asn1_mac.h */
|
|---|---|
| 2 |
/* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com)
|
| 3 |
* All rights reserved.
|
| 4 |
*
|
| 5 |
* This package is an SSL implementation written
|
| 6 |
* by Eric Young (eay@cryptsoft.com).
|
| 7 |
* The implementation was written so as to conform with Netscapes SSL.
|
| 8 |
*
|
| 9 |
* This library is free for commercial and non-commercial use as long as
|
| 10 |
* the following conditions are aheared to. The following conditions
|
| 11 |
* apply to all code found in this distribution, be it the RC4, RSA,
|
| 12 |
* lhash, DES, etc., code; not just the SSL code. The SSL documentation
|
| 13 |
* included with this distribution is covered by the same copyright terms
|
| 14 |
* except that the holder is Tim Hudson (tjh@cryptsoft.com).
|
| 15 |
*
|
| 16 |
* Copyright remains Eric Young's, and as such any Copyright notices in
|
| 17 |
* the code are not to be removed.
|
| 18 |
* If this package is used in a product, Eric Young should be given attribution
|
| 19 |
* as the author of the parts of the library used.
|
| 20 |
* This can be in the form of a textual message at program startup or
|
| 21 |
* in documentation (online or textual) provided with the package.
|
| 22 |
*
|
| 23 |
* Redistribution and use in source and binary forms, with or without
|
| 24 |
* modification, are permitted provided that the following conditions
|
| 25 |
* are met:
|
| 26 |
* 1. Redistributions of source code must retain the copyright
|
| 27 |
* notice, this list of conditions and the following disclaimer.
|
| 28 |
* 2. Redistributions in binary form must reproduce the above copyright
|
| 29 |
* notice, this list of conditions and the following disclaimer in the
|
| 30 |
* documentation and/or other materials provided with the distribution.
|
| 31 |
* 3. All advertising materials mentioning features or use of this software
|
| 32 |
* must display the following acknowledgement:
|
| 33 |
* "This product includes cryptographic software written by
|
| 34 |
* Eric Young (eay@cryptsoft.com)"
|
| 35 |
* The word 'cryptographic' can be left out if the rouines from the library
|
| 36 |
* being used are not cryptographic related :-).
|
| 37 |
* 4. If you include any Windows specific code (or a derivative thereof) from
|
| 38 |
* the apps directory (application code) you must include an acknowledgement:
|
| 39 |
* "This product includes software written by Tim Hudson (tjh@cryptsoft.com)"
|
| 40 |
*
|
| 41 |
* THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND
|
| 42 |
* ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
| 43 |
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
|
| 44 |
* ARE DISCLAIMED. IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE
|
| 45 |
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
| 46 |
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
|
| 47 |
* OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
|
| 48 |
* HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
|
| 49 |
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
|
| 50 |
* OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
|
| 51 |
* SUCH DAMAGE.
|
| 52 |
*
|
| 53 |
* The licence and distribution terms for any publically available version or
|
| 54 |
* derivative of this code cannot be changed. i.e. this code cannot simply be
|
| 55 |
* copied and put under another distribution licence
|
| 56 |
* [including the GNU Public Licence.]
|
| 57 |
*/
|
| 58 |
|
| 59 |
#ifndef HEADER_ASN1_MAC_H
|
| 60 |
# define HEADER_ASN1_MAC_H
|
| 61 |
|
| 62 |
# include <openssl/asn1.h> |
| 63 |
|
| 64 |
#ifdef __cplusplus
|
| 65 |
extern "C" { |
| 66 |
#endif
|
| 67 |
|
| 68 |
# ifndef ASN1_MAC_ERR_LIB
|
| 69 |
# define ASN1_MAC_ERR_LIB ERR_LIB_ASN1
|
| 70 |
# endif
|
| 71 |
|
| 72 |
# define ASN1_MAC_H_err(f,r,line) \
|
| 73 |
ERR_PUT_error(ASN1_MAC_ERR_LIB,(f),(r),__FILE__,(line)) |
| 74 |
|
| 75 |
# define M_ASN1_D2I_vars(a,type,func) \
|
| 76 |
ASN1_const_CTX c; \ |
| 77 |
type ret=NULL; \
|
| 78 |
\ |
| 79 |
c.pp=(const unsigned char **)pp; \ |
| 80 |
c.q= *(const unsigned char **)pp; \ |
| 81 |
c.error=ERR_R_NESTED_ASN1_ERROR; \ |
| 82 |
if ((a == NULL) || ((*a) == NULL)) \ |
| 83 |
{ if ((ret=(type)func()) == NULL) \
|
| 84 |
{ c.line=__LINE__; goto err; } } \
|
| 85 |
else ret=(*a);
|
| 86 |
|
| 87 |
# define M_ASN1_D2I_Init() \
|
| 88 |
c.p= *(const unsigned char **)pp; \ |
| 89 |
c.max=(length == 0)?0:(c.p+length); |
| 90 |
|
| 91 |
# define M_ASN1_D2I_Finish_2(a) \
|
| 92 |
if (!asn1_const_Finish(&c)) \
|
| 93 |
{ c.line=__LINE__; goto err; } \
|
| 94 |
*(const unsigned char **)pp=c.p; \ |
| 95 |
if (a != NULL) (*a)=ret; \ |
| 96 |
return(ret);
|
| 97 |
|
| 98 |
# define M_ASN1_D2I_Finish(a,func,e) \
|
| 99 |
M_ASN1_D2I_Finish_2(a); \ |
| 100 |
err:\ |
| 101 |
ASN1_MAC_H_err((e),c.error,c.line); \ |
| 102 |
asn1_add_error(*(const unsigned char **)pp,(int)(c.q- *pp)); \ |
| 103 |
if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); \ |
| 104 |
return(NULL) |
| 105 |
|
| 106 |
# define M_ASN1_D2I_start_sequence() \
|
| 107 |
if (!asn1_GetSequence(&c,&length)) \
|
| 108 |
{ c.line=__LINE__; goto err; }
|
| 109 |
/* Begin reading ASN1 without a surrounding sequence */
|
| 110 |
# define M_ASN1_D2I_begin() \
|
| 111 |
c.slen = length; |
| 112 |
|
| 113 |
/* End reading ASN1 with no check on length */
|
| 114 |
# define M_ASN1_D2I_Finish_nolen(a, func, e) \
|
| 115 |
*pp=c.p; \ |
| 116 |
if (a != NULL) (*a)=ret; \ |
| 117 |
return(ret); \
|
| 118 |
err:\ |
| 119 |
ASN1_MAC_H_err((e),c.error,c.line); \ |
| 120 |
asn1_add_error(*pp,(int)(c.q- *pp)); \
|
| 121 |
if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); \ |
| 122 |
return(NULL) |
| 123 |
|
| 124 |
# define M_ASN1_D2I_end_sequence() \
|
| 125 |
(((c.inf&1) == 0)?(c.slen <= 0): \ |
| 126 |
(c.eos=ASN1_const_check_infinite_end(&c.p,c.slen))) |
| 127 |
|
| 128 |
/* Don't use this with d2i_ASN1_BOOLEAN() */
|
| 129 |
# define M_ASN1_D2I_get(b, func) \
|
| 130 |
c.q=c.p; \ |
| 131 |
if (func(&(b),&c.p,c.slen) == NULL) \ |
| 132 |
{c.line=__LINE__; goto err; } \
|
| 133 |
c.slen-=(c.p-c.q); |
| 134 |
|
| 135 |
/* Don't use this with d2i_ASN1_BOOLEAN() */
|
| 136 |
# define M_ASN1_D2I_get_x(type,b,func) \
|
| 137 |
c.q=c.p; \ |
| 138 |
if (((D2I_OF(type))func)(&(b),&c.p,c.slen) == NULL) \ |
| 139 |
{c.line=__LINE__; goto err; } \
|
| 140 |
c.slen-=(c.p-c.q); |
| 141 |
|
| 142 |
/* use this instead () */
|
| 143 |
# define M_ASN1_D2I_get_int(b,func) \
|
| 144 |
c.q=c.p; \ |
| 145 |
if (func(&(b),&c.p,c.slen) < 0) \ |
| 146 |
{c.line=__LINE__; goto err; } \
|
| 147 |
c.slen-=(c.p-c.q); |
| 148 |
|
| 149 |
# define M_ASN1_D2I_get_opt(b,func,type) \
|
| 150 |
if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) \ |
| 151 |
== (V_ASN1_UNIVERSAL|(type)))) \ |
| 152 |
{ \
|
| 153 |
M_ASN1_D2I_get(b,func); \ |
| 154 |
} |
| 155 |
|
| 156 |
# define M_ASN1_D2I_get_int_opt(b,func,type) \
|
| 157 |
if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) \ |
| 158 |
== (V_ASN1_UNIVERSAL|(type)))) \ |
| 159 |
{ \
|
| 160 |
M_ASN1_D2I_get_int(b,func); \ |
| 161 |
} |
| 162 |
|
| 163 |
# define M_ASN1_D2I_get_imp(b,func, type) \
|
| 164 |
M_ASN1_next=(_tmp& V_ASN1_CONSTRUCTED)|type; \ |
| 165 |
c.q=c.p; \ |
| 166 |
if (func(&(b),&c.p,c.slen) == NULL) \ |
| 167 |
{c.line=__LINE__; M_ASN1_next_prev = _tmp; goto err; } \
|
| 168 |
c.slen-=(c.p-c.q);\ |
| 169 |
M_ASN1_next_prev=_tmp; |
| 170 |
|
| 171 |
# define M_ASN1_D2I_get_IMP_opt(b,func,tag,type) \
|
| 172 |
if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) == \ |
| 173 |
(V_ASN1_CONTEXT_SPECIFIC|(tag)))) \ |
| 174 |
{ \
|
| 175 |
unsigned char _tmp = M_ASN1_next; \ |
| 176 |
M_ASN1_D2I_get_imp(b,func, type);\ |
| 177 |
} |
| 178 |
|
| 179 |
# define M_ASN1_D2I_get_set(r,func,free_func) \
|
| 180 |
M_ASN1_D2I_get_imp_set(r,func,free_func, \ |
| 181 |
V_ASN1_SET,V_ASN1_UNIVERSAL); |
| 182 |
|
| 183 |
# define M_ASN1_D2I_get_set_type(type,r,func,free_func) \
|
| 184 |
M_ASN1_D2I_get_imp_set_type(type,r,func,free_func, \ |
| 185 |
V_ASN1_SET,V_ASN1_UNIVERSAL); |
| 186 |
|
| 187 |
# define M_ASN1_D2I_get_set_opt(r,func,free_func) \
|
| 188 |
if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ |
| 189 |
V_ASN1_CONSTRUCTED|V_ASN1_SET)))\ |
| 190 |
{ M_ASN1_D2I_get_set(r,func,free_func); }
|
| 191 |
|
| 192 |
# define M_ASN1_D2I_get_set_opt_type(type,r,func,free_func) \
|
| 193 |
if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ |
| 194 |
V_ASN1_CONSTRUCTED|V_ASN1_SET)))\ |
| 195 |
{ M_ASN1_D2I_get_set_type(type,r,func,free_func); }
|
| 196 |
|
| 197 |
# define M_ASN1_I2D_len_SET_opt(a,f) \
|
| 198 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 199 |
M_ASN1_I2D_len_SET(a,f); |
| 200 |
|
| 201 |
# define M_ASN1_I2D_put_SET_opt(a,f) \
|
| 202 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 203 |
M_ASN1_I2D_put_SET(a,f); |
| 204 |
|
| 205 |
# define M_ASN1_I2D_put_SEQUENCE_opt(a,f) \
|
| 206 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 207 |
M_ASN1_I2D_put_SEQUENCE(a,f); |
| 208 |
|
| 209 |
# define M_ASN1_I2D_put_SEQUENCE_opt_type(type,a,f) \
|
| 210 |
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
| 211 |
M_ASN1_I2D_put_SEQUENCE_type(type,a,f); |
| 212 |
|
| 213 |
# define M_ASN1_D2I_get_IMP_set_opt(b,func,free_func,tag) \
|
| 214 |
if ((c.slen != 0) && \ |
| 215 |
(M_ASN1_next == \ |
| 216 |
(V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))\ |
| 217 |
{ \
|
| 218 |
M_ASN1_D2I_get_imp_set(b,func,free_func,\ |
| 219 |
tag,V_ASN1_CONTEXT_SPECIFIC); \ |
| 220 |
} |
| 221 |
|
| 222 |
# define M_ASN1_D2I_get_IMP_set_opt_type(type,b,func,free_func,tag) \
|
| 223 |
if ((c.slen != 0) && \ |
| 224 |
(M_ASN1_next == \ |
| 225 |
(V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))\ |
| 226 |
{ \
|
| 227 |
M_ASN1_D2I_get_imp_set_type(type,b,func,free_func,\ |
| 228 |
tag,V_ASN1_CONTEXT_SPECIFIC); \ |
| 229 |
} |
| 230 |
|
| 231 |
# define M_ASN1_D2I_get_seq(r,func,free_func) \
|
| 232 |
M_ASN1_D2I_get_imp_set(r,func,free_func,\ |
| 233 |
V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL); |
| 234 |
|
| 235 |
# define M_ASN1_D2I_get_seq_type(type,r,func,free_func) \
|
| 236 |
M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,\ |
| 237 |
V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL) |
| 238 |
|
| 239 |
# define M_ASN1_D2I_get_seq_opt(r,func,free_func) \
|
| 240 |
if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ |
| 241 |
V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))\ |
| 242 |
{ M_ASN1_D2I_get_seq(r,func,free_func); }
|
| 243 |
|
| 244 |
# define M_ASN1_D2I_get_seq_opt_type(type,r,func,free_func) \
|
| 245 |
if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| \ |
| 246 |
V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))\ |
| 247 |
{ M_ASN1_D2I_get_seq_type(type,r,func,free_func); }
|
| 248 |
|
| 249 |
# define M_ASN1_D2I_get_IMP_set(r,func,free_func,x) \
|
| 250 |
M_ASN1_D2I_get_imp_set(r,func,free_func,\ |
| 251 |
x,V_ASN1_CONTEXT_SPECIFIC); |
| 252 |
|
| 253 |
# define M_ASN1_D2I_get_IMP_set_type(type,r,func,free_func,x) \
|
| 254 |
M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,\ |
| 255 |
x,V_ASN1_CONTEXT_SPECIFIC); |
| 256 |
|
| 257 |
# define M_ASN1_D2I_get_imp_set(r,func,free_func,a,b) \
|
| 258 |
c.q=c.p; \ |
| 259 |
if (d2i_ASN1_SET(&(r),&c.p,c.slen,(char *(*)())func,\ |
| 260 |
(void (*)())free_func,a,b) == NULL) \ |
| 261 |
{ c.line=__LINE__; goto err; } \
|
| 262 |
c.slen-=(c.p-c.q); |
| 263 |
|
| 264 |
# define M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,a,b) \
|
| 265 |
c.q=c.p; \ |
| 266 |
if (d2i_ASN1_SET_OF_##type(&(r),&c.p,c.slen,func,\ |
| 267 |
free_func,a,b) == NULL) \
|
| 268 |
{ c.line=__LINE__; goto err; } \
|
| 269 |
c.slen-=(c.p-c.q); |
| 270 |
|
| 271 |
# define M_ASN1_D2I_get_set_strings(r,func,a,b) \
|
| 272 |
c.q=c.p; \ |
| 273 |
if (d2i_ASN1_STRING_SET(&(r),&c.p,c.slen,a,b) == NULL) \ |
| 274 |
{ c.line=__LINE__; goto err; } \
|
| 275 |
c.slen-=(c.p-c.q); |
| 276 |
|
| 277 |
# define M_ASN1_D2I_get_EXP_opt(r,func,tag) \
|
| 278 |
if ((c.slen != 0L) && (M_ASN1_next == \ |
| 279 |
(V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ |
| 280 |
{ \
|
| 281 |
int Tinf,Ttag,Tclass; \
|
| 282 |
long Tlen; \
|
| 283 |
\ |
| 284 |
c.q=c.p; \ |
| 285 |
Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ |
| 286 |
if (Tinf & 0x80) \ |
| 287 |
{ c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \
|
| 288 |
c.line=__LINE__; goto err; } \
|
| 289 |
if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ |
| 290 |
Tlen = c.slen - (c.p - c.q) - 2; \
|
| 291 |
if (func(&(r),&c.p,Tlen) == NULL) \ |
| 292 |
{ c.line=__LINE__; goto err; } \
|
| 293 |
if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ |
| 294 |
Tlen = c.slen - (c.p - c.q); \ |
| 295 |
if(!ASN1_const_check_infinite_end(&c.p, Tlen)) \
|
| 296 |
{ c.error=ERR_R_MISSING_ASN1_EOS; \
|
| 297 |
c.line=__LINE__; goto err; } \
|
| 298 |
}\ |
| 299 |
c.slen-=(c.p-c.q); \ |
| 300 |
} |
| 301 |
|
| 302 |
# define M_ASN1_D2I_get_EXP_set_opt(r,func,free_func,tag,b) \
|
| 303 |
if ((c.slen != 0) && (M_ASN1_next == \ |
| 304 |
(V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ |
| 305 |
{ \
|
| 306 |
int Tinf,Ttag,Tclass; \
|
| 307 |
long Tlen; \
|
| 308 |
\ |
| 309 |
c.q=c.p; \ |
| 310 |
Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ |
| 311 |
if (Tinf & 0x80) \ |
| 312 |
{ c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \
|
| 313 |
c.line=__LINE__; goto err; } \
|
| 314 |
if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ |
| 315 |
Tlen = c.slen - (c.p - c.q) - 2; \
|
| 316 |
if (d2i_ASN1_SET(&(r),&c.p,Tlen,(char *(*)())func, \ |
| 317 |
(void (*)())free_func, \
|
| 318 |
b,V_ASN1_UNIVERSAL) == NULL) \
|
| 319 |
{ c.line=__LINE__; goto err; } \
|
| 320 |
if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ |
| 321 |
Tlen = c.slen - (c.p - c.q); \ |
| 322 |
if(!ASN1_check_infinite_end(&c.p, Tlen)) \
|
| 323 |
{ c.error=ERR_R_MISSING_ASN1_EOS; \
|
| 324 |
c.line=__LINE__; goto err; } \
|
| 325 |
}\ |
| 326 |
c.slen-=(c.p-c.q); \ |
| 327 |
} |
| 328 |
|
| 329 |
# define M_ASN1_D2I_get_EXP_set_opt_type(type,r,func,free_func,tag,b) \
|
| 330 |
if ((c.slen != 0) && (M_ASN1_next == \ |
| 331 |
(V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) \ |
| 332 |
{ \
|
| 333 |
int Tinf,Ttag,Tclass; \
|
| 334 |
long Tlen; \
|
| 335 |
\ |
| 336 |
c.q=c.p; \ |
| 337 |
Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); \ |
| 338 |
if (Tinf & 0x80) \ |
| 339 |
{ c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; \
|
| 340 |
c.line=__LINE__; goto err; } \
|
| 341 |
if (Tinf == (V_ASN1_CONSTRUCTED+1)) \ |
| 342 |
Tlen = c.slen - (c.p - c.q) - 2; \
|
| 343 |
if (d2i_ASN1_SET_OF_##type(&(r),&c.p,Tlen,func, \ |
| 344 |
free_func,b,V_ASN1_UNIVERSAL) == NULL) \
|
| 345 |
{ c.line=__LINE__; goto err; } \
|
| 346 |
if (Tinf == (V_ASN1_CONSTRUCTED+1)) { \ |
| 347 |
Tlen = c.slen - (c.p - c.q); \ |
| 348 |
if(!ASN1_check_infinite_end(&c.p, Tlen)) \
|
| 349 |
{ c.error=ERR_R_MISSING_ASN1_EOS; \
|
| 350 |
c.line=__LINE__; goto err; } \
|
| 351 |
}\ |
| 352 |
c.slen-=(c.p-c.q); \ |
| 353 |
} |
| 354 |
|
| 355 |
/* New macros */
|
| 356 |
# define M_ASN1_New_Malloc(ret,type) \
|
| 357 |
if ((ret=(type *)OPENSSL_malloc(sizeof(type))) == NULL) \ |
| 358 |
{ c.line=__LINE__; goto err2; }
|
| 359 |
|
| 360 |
# define M_ASN1_New(arg,func) \
|
| 361 |
if (((arg)=func()) == NULL) return(NULL) |
| 362 |
|
| 363 |
# define M_ASN1_New_Error(a) \
|
| 364 |
/*- err: ASN1_MAC_H_err((a),ERR_R_NESTED_ASN1_ERROR,c.line); \
|
| 365 |
return(NULL);*/ \
|
| 366 |
err2: ASN1_MAC_H_err((a),ERR_R_MALLOC_FAILURE,c.line); \ |
| 367 |
return(NULL) |
| 368 |
|
| 369 |
/*
|
| 370 |
* BIG UGLY WARNING! This is so damn ugly I wanna puke. Unfortunately, some
|
| 371 |
* macros that use ASN1_const_CTX still insist on writing in the input
|
| 372 |
* stream. ARGH! ARGH! ARGH! Let's get rid of this macro package. Please? --
|
| 373 |
* Richard Levitte
|
| 374 |
*/
|
| 375 |
# define M_ASN1_next (*((unsigned char *)(c.p))) |
| 376 |
# define M_ASN1_next_prev (*((unsigned char *)(c.q))) |
| 377 |
|
| 378 |
/*************************************************/
|
| 379 |
|
| 380 |
# define M_ASN1_I2D_vars(a) int r=0,ret=0; \ |
| 381 |
unsigned char *p; \ |
| 382 |
if (a == NULL) return(0) |
| 383 |
|
| 384 |
/* Length Macros */
|
| 385 |
# define M_ASN1_I2D_len(a,f) ret+=f(a,NULL) |
| 386 |
# define M_ASN1_I2D_len_IMP_opt(a,f) if (a != NULL) M_ASN1_I2D_len(a,f) |
| 387 |
|
| 388 |
# define M_ASN1_I2D_len_SET(a,f) \
|
| 389 |
ret+=i2d_ASN1_SET(a,NULL,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET);
|
| 390 |
|
| 391 |
# define M_ASN1_I2D_len_SET_type(type,a,f) \
|
| 392 |
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SET, \ |
| 393 |
V_ASN1_UNIVERSAL,IS_SET); |
| 394 |
|
| 395 |
# define M_ASN1_I2D_len_SEQUENCE(a,f) \
|
| 396 |
ret+=i2d_ASN1_SET(a,NULL,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, \
|
| 397 |
IS_SEQUENCE); |
| 398 |
|
| 399 |
# define M_ASN1_I2D_len_SEQUENCE_type(type,a,f) \
|
| 400 |
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SEQUENCE, \ |
| 401 |
V_ASN1_UNIVERSAL,IS_SEQUENCE) |
| 402 |
|
| 403 |
# define M_ASN1_I2D_len_SEQUENCE_opt(a,f) \
|
| 404 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 405 |
M_ASN1_I2D_len_SEQUENCE(a,f); |
| 406 |
|
| 407 |
# define M_ASN1_I2D_len_SEQUENCE_opt_type(type,a,f) \
|
| 408 |
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
| 409 |
M_ASN1_I2D_len_SEQUENCE_type(type,a,f); |
| 410 |
|
| 411 |
# define M_ASN1_I2D_len_IMP_SET(a,f,x) \
|
| 412 |
ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET);
|
| 413 |
|
| 414 |
# define M_ASN1_I2D_len_IMP_SET_type(type,a,f,x) \
|
| 415 |
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ |
| 416 |
V_ASN1_CONTEXT_SPECIFIC,IS_SET); |
| 417 |
|
| 418 |
# define M_ASN1_I2D_len_IMP_SET_opt(a,f,x) \
|
| 419 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 420 |
ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \
|
| 421 |
IS_SET); |
| 422 |
|
| 423 |
# define M_ASN1_I2D_len_IMP_SET_opt_type(type,a,f,x) \
|
| 424 |
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
| 425 |
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ |
| 426 |
V_ASN1_CONTEXT_SPECIFIC,IS_SET); |
| 427 |
|
| 428 |
# define M_ASN1_I2D_len_IMP_SEQUENCE(a,f,x) \
|
| 429 |
ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \
|
| 430 |
IS_SEQUENCE); |
| 431 |
|
| 432 |
# define M_ASN1_I2D_len_IMP_SEQUENCE_opt(a,f,x) \
|
| 433 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 434 |
ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, \
|
| 435 |
IS_SEQUENCE); |
| 436 |
|
| 437 |
# define M_ASN1_I2D_len_IMP_SEQUENCE_opt_type(type,a,f,x) \
|
| 438 |
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
| 439 |
ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, \ |
| 440 |
V_ASN1_CONTEXT_SPECIFIC, \ |
| 441 |
IS_SEQUENCE); |
| 442 |
|
| 443 |
# define M_ASN1_I2D_len_EXP_opt(a,f,mtag,v) \
|
| 444 |
if (a != NULL)\ |
| 445 |
{ \
|
| 446 |
v=f(a,NULL); \
|
| 447 |
ret+=ASN1_object_size(1,v,mtag); \
|
| 448 |
} |
| 449 |
|
| 450 |
# define M_ASN1_I2D_len_EXP_SET_opt(a,f,mtag,tag,v) \
|
| 451 |
if ((a != NULL) && (sk_num(a) != 0))\ |
| 452 |
{ \
|
| 453 |
v=i2d_ASN1_SET(a,NULL,f,tag,V_ASN1_UNIVERSAL,IS_SET); \
|
| 454 |
ret+=ASN1_object_size(1,v,mtag); \
|
| 455 |
} |
| 456 |
|
| 457 |
# define M_ASN1_I2D_len_EXP_SEQUENCE_opt(a,f,mtag,tag,v) \
|
| 458 |
if ((a != NULL) && (sk_num(a) != 0))\ |
| 459 |
{ \
|
| 460 |
v=i2d_ASN1_SET(a,NULL,f,tag,V_ASN1_UNIVERSAL, \
|
| 461 |
IS_SEQUENCE); \ |
| 462 |
ret+=ASN1_object_size(1,v,mtag); \
|
| 463 |
} |
| 464 |
|
| 465 |
# define M_ASN1_I2D_len_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) \
|
| 466 |
if ((a != NULL) && (sk_##type##_num(a) != 0))\ |
| 467 |
{ \
|
| 468 |
v=i2d_ASN1_SET_OF_##type(a,NULL,f,tag, \ |
| 469 |
V_ASN1_UNIVERSAL, \ |
| 470 |
IS_SEQUENCE); \ |
| 471 |
ret+=ASN1_object_size(1,v,mtag); \
|
| 472 |
} |
| 473 |
|
| 474 |
/* Put Macros */
|
| 475 |
# define M_ASN1_I2D_put(a,f) f(a,&p)
|
| 476 |
|
| 477 |
# define M_ASN1_I2D_put_IMP_opt(a,f,t) \
|
| 478 |
if (a != NULL) \ |
| 479 |
{ \
|
| 480 |
unsigned char *q=p; \ |
| 481 |
f(a,&p); \ |
| 482 |
*q=(V_ASN1_CONTEXT_SPECIFIC|t|(*q&V_ASN1_CONSTRUCTED));\ |
| 483 |
} |
| 484 |
|
| 485 |
# define M_ASN1_I2D_put_SET(a,f) i2d_ASN1_SET(a,&p,f,V_ASN1_SET,\
|
| 486 |
V_ASN1_UNIVERSAL,IS_SET) |
| 487 |
# define M_ASN1_I2D_put_SET_type(type,a,f) \
|
| 488 |
i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET) |
| 489 |
# define M_ASN1_I2D_put_IMP_SET(a,f,x) i2d_ASN1_SET(a,&p,f,x,\
|
| 490 |
V_ASN1_CONTEXT_SPECIFIC,IS_SET) |
| 491 |
# define M_ASN1_I2D_put_IMP_SET_type(type,a,f,x) \
|
| 492 |
i2d_ASN1_SET_OF_##type(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET) |
| 493 |
# define M_ASN1_I2D_put_IMP_SEQUENCE(a,f,x) i2d_ASN1_SET(a,&p,f,x,\
|
| 494 |
V_ASN1_CONTEXT_SPECIFIC,IS_SEQUENCE) |
| 495 |
|
| 496 |
# define M_ASN1_I2D_put_SEQUENCE(a,f) i2d_ASN1_SET(a,&p,f,V_ASN1_SEQUENCE,\
|
| 497 |
V_ASN1_UNIVERSAL,IS_SEQUENCE) |
| 498 |
|
| 499 |
# define M_ASN1_I2D_put_SEQUENCE_type(type,a,f) \
|
| 500 |
i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, \ |
| 501 |
IS_SEQUENCE) |
| 502 |
|
| 503 |
# define M_ASN1_I2D_put_SEQUENCE_opt(a,f) \
|
| 504 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 505 |
M_ASN1_I2D_put_SEQUENCE(a,f); |
| 506 |
|
| 507 |
# define M_ASN1_I2D_put_IMP_SET_opt(a,f,x) \
|
| 508 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 509 |
{ i2d_ASN1_SET(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC, \
|
| 510 |
IS_SET); } |
| 511 |
|
| 512 |
# define M_ASN1_I2D_put_IMP_SET_opt_type(type,a,f,x) \
|
| 513 |
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
| 514 |
{ i2d_ASN1_SET_OF_##type(a,&p,f,x, \
|
| 515 |
V_ASN1_CONTEXT_SPECIFIC, \ |
| 516 |
IS_SET); } |
| 517 |
|
| 518 |
# define M_ASN1_I2D_put_IMP_SEQUENCE_opt(a,f,x) \
|
| 519 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 520 |
{ i2d_ASN1_SET(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC, \
|
| 521 |
IS_SEQUENCE); } |
| 522 |
|
| 523 |
# define M_ASN1_I2D_put_IMP_SEQUENCE_opt_type(type,a,f,x) \
|
| 524 |
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
| 525 |
{ i2d_ASN1_SET_OF_##type(a,&p,f,x, \
|
| 526 |
V_ASN1_CONTEXT_SPECIFIC, \ |
| 527 |
IS_SEQUENCE); } |
| 528 |
|
| 529 |
# define M_ASN1_I2D_put_EXP_opt(a,f,tag,v) \
|
| 530 |
if (a != NULL) \ |
| 531 |
{ \
|
| 532 |
ASN1_put_object(&p,1,v,tag,V_ASN1_CONTEXT_SPECIFIC); \
|
| 533 |
f(a,&p); \ |
| 534 |
} |
| 535 |
|
| 536 |
# define M_ASN1_I2D_put_EXP_SET_opt(a,f,mtag,tag,v) \
|
| 537 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 538 |
{ \
|
| 539 |
ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \
|
| 540 |
i2d_ASN1_SET(a,&p,f,tag,V_ASN1_UNIVERSAL,IS_SET); \ |
| 541 |
} |
| 542 |
|
| 543 |
# define M_ASN1_I2D_put_EXP_SEQUENCE_opt(a,f,mtag,tag,v) \
|
| 544 |
if ((a != NULL) && (sk_num(a) != 0)) \ |
| 545 |
{ \
|
| 546 |
ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \
|
| 547 |
i2d_ASN1_SET(a,&p,f,tag,V_ASN1_UNIVERSAL,IS_SEQUENCE); \ |
| 548 |
} |
| 549 |
|
| 550 |
# define M_ASN1_I2D_put_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) \
|
| 551 |
if ((a != NULL) && (sk_##type##_num(a) != 0)) \ |
| 552 |
{ \
|
| 553 |
ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); \
|
| 554 |
i2d_ASN1_SET_OF_##type(a,&p,f,tag,V_ASN1_UNIVERSAL, \ |
| 555 |
IS_SEQUENCE); \ |
| 556 |
} |
| 557 |
|
| 558 |
# define M_ASN1_I2D_seq_total() \
|
| 559 |
r=ASN1_object_size(1,ret,V_ASN1_SEQUENCE); \
|
| 560 |
if (pp == NULL) return(r); \ |
| 561 |
p= *pp; \ |
| 562 |
ASN1_put_object(&p,1,ret,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL)
|
| 563 |
|
| 564 |
# define M_ASN1_I2D_INF_seq_start(tag,ctx) \
|
| 565 |
*(p++)=(V_ASN1_CONSTRUCTED|(tag)|(ctx)); \ |
| 566 |
*(p++)=0x80
|
| 567 |
|
| 568 |
# define M_ASN1_I2D_INF_seq_end() *(p++)=0x00; *(p++)=0x00 |
| 569 |
|
| 570 |
# define M_ASN1_I2D_finish() *pp=p; \
|
| 571 |
return(r);
|
| 572 |
|
| 573 |
int asn1_GetSequence(ASN1_const_CTX *c, long *length); |
| 574 |
void asn1_add_error(const unsigned char *address, int offset); |
| 575 |
#ifdef __cplusplus
|
| 576 |
} |
| 577 |
#endif
|
| 578 |
|
| 579 |
#endif
|