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

其他游戏

开发平台:

Visual C++

  1. /* crypto/bio/bf_nbio.c */
  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. #include <stdio.h>
  59. #include <errno.h>
  60. #include "cryptlib.h"
  61. #include <openssl/rand.h>
  62. #include <openssl/bio.h>
  63. /* BIO_put and BIO_get both add to the digest,
  64.  * BIO_gets returns the digest */
  65. static int nbiof_write(BIO *h,const char *buf,int num);
  66. static int nbiof_read(BIO *h,char *buf,int size);
  67. static int nbiof_puts(BIO *h,const char *str);
  68. static int nbiof_gets(BIO *h,char *str,int size);
  69. static long nbiof_ctrl(BIO *h,int cmd,long arg1,void *arg2);
  70. static int nbiof_new(BIO *h);
  71. static int nbiof_free(BIO *data);
  72. static long nbiof_callback_ctrl(BIO *h,int cmd,bio_info_cb *fp);
  73. typedef struct nbio_test_st
  74. {
  75. /* only set if we sent a 'should retry' error */
  76. int lrn;
  77. int lwn;
  78. } NBIO_TEST;
  79. static BIO_METHOD methods_nbiof=
  80. {
  81. BIO_TYPE_NBIO_TEST,
  82. "non-blocking IO test filter",
  83. nbiof_write,
  84. nbiof_read,
  85. nbiof_puts,
  86. nbiof_gets,
  87. nbiof_ctrl,
  88. nbiof_new,
  89. nbiof_free,
  90. nbiof_callback_ctrl,
  91. };
  92. BIO_METHOD *BIO_f_nbio_test(void)
  93. {
  94. return(&methods_nbiof);
  95. }
  96. static int nbiof_new(BIO *bi)
  97. {
  98. NBIO_TEST *nt;
  99. if (!(nt=(NBIO_TEST *)OPENSSL_malloc(sizeof(NBIO_TEST)))) return(0);
  100. nt->lrn= -1;
  101. nt->lwn= -1;
  102. bi->ptr=(char *)nt;
  103. bi->init=1;
  104. bi->flags=0;
  105. return(1);
  106. }
  107. static int nbiof_free(BIO *a)
  108. {
  109. if (a == NULL) return(0);
  110. if (a->ptr != NULL)
  111. OPENSSL_free(a->ptr);
  112. a->ptr=NULL;
  113. a->init=0;
  114. a->flags=0;
  115. return(1);
  116. }
  117. static int nbiof_read(BIO *b, char *out, int outl)
  118. {
  119. NBIO_TEST *nt;
  120. int ret=0;
  121. #if 1
  122. int num;
  123. unsigned char n;
  124. #endif
  125. if (out == NULL) return(0);
  126. if (b->next_bio == NULL) return(0);
  127. nt=(NBIO_TEST *)b->ptr;
  128. BIO_clear_retry_flags(b);
  129. #if 1
  130. RAND_pseudo_bytes(&n,1);
  131. num=(n&0x07);
  132. if (outl > num) outl=num;
  133. if (num == 0)
  134. {
  135. ret= -1;
  136. BIO_set_retry_read(b);
  137. }
  138. else
  139. #endif
  140. {
  141. ret=BIO_read(b->next_bio,out,outl);
  142. if (ret < 0)
  143. BIO_copy_next_retry(b);
  144. }
  145. return(ret);
  146. }
  147. static int nbiof_write(BIO *b, const char *in, int inl)
  148. {
  149. NBIO_TEST *nt;
  150. int ret=0;
  151. int num;
  152. unsigned char n;
  153. if ((in == NULL) || (inl <= 0)) return(0);
  154. if (b->next_bio == NULL) return(0);
  155. nt=(NBIO_TEST *)b->ptr;
  156. BIO_clear_retry_flags(b);
  157. #if 1
  158. if (nt->lwn > 0)
  159. {
  160. num=nt->lwn;
  161. nt->lwn=0;
  162. }
  163. else
  164. {
  165. RAND_pseudo_bytes(&n,1);
  166. num=(n&7);
  167. }
  168. if (inl > num) inl=num;
  169. if (num == 0)
  170. {
  171. ret= -1;
  172. BIO_set_retry_write(b);
  173. }
  174. else
  175. #endif
  176. {
  177. ret=BIO_write(b->next_bio,in,inl);
  178. if (ret < 0)
  179. {
  180. BIO_copy_next_retry(b);
  181. nt->lwn=inl;
  182. }
  183. }
  184. return(ret);
  185. }
  186. static long nbiof_ctrl(BIO *b, int cmd, long num, void *ptr)
  187. {
  188. long ret;
  189. if (b->next_bio == NULL) return(0);
  190. switch (cmd)
  191. {
  192.         case BIO_C_DO_STATE_MACHINE:
  193. BIO_clear_retry_flags(b);
  194. ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
  195. BIO_copy_next_retry(b);
  196. break;
  197. case BIO_CTRL_DUP:
  198. ret=0L;
  199. break;
  200. default:
  201. ret=BIO_ctrl(b->next_bio,cmd,num,ptr);
  202. break;
  203. }
  204. return(ret);
  205. }
  206. static long nbiof_callback_ctrl(BIO *b, int cmd, bio_info_cb *fp)
  207. {
  208. long ret=1;
  209. if (b->next_bio == NULL) return(0);
  210. switch (cmd)
  211. {
  212. default:
  213. ret=BIO_callback_ctrl(b->next_bio,cmd,fp);
  214. break;
  215. }
  216. return(ret);
  217. }
  218. static int nbiof_gets(BIO *bp, char *buf, int size)
  219. {
  220. if (bp->next_bio == NULL) return(0);
  221. return(BIO_gets(bp->next_bio,buf,size));
  222. }
  223. static int nbiof_puts(BIO *bp, const char *str)
  224. {
  225. if (bp->next_bio == NULL) return(0);
  226. return(BIO_puts(bp->next_bio,str));
  227. }