开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 游戏 > 其他游戏 > 查看源码
bss_acpt.c
资源名称：wow-313-source.rar　[点击查看]
上传用户：yisoukefu
上传日期：2020-08-09
资源大小：39506k
文件大小：11k
源码类别：

其他游戏

开发平台：

Visual C++

bss_acpt.c：源码内容
  1. /* crypto/bio/bss_acpt.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.  */
  59. #include <stdio.h>
  60. #include <errno.h>
  61. #define USE_SOCKETS
  62. #include "cryptlib.h"
  63. #include <openssl/bio.h>
  65. #ifndef OPENSSL_NO_SOCK
  67. #ifdef OPENSSL_SYS_WIN16
  68. #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
  69. #else
  70. #define SOCKET_PROTOCOL IPPROTO_TCP
  71. #endif
  73. #if (defined(OPENSSL_SYS_VMS) && __VMS_VER < 70000000)
  74. /* FIONBIO used as a switch to enable ioctl, and that isn't in VMS < 7.0 */
  75. #undef FIONBIO
  76. #endif
  78. typedef struct bio_accept_st
  79. {
  80. int state;
  81. char *param_addr;
  83. int accept_sock;
  84. int accept_nbio;
  86. char *addr;
  87. int nbio;
  88. /* If 0, it means normal, if 1, do a connect on bind failure,
  89.  * and if there is no-one listening, bind with SO_REUSEADDR.
  90.  * If 2, always use SO_REUSEADDR. */
  91. int bind_mode;
  92. BIO *bio_chain;
  93. } BIO_ACCEPT;
  95. static int acpt_write(BIO *h, const char *buf, int num);
  96. static int acpt_read(BIO *h, char *buf, int size);
  97. static int acpt_puts(BIO *h, const char *str);
  98. static long acpt_ctrl(BIO *h, int cmd, long arg1, void *arg2);
  99. static int acpt_new(BIO *h);
  100. static int acpt_free(BIO *data);
  101. static int acpt_state(BIO *b, BIO_ACCEPT *c);
  102. static void acpt_close_socket(BIO *data);
  103. BIO_ACCEPT *BIO_ACCEPT_new(void );
  104. void BIO_ACCEPT_free(BIO_ACCEPT *a);
  106. #define ACPT_S_BEFORE 1
  107. #define ACPT_S_GET_ACCEPT_SOCKET 2
  108. #define ACPT_S_OK 3
  110. static BIO_METHOD methods_acceptp=
  111. {
  112. BIO_TYPE_ACCEPT,
  113. "socket accept",
  114. acpt_write,
  115. acpt_read,
  116. acpt_puts,
  117. NULL, /* connect_gets, */
  118. acpt_ctrl,
  119. acpt_new,
  120. acpt_free,
  121. NULL,
  122. };
  124. BIO_METHOD *BIO_s_accept(void)
  125. {
  126. return(&methods_acceptp);
  127. }
  129. static int acpt_new(BIO *bi)
  130. {
  131. BIO_ACCEPT *ba;
  133. bi->init=0;
  134. bi->num=INVALID_SOCKET;
  135. bi->flags=0;
  136. if ((ba=BIO_ACCEPT_new()) == NULL)
  137. return(0);
  138. bi->ptr=(char *)ba;
  139. ba->state=ACPT_S_BEFORE;
  140. bi->shutdown=1;
  141. return(1);
  142. }
  144. BIO_ACCEPT *BIO_ACCEPT_new(void)
  145. {
  146. BIO_ACCEPT *ret;
  148. if ((ret=(BIO_ACCEPT *)OPENSSL_malloc(sizeof(BIO_ACCEPT))) == NULL)
  149. return(NULL);
  151. memset(ret,0,sizeof(BIO_ACCEPT));
  152. ret->accept_sock=INVALID_SOCKET;
  153. ret->bind_mode=BIO_BIND_NORMAL;
  154. return(ret);
  155. }
  157. void BIO_ACCEPT_free(BIO_ACCEPT *a)
  158. {
  159. if(a == NULL)
  160.     return;
  162. if (a->param_addr != NULL) OPENSSL_free(a->param_addr);
  163. if (a->addr != NULL) OPENSSL_free(a->addr);
  164. if (a->bio_chain != NULL) BIO_free(a->bio_chain);
  165. OPENSSL_free(a);
  166. }
  168. static void acpt_close_socket(BIO *bio)
  169. {
  170. BIO_ACCEPT *c;
  172. c=(BIO_ACCEPT *)bio->ptr;
  173. if (c->accept_sock != INVALID_SOCKET)
  174. {
  175. shutdown(c->accept_sock,2);
  176. closesocket(c->accept_sock);
  177. c->accept_sock=INVALID_SOCKET;
  178. bio->num=INVALID_SOCKET;
  179. }
  180. }
  182. static int acpt_free(BIO *a)
  183. {
  184. BIO_ACCEPT *data;
  186. if (a == NULL) return(0);
  187. data=(BIO_ACCEPT *)a->ptr;
  188.  
  189. if (a->shutdown)
  190. {
  191. acpt_close_socket(a);
  192. BIO_ACCEPT_free(data);
  193. a->ptr=NULL;
  194. a->flags=0;
  195. a->init=0;
  196. }
  197. return(1);
  198. }
  200. static int acpt_state(BIO *b, BIO_ACCEPT *c)
  201. {
  202. BIO *bio=NULL,*dbio;
  203. int s= -1;
  204. int i;
  206. again:
  207. switch (c->state)
  208. {
  209. case ACPT_S_BEFORE:
  210. if (c->param_addr == NULL)
  211. {
  212. BIOerr(BIO_F_ACPT_STATE,BIO_R_NO_ACCEPT_PORT_SPECIFIED);
  213. return(-1);
  214. }
  215. s=BIO_get_accept_socket(c->param_addr,c->bind_mode);
  216. if (s == INVALID_SOCKET)
  217. return(-1);
  219. if (c->accept_nbio)
  220. {
  221. if (!BIO_socket_nbio(s,1))
  222. {
  223. closesocket(s);
  224. BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPT_SOCKET);
  225. return(-1);
  226. }
  227. }
  228. c->accept_sock=s;
  229. b->num=s;
  230. c->state=ACPT_S_GET_ACCEPT_SOCKET;
  231. return(1);
  232. /* break; */
  233. case ACPT_S_GET_ACCEPT_SOCKET:
  234. if (b->next_bio != NULL)
  235. {
  236. c->state=ACPT_S_OK;
  237. goto again;
  238. }
  239. BIO_clear_retry_flags(b);
  240. b->retry_reason=0;
  241. i=BIO_accept(c->accept_sock,&(c->addr));
  243. /* -2 return means we should retry */
  244. if(i == -2)
  245. {
  246. BIO_set_retry_special(b);
  247. b->retry_reason=BIO_RR_ACCEPT;
  248. return -1;
  249. }
  251. if (i < 0) return(i);
  253. bio=BIO_new_socket(i,BIO_CLOSE);
  254. if (bio == NULL) goto err;
  256. BIO_set_callback(bio,BIO_get_callback(b));
  257. BIO_set_callback_arg(bio,BIO_get_callback_arg(b));
  259. if (c->nbio)
  260. {
  261. if (!BIO_socket_nbio(i,1))
  262. {
  263. BIOerr(BIO_F_ACPT_STATE,BIO_R_ERROR_SETTING_NBIO_ON_ACCEPTED_SOCKET);
  264. goto err;
  265. }
  266. }
  268. /* If the accept BIO has an bio_chain, we dup it and
  269.  * put the new socket at the end. */
  270. if (c->bio_chain != NULL)
  271. {
  272. if ((dbio=BIO_dup_chain(c->bio_chain)) == NULL)
  273. goto err;
  274. if (!BIO_push(dbio,bio)) goto err;
  275. bio=dbio;
  276. }
  277. if (BIO_push(b,bio) == NULL) goto err;
  279. c->state=ACPT_S_OK;
  280. return(1);
  281. err:
  282. if (bio != NULL)
  283. BIO_free(bio);
  284. else if (s >= 0)
  285. closesocket(s);
  286. return(0);
  287. /* break; */
  288. case ACPT_S_OK:
  289. if (b->next_bio == NULL)
  290. {
  291. c->state=ACPT_S_GET_ACCEPT_SOCKET;
  292. goto again;
  293. }
  294. return(1);
  295. /* break; */
  296. default:
  297. return(0);
  298. /* break; */
  299. }
  301. }
  303. static int acpt_read(BIO *b, char *out, int outl)
  304. {
  305. int ret=0;
  306. BIO_ACCEPT *data;
  308. BIO_clear_retry_flags(b);
  309. data=(BIO_ACCEPT *)b->ptr;
  311. while (b->next_bio == NULL)
  312. {
  313. ret=acpt_state(b,data);
  314. if (ret <= 0) return(ret);
  315. }
  317. ret=BIO_read(b->next_bio,out,outl);
  318. BIO_copy_next_retry(b);
  319. return(ret);
  320. }
  322. static int acpt_write(BIO *b, const char *in, int inl)
  323. {
  324. int ret;
  325. BIO_ACCEPT *data;
  327. BIO_clear_retry_flags(b);
  328. data=(BIO_ACCEPT *)b->ptr;
  330. while (b->next_bio == NULL)
  331. {
  332. ret=acpt_state(b,data);
  333. if (ret <= 0) return(ret);
  334. }
  336. ret=BIO_write(b->next_bio,in,inl);
  337. BIO_copy_next_retry(b);
  338. return(ret);
  339. }
  341. static long acpt_ctrl(BIO *b, int cmd, long num, void *ptr)
  342. {
  343. BIO *dbio;
  344. int *ip;
  345. long ret=1;
  346. BIO_ACCEPT *data;
  347. char **pp;
  349. data=(BIO_ACCEPT *)b->ptr;
  351. switch (cmd)
  352. {
  353. case BIO_CTRL_RESET:
  354. ret=0;
  355. data->state=ACPT_S_BEFORE;
  356. acpt_close_socket(b);
  357. b->flags=0;
  358. break;
  359. case BIO_C_DO_STATE_MACHINE:
  360. /* use this one to start the connection */
  361. ret=(long)acpt_state(b,data);
  362. break;
  363. case BIO_C_SET_ACCEPT:
  364. if (ptr != NULL)
  365. {
  366. if (num == 0)
  367. {
  368. b->init=1;
  369. if (data->param_addr != NULL)
  370. OPENSSL_free(data->param_addr);
  371. data->param_addr=BUF_strdup(ptr);
  372. }
  373. else if (num == 1)
  374. {
  375. data->accept_nbio=(ptr != NULL);
  376. }
  377. else if (num == 2)
  378. {
  379. if (data->bio_chain != NULL)
  380. BIO_free(data->bio_chain);
  381. data->bio_chain=(BIO *)ptr;
  382. }
  383. }
  384. break;
  385. case BIO_C_SET_NBIO:
  386. data->nbio=(int)num;
  387. break;
  388. case BIO_C_SET_FD:
  389. b->init=1;
  390. b->num= *((int *)ptr);
  391. data->accept_sock=b->num;
  392. data->state=ACPT_S_GET_ACCEPT_SOCKET;
  393. b->shutdown=(int)num;
  394. b->init=1;
  395. break;
  396. case BIO_C_GET_FD:
  397. if (b->init)
  398. {
  399. ip=(int *)ptr;
  400. if (ip != NULL)
  401. *ip=data->accept_sock;
  402. ret=data->accept_sock;
  403. }
  404. else
  405. ret= -1;
  406. break;
  407. case BIO_C_GET_ACCEPT:
  408. if (b->init)
  409. {
  410. if (ptr != NULL)
  411. {
  412. pp=(char **)ptr;
  413. *pp=data->param_addr;
  414. }
  415. else
  416. ret= -1;
  417. }
  418. else
  419. ret= -1;
  420. break;
  421. case BIO_CTRL_GET_CLOSE:
  422. ret=b->shutdown;
  423. break;
  424. case BIO_CTRL_SET_CLOSE:
  425. b->shutdown=(int)num;
  426. break;
  427. case BIO_CTRL_PENDING:
  428. case BIO_CTRL_WPENDING:
  429. ret=0;
  430. break;
  431. case BIO_CTRL_FLUSH:
  432. break;
  433. case BIO_C_SET_BIND_MODE:
  434. data->bind_mode=(int)num;
  435. break;
  436. case BIO_C_GET_BIND_MODE:
  437. ret=(long)data->bind_mode;
  438. break;
  439. case BIO_CTRL_DUP:
  440. dbio=(BIO *)ptr;
  441. /* if (data->param_port) EAY EAY
  442. BIO_set_port(dbio,data->param_port);
  443. if (data->param_hostname)
  444. BIO_set_hostname(dbio,data->param_hostname);
  445. BIO_set_nbio(dbio,data->nbio); */
  446. break;
  448. default:
  449. ret=0;
  450. break;
  451. }
  452. return(ret);
  453. }
  455. static int acpt_puts(BIO *bp, const char *str)
  456. {
  457. int n,ret;
  459. n=strlen(str);
  460. ret=acpt_write(bp,str,n);
  461. return(ret);
  462. }
  464. BIO *BIO_new_accept(char *str)
  465. {
  466. BIO *ret;
  468. ret=BIO_new(BIO_s_accept());
  469. if (ret == NULL) return(NULL);
  470. if (BIO_set_accept_port(ret,str))
  471. return(ret);
  472. else
  473. {
  474. BIO_free(ret);
  475. return(NULL);
  476. }
  477. }
  479. #endif