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

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

其他游戏

开发平台：

Visual C++

b_sock.c：源码内容
  1. /* crypto/bio/b_sock.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 <stdlib.h>
  61. #include <errno.h>
  62. #define USE_SOCKETS
  63. #include "cryptlib.h"
  64. #include <openssl/bio.h>
  65. #if defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_BSDSOCK)
  66. #include "netdb.h"
  67. #endif
  69. #ifndef OPENSSL_NO_SOCK
  71. #ifdef OPENSSL_SYS_WIN16
  72. #define SOCKET_PROTOCOL 0 /* more microsoft stupidity */
  73. #else
  74. #define SOCKET_PROTOCOL IPPROTO_TCP
  75. #endif
  77. #ifdef SO_MAXCONN
  78. #define MAX_LISTEN  SO_MAXCONN
  79. #elif defined(SOMAXCONN)
  80. #define MAX_LISTEN  SOMAXCONN
  81. #else
  82. #define MAX_LISTEN  32
  83. #endif
  85. #if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))
  86. static int wsa_init_done=0;
  87. #endif
  89. #if 0
  90. static unsigned long BIO_ghbn_hits=0L;
  91. static unsigned long BIO_ghbn_miss=0L;
  93. #define GHBN_NUM 4
  94. static struct ghbn_cache_st
  95. {
  96. char name[129];
  97. struct hostent *ent;
  98. unsigned long order;
  99. } ghbn_cache[GHBN_NUM];
  100. #endif
  102. static int get_ip(const char *str,unsigned char *ip);
  103. #if 0
  104. static void ghbn_free(struct hostent *a);
  105. static struct hostent *ghbn_dup(struct hostent *a);
  106. #endif
  107. int BIO_get_host_ip(const char *str, unsigned char *ip)
  108. {
  109. int i;
  110. int err = 1;
  111. int locked = 0;
  112. struct hostent *he;
  114. i=get_ip(str,ip);
  115. if (i < 0)
  116. {
  117. BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS);
  118. goto err;
  119. }
  121. /* At this point, we have something that is most probably correct
  122.    in some way, so let's init the socket. */
  123. if (BIO_sock_init() != 1)
  124. return 0; /* don't generate another error code here */
  126. /* If the string actually contained an IP address, we need not do
  127.    anything more */
  128. if (i > 0) return(1);
  130. /* do a gethostbyname */
  131. CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
  132. locked = 1;
  133. he=BIO_gethostbyname(str);
  134. if (he == NULL)
  135. {
  136. BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP);
  137. goto err;
  138. }
  140. /* cast to short because of win16 winsock definition */
  141. if ((short)he->h_addrtype != AF_INET)
  142. {
  143. BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);
  144. goto err;
  145. }
  146. for (i=0; i<4; i++)
  147. ip[i]=he->h_addr_list[0][i];
  148. err = 0;
  150.  err:
  151. if (locked)
  152. CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
  153. if (err)
  154. {
  155. ERR_add_error_data(2,"host=",str);
  156. return 0;
  157. }
  158. else
  159. return 1;
  160. }
  162. int BIO_get_port(const char *str, unsigned short *port_ptr)
  163. {
  164. int i;
  165. struct servent *s;
  167. if (str == NULL)
  168. {
  169. BIOerr(BIO_F_BIO_GET_PORT,BIO_R_NO_PORT_DEFINED);
  170. return(0);
  171. }
  172. i=atoi(str);
  173. if (i != 0)
  174. *port_ptr=(unsigned short)i;
  175. else
  176. {
  177. CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);
  178. /* Note: under VMS with SOCKETSHR, it seems like the first
  179.  * parameter is 'char *', instead of 'const char *'
  180.  */
  181.   s=getservbyname(
  182. #ifndef CONST_STRICT
  183.     (char *)
  184. #endif
  185.     str,"tcp");
  186. if(s != NULL)
  187. *port_ptr=ntohs((unsigned short)s->s_port);
  188. CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
  189. if(s == NULL)
  190. {
  191. if (strcmp(str,"http") == 0)
  192. *port_ptr=80;
  193. else if (strcmp(str,"telnet") == 0)
  194. *port_ptr=23;
  195. else if (strcmp(str,"socks") == 0)
  196. *port_ptr=1080;
  197. else if (strcmp(str,"https") == 0)
  198. *port_ptr=443;
  199. else if (strcmp(str,"ssl") == 0)
  200. *port_ptr=443;
  201. else if (strcmp(str,"ftp") == 0)
  202. *port_ptr=21;
  203. else if (strcmp(str,"gopher") == 0)
  204. *port_ptr=70;
  205. #if 0
  206. else if (strcmp(str,"wais") == 0)
  207. *port_ptr=21;
  208. #endif
  209. else
  210. {
  211. SYSerr(SYS_F_GETSERVBYNAME,get_last_socket_error());
  212. ERR_add_error_data(3,"service='",str,"'");
  213. return(0);
  214. }
  215. }
  216. }
  217. return(1);
  218. }
  220. int BIO_sock_error(int sock)
  221. {
  222. int j,i;
  223. int size;
  224.  
  225. size=sizeof(int);
  226. /* Note: under Windows the third parameter is of type (char *)
  227.  * whereas under other systems it is (void *) if you don't have
  228.  * a cast it will choke the compiler: if you do have a cast then
  229.  * you can either go for (char *) or (void *).
  230.  */
  231. i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(void *)&j,(void *)&size);
  232. if (i < 0)
  233. return(1);
  234. else
  235. return(j);
  236. }
  238. #if 0
  239. long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)
  240. {
  241. int i;
  242. char **p;
  244. switch (cmd)
  245. {
  246. case BIO_GHBN_CTRL_HITS:
  247. return(BIO_ghbn_hits);
  248. /* break; */
  249. case BIO_GHBN_CTRL_MISSES:
  250. return(BIO_ghbn_miss);
  251. /* break; */
  252. case BIO_GHBN_CTRL_CACHE_SIZE:
  253. return(GHBN_NUM);
  254. /* break; */
  255. case BIO_GHBN_CTRL_GET_ENTRY:
  256. if ((iarg >= 0) && (iarg <GHBN_NUM) &&
  257. (ghbn_cache[iarg].order > 0))
  258. {
  259. p=(char **)parg;
  260. if (p == NULL) return(0);
  261. *p=ghbn_cache[iarg].name;
  262. ghbn_cache[iarg].name[128]='';
  263. return(1);
  264. }
  265. return(0);
  266. /* break; */
  267. case BIO_GHBN_CTRL_FLUSH:
  268. for (i=0; i<GHBN_NUM; i++)
  269. ghbn_cache[i].order=0;
  270. break;
  271. default:
  272. return(0);
  273. }
  274. return(1);
  275. }
  276. #endif
  278. #if 0
  279. static struct hostent *ghbn_dup(struct hostent *a)
  280. {
  281. struct hostent *ret;
  282. int i,j;
  284. MemCheck_off();
  285. ret=(struct hostent *)OPENSSL_malloc(sizeof(struct hostent));
  286. if (ret == NULL) return(NULL);
  287. memset(ret,0,sizeof(struct hostent));
  289. for (i=0; a->h_aliases[i] != NULL; i++)
  290. ;
  291. i++;
  292. ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *));
  293. if (ret->h_aliases == NULL)
  294. goto err;
  295. memset(ret->h_aliases, 0, i*sizeof(char *));
  297. for (i=0; a->h_addr_list[i] != NULL; i++)
  298. ;
  299. i++;
  300. ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *));
  301. if (ret->h_addr_list == NULL)
  302. goto err;
  303. memset(ret->h_addr_list, 0, i*sizeof(char *));
  305. j=strlen(a->h_name)+1;
  306. if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err;
  307. memcpy((char *)ret->h_name,a->h_name,j);
  308. for (i=0; a->h_aliases[i] != NULL; i++)
  309. {
  310. j=strlen(a->h_aliases[i])+1;
  311. if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err;
  312. memcpy(ret->h_aliases[i],a->h_aliases[i],j);
  313. }
  314. ret->h_length=a->h_length;
  315. ret->h_addrtype=a->h_addrtype;
  316. for (i=0; a->h_addr_list[i] != NULL; i++)
  317. {
  318. if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL)
  319. goto err;
  320. memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length);
  321. }
  322. if (0)
  323. {
  324. err:
  325. if (ret != NULL)
  326. ghbn_free(ret);
  327. ret=NULL;
  328. }
  329. MemCheck_on();
  330. return(ret);
  331. }
  333. static void ghbn_free(struct hostent *a)
  334. {
  335. int i;
  337. if(a == NULL)
  338.     return;
  340. if (a->h_aliases != NULL)
  341. {
  342. for (i=0; a->h_aliases[i] != NULL; i++)
  343. OPENSSL_free(a->h_aliases[i]);
  344. OPENSSL_free(a->h_aliases);
  345. }
  346. if (a->h_addr_list != NULL)
  347. {
  348. for (i=0; a->h_addr_list[i] != NULL; i++)
  349. OPENSSL_free(a->h_addr_list[i]);
  350. OPENSSL_free(a->h_addr_list);
  351. }
  352. if (a->h_name != NULL) OPENSSL_free(a->h_name);
  353. OPENSSL_free(a);
  354. }
  356. #endif
  358. struct hostent *BIO_gethostbyname(const char *name)
  359. {
  360. #if 1
  361. /* Caching gethostbyname() results forever is wrong,
  362.  * so we have to let the true gethostbyname() worry about this */
  363. return gethostbyname(name);
  364. #else
  365. struct hostent *ret;
  366. int i,lowi=0,j;
  367. unsigned long low= (unsigned long)-1;
  370. #  if 0
  371. /* It doesn't make sense to use locking here: The function interface
  372.  * is not thread-safe, because threads can never be sure when
  373.  * some other thread destroys the data they were given a pointer to.
  374.  */
  375. CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);
  376. #  endif
  377. j=strlen(name);
  378. if (j < 128)
  379. {
  380. for (i=0; i<GHBN_NUM; i++)
  381. {
  382. if (low > ghbn_cache[i].order)
  383. {
  384. low=ghbn_cache[i].order;
  385. lowi=i;
  386. }
  387. if (ghbn_cache[i].order > 0)
  388. {
  389. if (strncmp(name,ghbn_cache[i].name,128) == 0)
  390. break;
  391. }
  392. }
  393. }
  394. else
  395. i=GHBN_NUM;
  397. if (i == GHBN_NUM) /* no hit*/
  398. {
  399. BIO_ghbn_miss++;
  400. /* Note: under VMS with SOCKETSHR, it seems like the first
  401.  * parameter is 'char *', instead of 'const char *'
  402.  */
  403. ret=gethostbyname(
  404. #  ifndef CONST_STRICT
  405.     (char *)
  406. #  endif
  407.     name);
  409. if (ret == NULL)
  410. goto end;
  411. if (j > 128) /* too big to cache */
  412. {
  413. #  if 0
  414. /* If we were trying to make this function thread-safe (which
  415.  * is bound to fail), we'd have to give up in this case
  416.  * (or allocate more memory). */
  417. ret = NULL;
  418. #  endif
  419. goto end;
  420. }
  422. /* else add to cache */
  423. if (ghbn_cache[lowi].ent != NULL)
  424. ghbn_free(ghbn_cache[lowi].ent); /* XXX not thread-safe */
  425. ghbn_cache[lowi].name[0] = '';
  427. if((ret=ghbn_cache[lowi].ent=ghbn_dup(ret)) == NULL)
  428. {
  429. BIOerr(BIO_F_BIO_GETHOSTBYNAME,ERR_R_MALLOC_FAILURE);
  430. goto end;
  431. }
  432. strncpy(ghbn_cache[lowi].name,name,128);
  433. ghbn_cache[lowi].order=BIO_ghbn_miss+BIO_ghbn_hits;
  434. }
  435. else
  436. {
  437. BIO_ghbn_hits++;
  438. ret= ghbn_cache[i].ent;
  439. ghbn_cache[i].order=BIO_ghbn_miss+BIO_ghbn_hits;
  440. }
  441. end:
  442. #  if 0
  443. CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);
  444. #  endif
  445. return(ret);
  446. #endif
  447. }
  450. int BIO_sock_init(void)
  451. {
  452. #ifdef OPENSSL_SYS_WINDOWS
  453. static struct WSAData wsa_state;
  455. if (!wsa_init_done)
  456. {
  457. int err;
  458.   
  459. #ifdef SIGINT
  460. signal(SIGINT,(void (*)(int))BIO_sock_cleanup);
  461. #endif
  462. wsa_init_done=1;
  463. memset(&wsa_state,0,sizeof(wsa_state));
  464. if (WSAStartup(0x0101,&wsa_state)!=0)
  465. {
  466. err=WSAGetLastError();
  467. SYSerr(SYS_F_WSASTARTUP,err);
  468. BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP);
  469. return(-1);
  470. }
  471. }
  472. #endif /* OPENSSL_SYS_WINDOWS */
  473. #ifdef WATT32
  474. extern int _watt_do_exit;
  475. _watt_do_exit = 0;    /* don't make sock_init() call exit() */
  476. if (sock_init())
  477. return (-1);
  478. #endif
  480. #if defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
  481.     WORD wVerReq;
  482.     WSADATA wsaData;
  483.     int err;
  485.     if (!wsa_init_done)
  486.     {
  487.    
  488. # ifdef SIGINT
  489.         signal(SIGINT,(void (*)(int))BIO_sock_cleanup);
  490. # endif
  492.         wsa_init_done=1;
  493.         wVerReq = MAKEWORD( 2, 0 );
  494.         err = WSAStartup(wVerReq,&wsaData);
  495.         if (err != 0)
  496.         {
  497.             SYSerr(SYS_F_WSASTARTUP,err);
  498.             BIOerr(BIO_F_BIO_SOCK_INIT,BIO_R_WSASTARTUP);
  499.             return(-1);
  500. }
  501. }
  502. #endif
  504. return(1);
  505. }
  507. void BIO_sock_cleanup(void)
  508. {
  509. #ifdef OPENSSL_SYS_WINDOWS
  510. if (wsa_init_done)
  511. {
  512. wsa_init_done=0;
  513. #ifndef OPENSSL_SYS_WINCE
  514. WSACancelBlockingCall();
  515. #endif
  516. WSACleanup();
  517. }
  518. #elif defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK)
  519.    if (wsa_init_done)
  520.         {
  521.         wsa_init_done=0;
  522.         WSACleanup();
  523. }
  524. #endif
  525. }
  527. #if !defined(OPENSSL_SYS_VMS) || __VMS_VER >= 70000000
  529. int BIO_socket_ioctl(int fd, long type, void *arg)
  530. {
  531. int i;
  533. #ifdef __DJGPP__
  534. i=ioctlsocket(fd,type,(char *)arg);
  535. #else
  536. i=ioctlsocket(fd,type,arg);
  537. #endif /* __DJGPP__ */
  538. if (i < 0)
  539. SYSerr(SYS_F_IOCTLSOCKET,get_last_socket_error());
  540. return(i);
  541. }
  542. #endif /* __VMS_VER */
  544. /* The reason I have implemented this instead of using sscanf is because
  545.  * Visual C 1.52c gives an unresolved external when linking a DLL :-( */
  546. static int get_ip(const char *str, unsigned char ip[4])
  547. {
  548. unsigned int tmp[4];
  549. int num=0,c,ok=0;
  551. tmp[0]=tmp[1]=tmp[2]=tmp[3]=0;
  553. for (;;)
  554. {
  555. c= *(str++);
  556. if ((c >= '0') && (c <= '9'))
  557. {
  558. ok=1;
  559. tmp[num]=tmp[num]*10+c-'0';
  560. if (tmp[num] > 255) return(0);
  561. }
  562. else if (c == '.')
  563. {
  564. if (!ok) return(-1);
  565. if (num == 3) return(0);
  566. num++;
  567. ok=0;
  568. }
  569. else if (c == '' && (num == 3) && ok)
  570. break;
  571. else
  572. return(0);
  573. }
  574. ip[0]=tmp[0];
  575. ip[1]=tmp[1];
  576. ip[2]=tmp[2];
  577. ip[3]=tmp[3];
  578. return(1);
  579. }
  581. int BIO_get_accept_socket(char *host, int bind_mode)
  582. {
  583. int ret=0;
  584. struct sockaddr_in server,client;
  585. int s=INVALID_SOCKET,cs;
  586. unsigned char ip[4];
  587. unsigned short port;
  588. char *str=NULL,*e;
  589. const char *h,*p;
  590. unsigned long l;
  591. int err_num;
  593. if (BIO_sock_init() != 1) return(INVALID_SOCKET);
  595. if ((str=BUF_strdup(host)) == NULL) return(INVALID_SOCKET);
  597. h=p=NULL;
  598. h=str;
  599. for (e=str; *e; e++)
  600. {
  601. if (*e == ':')
  602. {
  603. p= &(e[1]);
  604. *e='';
  605. }
  606. else if (*e == '/')
  607. {
  608. *e='';
  609. break;
  610. }
  611. }
  613. if (p == NULL)
  614. {
  615. p=h;
  616. h="*";
  617. }
  619. if (!BIO_get_port(p,&port)) goto err;
  621. memset((char *)&server,0,sizeof(server));
  622. server.sin_family=AF_INET;
  623. server.sin_port=htons(port);
  625. if (strcmp(h,"*") == 0)
  626. server.sin_addr.s_addr=INADDR_ANY;
  627. else
  628. {
  629.                 if (!BIO_get_host_ip(h,&(ip[0]))) goto err;
  630. l=(unsigned long)
  631. ((unsigned long)ip[0]<<24L)|
  632. ((unsigned long)ip[1]<<16L)|
  633. ((unsigned long)ip[2]<< 8L)|
  634. ((unsigned long)ip[3]);
  635. server.sin_addr.s_addr=htonl(l);
  636. }
  638. again:
  639. s=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
  640. if (s == INVALID_SOCKET)
  641. {
  642. SYSerr(SYS_F_SOCKET,get_last_socket_error());
  643. ERR_add_error_data(3,"port='",host,"'");
  644. BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_CREATE_SOCKET);
  645. goto err;
  646. }
  648. #ifdef SO_REUSEADDR
  649. if (bind_mode == BIO_BIND_REUSEADDR)
  650. {
  651. int i=1;
  653. ret=setsockopt(s,SOL_SOCKET,SO_REUSEADDR,(char *)&i,sizeof(i));
  654. bind_mode=BIO_BIND_NORMAL;
  655. }
  656. #endif
  657. if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1)
  658. {
  659. #ifdef SO_REUSEADDR
  660. err_num=get_last_socket_error();
  661. if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
  662. (err_num == EADDRINUSE))
  663. {
  664. memcpy((char *)&client,(char *)&server,sizeof(server));
  665. if (strcmp(h,"*") == 0)
  666. client.sin_addr.s_addr=htonl(0x7F000001);
  667. cs=socket(AF_INET,SOCK_STREAM,SOCKET_PROTOCOL);
  668. if (cs != INVALID_SOCKET)
  669. {
  670. int ii;
  671. ii=connect(cs,(struct sockaddr *)&client,
  672. sizeof(client));
  673. closesocket(cs);
  674. if (ii == INVALID_SOCKET)
  675. {
  676. bind_mode=BIO_BIND_REUSEADDR;
  677. closesocket(s);
  678. goto again;
  679. }
  680. /* else error */
  681. }
  682. /* else error */
  683. }
  684. #endif
  685. SYSerr(SYS_F_BIND,err_num);
  686. ERR_add_error_data(3,"port='",host,"'");
  687. BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_BIND_SOCKET);
  688. goto err;
  689. }
  690. if (listen(s,MAX_LISTEN) == -1)
  691. {
  692. SYSerr(SYS_F_BIND,get_last_socket_error());
  693. ERR_add_error_data(3,"port='",host,"'");
  694. BIOerr(BIO_F_BIO_GET_ACCEPT_SOCKET,BIO_R_UNABLE_TO_LISTEN_SOCKET);
  695. goto err;
  696. }
  697. ret=1;
  698. err:
  699. if (str != NULL) OPENSSL_free(str);
  700. if ((ret == 0) && (s != INVALID_SOCKET))
  701. {
  702. closesocket(s);
  703. s= INVALID_SOCKET;
  704. }
  705. return(s);
  706. }
  708. int BIO_accept(int sock, char **addr)
  709. {
  710. int ret=INVALID_SOCKET;
  711. static struct sockaddr_in from;
  712. unsigned long l;
  713. unsigned short port;
  714. int len;
  715. char *p;
  717. memset((char *)&from,0,sizeof(from));
  718. len=sizeof(from);
  719. /* Note: under VMS with SOCKETSHR the fourth parameter is currently
  720.  * of type (int *) whereas under other systems it is (void *) if
  721.  * you don't have a cast it will choke the compiler: if you do
  722.  * have a cast then you can either go for (int *) or (void *).
  723.  */
  724. ret=accept(sock,(struct sockaddr *)&from,(void *)&len);
  725. if (ret == INVALID_SOCKET)
  726. {
  727. if(BIO_sock_should_retry(ret)) return -2;
  728. SYSerr(SYS_F_ACCEPT,get_last_socket_error());
  729. BIOerr(BIO_F_BIO_ACCEPT,BIO_R_ACCEPT_ERROR);
  730. goto end;
  731. }
  733. if (addr == NULL) goto end;
  735. l=ntohl(from.sin_addr.s_addr);
  736. port=ntohs(from.sin_port);
  737. if (*addr == NULL)
  738. {
  739. if ((p=OPENSSL_malloc(24)) == NULL)
  740. {
  741. BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
  742. goto end;
  743. }
  744. *addr=p;
  745. }
  746. BIO_snprintf(*addr,24,"%d.%d.%d.%d:%d",
  747.      (unsigned char)(l>>24L)&0xff,
  748.      (unsigned char)(l>>16L)&0xff,
  749.      (unsigned char)(l>> 8L)&0xff,
  750.      (unsigned char)(l     )&0xff,
  751.      port);
  752. end:
  753. return(ret);
  754. }
  756. int BIO_set_tcp_ndelay(int s, int on)
  757. {
  758. int ret=0;
  759. #if defined(TCP_NODELAY) && (defined(IPPROTO_TCP) || defined(SOL_TCP))
  760. int opt;
  762. #ifdef SOL_TCP
  763. opt=SOL_TCP;
  764. #else
  765. #ifdef IPPROTO_TCP
  766. opt=IPPROTO_TCP;
  767. #endif
  768. #endif
  770. ret=setsockopt(s,opt,TCP_NODELAY,(char *)&on,sizeof(on));
  771. #endif
  772. return(ret == 0);
  773. }
  774. #endif
  776. int BIO_socket_nbio(int s, int mode)
  777. {
  778. int ret= -1;
  779. int l;
  781. l=mode;
  782. #ifdef FIONBIO
  783. ret=BIO_socket_ioctl(s,FIONBIO,&l);
  784. #endif
  785. return(ret == 0);
  786. }