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