asn1_mac.h
上传用户:yisoukefu
上传日期:2020-08-09
资源大小:39506k
文件大小:19k
源码类别:

其他游戏

开发平台:

Visual C++

  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. #ifndef HEADER_ASN1_MAC_H
  59. #define HEADER_ASN1_MAC_H
  60. #include <openssl/asn1.h>
  61. #ifdef  __cplusplus
  62. extern "C" {
  63. #endif
  64. #ifndef ASN1_MAC_ERR_LIB
  65. #define ASN1_MAC_ERR_LIB ERR_LIB_ASN1
  66. #endif 
  67. #define ASN1_MAC_H_err(f,r,line) 
  68. ERR_PUT_error(ASN1_MAC_ERR_LIB,(f),(r),__FILE__,(line))
  69. #define M_ASN1_D2I_vars(a,type,func) 
  70. ASN1_const_CTX c; 
  71. type ret=NULL; 
  72. c.pp=(const unsigned char **)pp; 
  73. c.q= *(const unsigned char **)pp; 
  74. c.error=ERR_R_NESTED_ASN1_ERROR; 
  75. if ((a == NULL) || ((*a) == NULL)) 
  76. { if ((ret=(type)func()) == NULL) 
  77. { c.line=__LINE__; goto err; } } 
  78. else ret=(*a);
  79. #define M_ASN1_D2I_Init() 
  80. c.p= *(const unsigned char **)pp; 
  81. c.max=(length == 0)?0:(c.p+length);
  82. #define M_ASN1_D2I_Finish_2(a) 
  83. if (!asn1_const_Finish(&c)) 
  84. { c.line=__LINE__; goto err; } 
  85. *(const unsigned char **)pp=c.p; 
  86. if (a != NULL) (*a)=ret; 
  87. return(ret);
  88. #define M_ASN1_D2I_Finish(a,func,e) 
  89. M_ASN1_D2I_Finish_2(a); 
  90. err:
  91. ASN1_MAC_H_err((e),c.error,c.line); 
  92. asn1_add_error(*(const unsigned char **)pp,(int)(c.q- *pp)); 
  93. if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); 
  94. return(NULL)
  95. #define M_ASN1_D2I_start_sequence() 
  96. if (!asn1_GetSequence(&c,&length)) 
  97. { c.line=__LINE__; goto err; }
  98. /* Begin reading ASN1 without a surrounding sequence */
  99. #define M_ASN1_D2I_begin() 
  100. c.slen = length;
  101. /* End reading ASN1 with no check on length */
  102. #define M_ASN1_D2I_Finish_nolen(a, func, e) 
  103. *pp=c.p; 
  104. if (a != NULL) (*a)=ret; 
  105. return(ret); 
  106. err:
  107. ASN1_MAC_H_err((e),c.error,c.line); 
  108. asn1_add_error(*pp,(int)(c.q- *pp)); 
  109. if ((ret != NULL) && ((a == NULL) || (*a != ret))) func(ret); 
  110. return(NULL)
  111. #define M_ASN1_D2I_end_sequence() 
  112. (((c.inf&1) == 0)?(c.slen <= 0): 
  113. (c.eos=ASN1_const_check_infinite_end(&c.p,c.slen)))
  114. /* Don't use this with d2i_ASN1_BOOLEAN() */
  115. #define M_ASN1_D2I_get(b, func) 
  116. c.q=c.p; 
  117. if (func(&(b),&c.p,c.slen) == NULL) 
  118. {c.line=__LINE__; goto err; } 
  119. c.slen-=(c.p-c.q);
  120. /* Don't use this with d2i_ASN1_BOOLEAN() */
  121. #define M_ASN1_D2I_get_x(type,b,func) 
  122. c.q=c.p; 
  123. if (((D2I_OF(type))func)(&(b),&c.p,c.slen) == NULL) 
  124. {c.line=__LINE__; goto err; } 
  125. c.slen-=(c.p-c.q);
  126. /* use this instead () */
  127. #define M_ASN1_D2I_get_int(b,func) 
  128. c.q=c.p; 
  129. if (func(&(b),&c.p,c.slen) < 0) 
  130. {c.line=__LINE__; goto err; } 
  131. c.slen-=(c.p-c.q);
  132. #define M_ASN1_D2I_get_opt(b,func,type) 
  133. if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) 
  134. == (V_ASN1_UNIVERSAL|(type)))) 
  135. M_ASN1_D2I_get(b,func); 
  136. }
  137. #define M_ASN1_D2I_get_imp(b,func, type) 
  138. M_ASN1_next=(_tmp& V_ASN1_CONSTRUCTED)|type; 
  139. c.q=c.p; 
  140. if (func(&(b),&c.p,c.slen) == NULL) 
  141. {c.line=__LINE__; M_ASN1_next_prev = _tmp; goto err; } 
  142. c.slen-=(c.p-c.q);
  143. M_ASN1_next_prev=_tmp;
  144. #define M_ASN1_D2I_get_IMP_opt(b,func,tag,type) 
  145. if ((c.slen != 0) && ((M_ASN1_next & (~V_ASN1_CONSTRUCTED)) == 
  146. (V_ASN1_CONTEXT_SPECIFIC|(tag)))) 
  147. unsigned char _tmp = M_ASN1_next; 
  148. M_ASN1_D2I_get_imp(b,func, type);
  149. }
  150. #define M_ASN1_D2I_get_set(r,func,free_func) 
  151. M_ASN1_D2I_get_imp_set(r,func,free_func, 
  152. V_ASN1_SET,V_ASN1_UNIVERSAL);
  153. #define M_ASN1_D2I_get_set_type(type,r,func,free_func) 
  154. M_ASN1_D2I_get_imp_set_type(type,r,func,free_func, 
  155. V_ASN1_SET,V_ASN1_UNIVERSAL);
  156. #define M_ASN1_D2I_get_set_opt(r,func,free_func) 
  157. if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| 
  158. V_ASN1_CONSTRUCTED|V_ASN1_SET)))
  159. { M_ASN1_D2I_get_set(r,func,free_func); }
  160. #define M_ASN1_D2I_get_set_opt_type(type,r,func,free_func) 
  161. if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| 
  162. V_ASN1_CONSTRUCTED|V_ASN1_SET)))
  163. { M_ASN1_D2I_get_set_type(type,r,func,free_func); }
  164. #define M_ASN1_I2D_len_SET_opt(a,f) 
  165. if ((a != NULL) && (sk_num(a) != 0)) 
  166. M_ASN1_I2D_len_SET(a,f);
  167. #define M_ASN1_I2D_put_SET_opt(a,f) 
  168. if ((a != NULL) && (sk_num(a) != 0)) 
  169. M_ASN1_I2D_put_SET(a,f);
  170. #define M_ASN1_I2D_put_SEQUENCE_opt(a,f) 
  171. if ((a != NULL) && (sk_num(a) != 0)) 
  172. M_ASN1_I2D_put_SEQUENCE(a,f);
  173. #define M_ASN1_I2D_put_SEQUENCE_opt_type(type,a,f) 
  174. if ((a != NULL) && (sk_##type##_num(a) != 0)) 
  175. M_ASN1_I2D_put_SEQUENCE_type(type,a,f);
  176. #define M_ASN1_D2I_get_IMP_set_opt(b,func,free_func,tag) 
  177. if ((c.slen != 0) && 
  178. (M_ASN1_next == 
  179. (V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))
  180. M_ASN1_D2I_get_imp_set(b,func,free_func,
  181. tag,V_ASN1_CONTEXT_SPECIFIC); 
  182. }
  183. #define M_ASN1_D2I_get_IMP_set_opt_type(type,b,func,free_func,tag) 
  184. if ((c.slen != 0) && 
  185. (M_ASN1_next == 
  186. (V_ASN1_CONTEXT_SPECIFIC|V_ASN1_CONSTRUCTED|(tag))))
  187. M_ASN1_D2I_get_imp_set_type(type,b,func,free_func,
  188. tag,V_ASN1_CONTEXT_SPECIFIC); 
  189. }
  190. #define M_ASN1_D2I_get_seq(r,func,free_func) 
  191. M_ASN1_D2I_get_imp_set(r,func,free_func,
  192. V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL);
  193. #define M_ASN1_D2I_get_seq_type(type,r,func,free_func) 
  194. M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,
  195.     V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL)
  196. #define M_ASN1_D2I_get_seq_opt(r,func,free_func) 
  197. if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| 
  198. V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))
  199. { M_ASN1_D2I_get_seq(r,func,free_func); }
  200. #define M_ASN1_D2I_get_seq_opt_type(type,r,func,free_func) 
  201. if ((c.slen != 0) && (M_ASN1_next == (V_ASN1_UNIVERSAL| 
  202. V_ASN1_CONSTRUCTED|V_ASN1_SEQUENCE)))
  203. { M_ASN1_D2I_get_seq_type(type,r,func,free_func); }
  204. #define M_ASN1_D2I_get_IMP_set(r,func,free_func,x) 
  205. M_ASN1_D2I_get_imp_set(r,func,free_func,
  206. x,V_ASN1_CONTEXT_SPECIFIC);
  207. #define M_ASN1_D2I_get_IMP_set_type(type,r,func,free_func,x) 
  208. M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,
  209. x,V_ASN1_CONTEXT_SPECIFIC);
  210. #define M_ASN1_D2I_get_imp_set(r,func,free_func,a,b) 
  211. c.q=c.p; 
  212. if (d2i_ASN1_SET(&(r),&c.p,c.slen,(char *(*)())func,
  213. (void (*)())free_func,a,b) == NULL) 
  214. { c.line=__LINE__; goto err; } 
  215. c.slen-=(c.p-c.q);
  216. #define M_ASN1_D2I_get_imp_set_type(type,r,func,free_func,a,b) 
  217. c.q=c.p; 
  218. if (d2i_ASN1_SET_OF_##type(&(r),&c.p,c.slen,func,
  219.    free_func,a,b) == NULL) 
  220. { c.line=__LINE__; goto err; } 
  221. c.slen-=(c.p-c.q);
  222. #define M_ASN1_D2I_get_set_strings(r,func,a,b) 
  223. c.q=c.p; 
  224. if (d2i_ASN1_STRING_SET(&(r),&c.p,c.slen,a,b) == NULL) 
  225. { c.line=__LINE__; goto err; } 
  226. c.slen-=(c.p-c.q);
  227. #define M_ASN1_D2I_get_EXP_opt(r,func,tag) 
  228. if ((c.slen != 0L) && (M_ASN1_next == 
  229. (V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) 
  230. int Tinf,Ttag,Tclass; 
  231. long Tlen; 
  232. c.q=c.p; 
  233. Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); 
  234. if (Tinf & 0x80) 
  235. { c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; 
  236. c.line=__LINE__; goto err; } 
  237. if (Tinf == (V_ASN1_CONSTRUCTED+1)) 
  238. Tlen = c.slen - (c.p - c.q) - 2; 
  239. if (func(&(r),&c.p,Tlen) == NULL) 
  240. { c.line=__LINE__; goto err; } 
  241. if (Tinf == (V_ASN1_CONSTRUCTED+1)) { 
  242. Tlen = c.slen - (c.p - c.q); 
  243. if(!ASN1_const_check_infinite_end(&c.p, Tlen)) 
  244. { c.error=ERR_R_MISSING_ASN1_EOS; 
  245. c.line=__LINE__; goto err; } 
  246. }
  247. c.slen-=(c.p-c.q); 
  248. }
  249. #define M_ASN1_D2I_get_EXP_set_opt(r,func,free_func,tag,b) 
  250. if ((c.slen != 0) && (M_ASN1_next == 
  251. (V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) 
  252. int Tinf,Ttag,Tclass; 
  253. long Tlen; 
  254. c.q=c.p; 
  255. Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); 
  256. if (Tinf & 0x80) 
  257. { c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; 
  258. c.line=__LINE__; goto err; } 
  259. if (Tinf == (V_ASN1_CONSTRUCTED+1)) 
  260. Tlen = c.slen - (c.p - c.q) - 2; 
  261. if (d2i_ASN1_SET(&(r),&c.p,Tlen,(char *(*)())func, 
  262. (void (*)())free_func, 
  263. b,V_ASN1_UNIVERSAL) == NULL) 
  264. { c.line=__LINE__; goto err; } 
  265. if (Tinf == (V_ASN1_CONSTRUCTED+1)) { 
  266. Tlen = c.slen - (c.p - c.q); 
  267. if(!ASN1_check_infinite_end(&c.p, Tlen)) 
  268. { c.error=ERR_R_MISSING_ASN1_EOS; 
  269. c.line=__LINE__; goto err; } 
  270. }
  271. c.slen-=(c.p-c.q); 
  272. }
  273. #define M_ASN1_D2I_get_EXP_set_opt_type(type,r,func,free_func,tag,b) 
  274. if ((c.slen != 0) && (M_ASN1_next == 
  275. (V_ASN1_CONSTRUCTED|V_ASN1_CONTEXT_SPECIFIC|tag))) 
  276. int Tinf,Ttag,Tclass; 
  277. long Tlen; 
  278. c.q=c.p; 
  279. Tinf=ASN1_get_object(&c.p,&Tlen,&Ttag,&Tclass,c.slen); 
  280. if (Tinf & 0x80) 
  281. { c.error=ERR_R_BAD_ASN1_OBJECT_HEADER; 
  282. c.line=__LINE__; goto err; } 
  283. if (Tinf == (V_ASN1_CONSTRUCTED+1)) 
  284. Tlen = c.slen - (c.p - c.q) - 2; 
  285. if (d2i_ASN1_SET_OF_##type(&(r),&c.p,Tlen,func, 
  286. free_func,b,V_ASN1_UNIVERSAL) == NULL) 
  287. { c.line=__LINE__; goto err; } 
  288. if (Tinf == (V_ASN1_CONSTRUCTED+1)) { 
  289. Tlen = c.slen - (c.p - c.q); 
  290. if(!ASN1_check_infinite_end(&c.p, Tlen)) 
  291. { c.error=ERR_R_MISSING_ASN1_EOS; 
  292. c.line=__LINE__; goto err; } 
  293. }
  294. c.slen-=(c.p-c.q); 
  295. }
  296. /* New macros */
  297. #define M_ASN1_New_Malloc(ret,type) 
  298. if ((ret=(type *)OPENSSL_malloc(sizeof(type))) == NULL) 
  299. { c.line=__LINE__; goto err2; }
  300. #define M_ASN1_New(arg,func) 
  301. if (((arg)=func()) == NULL) return(NULL)
  302. #define M_ASN1_New_Error(a) 
  303. /* err: ASN1_MAC_H_err((a),ERR_R_NESTED_ASN1_ERROR,c.line); 
  304. return(NULL);*/ 
  305. err2: ASN1_MAC_H_err((a),ERR_R_MALLOC_FAILURE,c.line); 
  306. return(NULL)
  307. /* BIG UGLY WARNING!  This is so damn ugly I wanna puke.  Unfortunately,
  308.    some macros that use ASN1_const_CTX still insist on writing in the input
  309.    stream.  ARGH!  ARGH!  ARGH!  Let's get rid of this macro package.
  310.    Please? -- Richard Levitte */
  311. #define M_ASN1_next (*((unsigned char *)(c.p)))
  312. #define M_ASN1_next_prev (*((unsigned char *)(c.q)))
  313. /*************************************************/
  314. #define M_ASN1_I2D_vars(a) int r=0,ret=0; 
  315. unsigned char *p; 
  316. if (a == NULL) return(0)
  317. /* Length Macros */
  318. #define M_ASN1_I2D_len(a,f) ret+=f(a,NULL)
  319. #define M_ASN1_I2D_len_IMP_opt(a,f) if (a != NULL) M_ASN1_I2D_len(a,f)
  320. #define M_ASN1_I2D_len_SET(a,f) 
  321. ret+=i2d_ASN1_SET(a,NULL,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET);
  322. #define M_ASN1_I2D_len_SET_type(type,a,f) 
  323. ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SET, 
  324.     V_ASN1_UNIVERSAL,IS_SET);
  325. #define M_ASN1_I2D_len_SEQUENCE(a,f) 
  326. ret+=i2d_ASN1_SET(a,NULL,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, 
  327.   IS_SEQUENCE);
  328. #define M_ASN1_I2D_len_SEQUENCE_type(type,a,f) 
  329. ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,V_ASN1_SEQUENCE, 
  330.     V_ASN1_UNIVERSAL,IS_SEQUENCE)
  331. #define M_ASN1_I2D_len_SEQUENCE_opt(a,f) 
  332. if ((a != NULL) && (sk_num(a) != 0)) 
  333. M_ASN1_I2D_len_SEQUENCE(a,f);
  334. #define M_ASN1_I2D_len_SEQUENCE_opt_type(type,a,f) 
  335. if ((a != NULL) && (sk_##type##_num(a) != 0)) 
  336. M_ASN1_I2D_len_SEQUENCE_type(type,a,f);
  337. #define M_ASN1_I2D_len_IMP_SET(a,f,x) 
  338. ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET);
  339. #define M_ASN1_I2D_len_IMP_SET_type(type,a,f,x) 
  340. ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, 
  341.     V_ASN1_CONTEXT_SPECIFIC,IS_SET);
  342. #define M_ASN1_I2D_len_IMP_SET_opt(a,f,x) 
  343. if ((a != NULL) && (sk_num(a) != 0)) 
  344. ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, 
  345.   IS_SET);
  346. #define M_ASN1_I2D_len_IMP_SET_opt_type(type,a,f,x) 
  347. if ((a != NULL) && (sk_##type##_num(a) != 0)) 
  348. ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, 
  349.        V_ASN1_CONTEXT_SPECIFIC,IS_SET);
  350. #define M_ASN1_I2D_len_IMP_SEQUENCE(a,f,x) 
  351. ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, 
  352.   IS_SEQUENCE);
  353. #define M_ASN1_I2D_len_IMP_SEQUENCE_opt(a,f,x) 
  354. if ((a != NULL) && (sk_num(a) != 0)) 
  355. ret+=i2d_ASN1_SET(a,NULL,f,x,V_ASN1_CONTEXT_SPECIFIC, 
  356.   IS_SEQUENCE);
  357. #define M_ASN1_I2D_len_IMP_SEQUENCE_opt_type(type,a,f,x) 
  358. if ((a != NULL) && (sk_##type##_num(a) != 0)) 
  359. ret+=i2d_ASN1_SET_OF_##type(a,NULL,f,x, 
  360.     V_ASN1_CONTEXT_SPECIFIC, 
  361.     IS_SEQUENCE);
  362. #define M_ASN1_I2D_len_EXP_opt(a,f,mtag,v) 
  363. if (a != NULL)
  364. v=f(a,NULL); 
  365. ret+=ASN1_object_size(1,v,mtag); 
  366. }
  367. #define M_ASN1_I2D_len_EXP_SET_opt(a,f,mtag,tag,v) 
  368. if ((a != NULL) && (sk_num(a) != 0))
  369. v=i2d_ASN1_SET(a,NULL,f,tag,V_ASN1_UNIVERSAL,IS_SET); 
  370. ret+=ASN1_object_size(1,v,mtag); 
  371. }
  372. #define M_ASN1_I2D_len_EXP_SEQUENCE_opt(a,f,mtag,tag,v) 
  373. if ((a != NULL) && (sk_num(a) != 0))
  374. v=i2d_ASN1_SET(a,NULL,f,tag,V_ASN1_UNIVERSAL, 
  375.        IS_SEQUENCE); 
  376. ret+=ASN1_object_size(1,v,mtag); 
  377. }
  378. #define M_ASN1_I2D_len_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) 
  379. if ((a != NULL) && (sk_##type##_num(a) != 0))
  380. v=i2d_ASN1_SET_OF_##type(a,NULL,f,tag, 
  381.  V_ASN1_UNIVERSAL, 
  382.  IS_SEQUENCE); 
  383. ret+=ASN1_object_size(1,v,mtag); 
  384. }
  385. /* Put Macros */
  386. #define M_ASN1_I2D_put(a,f) f(a,&p)
  387. #define M_ASN1_I2D_put_IMP_opt(a,f,t)
  388. if (a != NULL) 
  389. unsigned char *q=p; 
  390. f(a,&p); 
  391. *q=(V_ASN1_CONTEXT_SPECIFIC|t|(*q&V_ASN1_CONSTRUCTED));
  392. }
  393. #define M_ASN1_I2D_put_SET(a,f) i2d_ASN1_SET(a,&p,f,V_ASN1_SET,
  394. V_ASN1_UNIVERSAL,IS_SET)
  395. #define M_ASN1_I2D_put_SET_type(type,a,f) 
  396.      i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SET,V_ASN1_UNIVERSAL,IS_SET)
  397. #define M_ASN1_I2D_put_IMP_SET(a,f,x) i2d_ASN1_SET(a,&p,f,x,
  398. V_ASN1_CONTEXT_SPECIFIC,IS_SET)
  399. #define M_ASN1_I2D_put_IMP_SET_type(type,a,f,x) 
  400.      i2d_ASN1_SET_OF_##type(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC,IS_SET)
  401. #define M_ASN1_I2D_put_IMP_SEQUENCE(a,f,x) i2d_ASN1_SET(a,&p,f,x,
  402. V_ASN1_CONTEXT_SPECIFIC,IS_SEQUENCE)
  403. #define M_ASN1_I2D_put_SEQUENCE(a,f) i2d_ASN1_SET(a,&p,f,V_ASN1_SEQUENCE,
  404.      V_ASN1_UNIVERSAL,IS_SEQUENCE)
  405. #define M_ASN1_I2D_put_SEQUENCE_type(type,a,f) 
  406.      i2d_ASN1_SET_OF_##type(a,&p,f,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL, 
  407.     IS_SEQUENCE)
  408. #define M_ASN1_I2D_put_SEQUENCE_opt(a,f) 
  409. if ((a != NULL) && (sk_num(a) != 0)) 
  410. M_ASN1_I2D_put_SEQUENCE(a,f);
  411. #define M_ASN1_I2D_put_IMP_SET_opt(a,f,x) 
  412. if ((a != NULL) && (sk_num(a) != 0)) 
  413. { i2d_ASN1_SET(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC, 
  414.        IS_SET); }
  415. #define M_ASN1_I2D_put_IMP_SET_opt_type(type,a,f,x) 
  416. if ((a != NULL) && (sk_##type##_num(a) != 0)) 
  417. { i2d_ASN1_SET_OF_##type(a,&p,f,x, 
  418.  V_ASN1_CONTEXT_SPECIFIC, 
  419.  IS_SET); }
  420. #define M_ASN1_I2D_put_IMP_SEQUENCE_opt(a,f,x) 
  421. if ((a != NULL) && (sk_num(a) != 0)) 
  422. { i2d_ASN1_SET(a,&p,f,x,V_ASN1_CONTEXT_SPECIFIC, 
  423.        IS_SEQUENCE); }
  424. #define M_ASN1_I2D_put_IMP_SEQUENCE_opt_type(type,a,f,x) 
  425. if ((a != NULL) && (sk_##type##_num(a) != 0)) 
  426. { i2d_ASN1_SET_OF_##type(a,&p,f,x, 
  427.  V_ASN1_CONTEXT_SPECIFIC, 
  428.  IS_SEQUENCE); }
  429. #define M_ASN1_I2D_put_EXP_opt(a,f,tag,v) 
  430. if (a != NULL) 
  431. ASN1_put_object(&p,1,v,tag,V_ASN1_CONTEXT_SPECIFIC); 
  432. f(a,&p); 
  433. }
  434. #define M_ASN1_I2D_put_EXP_SET_opt(a,f,mtag,tag,v) 
  435. if ((a != NULL) && (sk_num(a) != 0)) 
  436. ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); 
  437. i2d_ASN1_SET(a,&p,f,tag,V_ASN1_UNIVERSAL,IS_SET); 
  438. }
  439. #define M_ASN1_I2D_put_EXP_SEQUENCE_opt(a,f,mtag,tag,v) 
  440. if ((a != NULL) && (sk_num(a) != 0)) 
  441. ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); 
  442. i2d_ASN1_SET(a,&p,f,tag,V_ASN1_UNIVERSAL,IS_SEQUENCE); 
  443. }
  444. #define M_ASN1_I2D_put_EXP_SEQUENCE_opt_type(type,a,f,mtag,tag,v) 
  445. if ((a != NULL) && (sk_##type##_num(a) != 0)) 
  446. ASN1_put_object(&p,1,v,mtag,V_ASN1_CONTEXT_SPECIFIC); 
  447. i2d_ASN1_SET_OF_##type(a,&p,f,tag,V_ASN1_UNIVERSAL, 
  448.        IS_SEQUENCE); 
  449. }
  450. #define M_ASN1_I2D_seq_total() 
  451. r=ASN1_object_size(1,ret,V_ASN1_SEQUENCE); 
  452. if (pp == NULL) return(r); 
  453. p= *pp; 
  454. ASN1_put_object(&p,1,ret,V_ASN1_SEQUENCE,V_ASN1_UNIVERSAL)
  455. #define M_ASN1_I2D_INF_seq_start(tag,ctx) 
  456. *(p++)=(V_ASN1_CONSTRUCTED|(tag)|(ctx)); 
  457. *(p++)=0x80
  458. #define M_ASN1_I2D_INF_seq_end() *(p++)=0x00; *(p++)=0x00
  459. #define M_ASN1_I2D_finish() *pp=p; 
  460. return(r);
  461. int asn1_GetSequence(ASN1_const_CTX *c, long *length);
  462. void asn1_add_error(const unsigned char *address,int offset);
  463. #ifdef  __cplusplus
  464. }
  465. #endif
  466. #endif