/* crypto/bio/b_sock.c *//* Copyright (C) 1995-1998 Eric Young (eay@cryptsoft.com) * All rights reserved. * * This package is an SSL implementation written * by Eric Young (eay@cryptsoft.com). * The implementation was written so as to conform with Netscapes SSL. *  * This library is free for commercial and non-commercial use as long as * the following conditions are aheared to.  The following conditions * apply to all code found in this distribution, be it the RC4, RSA, * lhash, DES, etc., code; not just the SSL code.  The SSL documentation * included with this distribution is covered by the same copyright terms * except that the holder is Tim Hudson (tjh@cryptsoft.com). *  * Copyright remains Eric Young's, and as such any Copyright notices in * the code are not to be removed. * If this package is used in a product, Eric Young should be given attribution * as the author of the parts of the library used. * This can be in the form of a textual message at program startup or * in documentation (online or textual) provided with the package. *  * Redistribution and use in source and binary forms, with or without * modification, are permitted provided that the following conditions * are met: * 1. Redistributions of source code must retain the copyright *    notice, this list of conditions and the following disclaimer. * 2. Redistributions in binary form must reproduce the above copyright *    notice, this list of conditions and the following disclaimer in the *    documentation and/or other materials provided with the distribution. * 3. All advertising materials mentioning features or use of this software *    must display the following acknowledgement: *    "This product includes cryptographic software written by *     Eric Young (eay@cryptsoft.com)" *    The word 'cryptographic' can be left out if the rouines from the library *    being used are not cryptographic related :-). * 4. If you include any Windows specific code (or a derivative thereof) from  *    the apps directory (application code) you must include an acknowledgement: *    "This product includes software written by Tim Hudson (tjh@cryptsoft.com)" *  * THIS SOFTWARE IS PROVIDED BY ERIC YOUNG ``AS IS'' AND * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE * ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR OR CONTRIBUTORS BE LIABLE * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF * SUCH DAMAGE. *  * The licence and distribution terms for any publically available version or * derivative of this code cannot be changed.  i.e. this code cannot simply be * copied and put under another distribution licence * [including the GNU Public Licence.] */#include <stdio.h>#include <stdlib.h>#include <errno.h>#define USE_SOCKETS#include "cryptlib.h"#include <openssl/bio.h>#if defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_BSDSOCK)#include <netdb.h>#if defined(NETWARE_CLIB)#include <sys/ioctl.h>NETDB_DEFINE_CONTEXT#endif#endif#ifndef OPENSSL_NO_SOCK#ifdef OPENSSL_SYS_WIN16#define SOCKET_PROTOCOL 0 /* more microsoft stupidity */#else#define SOCKET_PROTOCOL IPPROTO_TCP#endif#ifdef SO_MAXCONN#define MAX_LISTEN  SO_MAXCONN#elif defined(SOMAXCONN)#define MAX_LISTEN  SOMAXCONN#else#define MAX_LISTEN  32#endif#if defined(OPENSSL_SYS_WINDOWS) || (defined(OPENSSL_SYS_NETWARE) && !defined(NETWARE_BSDSOCK))static int wsa_init_done=0;#endif#if 0static unsigned long BIO_ghbn_hits=0L;static unsigned long BIO_ghbn_miss=0L;#define GHBN_NUM	4static struct ghbn_cache_st	{	char name[129];	struct hostent *ent;	unsigned long order;	} ghbn_cache[GHBN_NUM];#endifstatic int get_ip(const char *str,unsigned char *ip);#if 0static void ghbn_free(struct hostent *a);static struct hostent *ghbn_dup(struct hostent *a);#endifint BIO_get_host_ip(const char *str, unsigned char *ip)	{	int i;	int err = 1;	int locked = 0;	struct hostent *he;	i=get_ip(str,ip);	if (i < 0)		{		BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_INVALID_IP_ADDRESS);		goto err;		}	/* At this point, we have something that is most probably correct	   in some way, so let's init the socket. */	if (BIO_sock_init() != 1)		return 0; /* don't generate another error code here */	/* If the string actually contained an IP address, we need not do	   anything more */	if (i > 0) return(1);	/* do a gethostbyname */	CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);	locked = 1;	he=BIO_gethostbyname(str);	if (he == NULL)		{		BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_BAD_HOSTNAME_LOOKUP);		goto err;		}	/* cast to short because of win16 winsock definition */	if ((short)he->h_addrtype != AF_INET)		{		BIOerr(BIO_F_BIO_GET_HOST_IP,BIO_R_GETHOSTBYNAME_ADDR_IS_NOT_AF_INET);		goto err;		}	for (i=0; i<4; i++)		ip[i]=he->h_addr_list[0][i];	err = 0; err:	if (locked)		CRYPTO_w_unlock(CRYPTO_LOCK_GETHOSTBYNAME);	if (err)		{		ERR_add_error_data(2,"host=",str);		return 0;		}	else		return 1;	}int BIO_get_port(const char *str, unsigned short *port_ptr)	{	int i;	struct servent *s;	if (str == NULL)		{		BIOerr(BIO_F_BIO_GET_PORT,BIO_R_NO_PORT_DEFINED);		return(0);		}	i=atoi(str);	if (i != 0)		*port_ptr=(unsigned short)i;	else		{		CRYPTO_w_lock(CRYPTO_LOCK_GETSERVBYNAME);		/* Note: under VMS with SOCKETSHR, it seems like the first		 * parameter is 'char *', instead of 'const char *'		 */#ifndef CONST_STRICT		s=getservbyname((char *)str,"tcp");#else		s=getservbyname(str,"tcp");#endif		if(s != NULL)			*port_ptr=ntohs((unsigned short)s->s_port);		CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);		if(s == NULL)			{			if (strcmp(str,"http") == 0)				*port_ptr=80;			else if (strcmp(str,"telnet") == 0)				*port_ptr=23;			else if (strcmp(str,"socks") == 0)				*port_ptr=1080;			else if (strcmp(str,"https") == 0)				*port_ptr=443;			else if (strcmp(str,"ssl") == 0)				*port_ptr=443;			else if (strcmp(str,"ftp") == 0)				*port_ptr=21;			else if (strcmp(str,"gopher") == 0)				*port_ptr=70;#if 0			else if (strcmp(str,"wais") == 0)				*port_ptr=21;#endif			else				{				SYSerr(SYS_F_GETSERVBYNAME,get_last_socket_error());				ERR_add_error_data(3,"service='",str,"'");				return(0);				}			}		}	return(1);	}int BIO_sock_error(int sock)	{	int j,i;	int size;		 	size=sizeof(int);	/* Note: under Windows the third parameter is of type (char *)	 * whereas under other systems it is (void *) if you don't have	 * a cast it will choke the compiler: if you do have a cast then	 * you can either go for (char *) or (void *).	 */	i=getsockopt(sock,SOL_SOCKET,SO_ERROR,(void *)&j,(void *)&size);	if (i < 0)		return(1);	else		return(j);	}#if 0long BIO_ghbn_ctrl(int cmd, int iarg, char *parg)	{	int i;	char **p;	switch (cmd)		{	case BIO_GHBN_CTRL_HITS:		return(BIO_ghbn_hits);		/* break; */	case BIO_GHBN_CTRL_MISSES:		return(BIO_ghbn_miss);		/* break; */	case BIO_GHBN_CTRL_CACHE_SIZE:		return(GHBN_NUM);		/* break; */	case BIO_GHBN_CTRL_GET_ENTRY:		if ((iarg >= 0) && (iarg <GHBN_NUM) &&			(ghbn_cache[iarg].order > 0))			{			p=(char **)parg;			if (p == NULL) return(0);			*p=ghbn_cache[iarg].name;			ghbn_cache[iarg].name[128]='\0';			return(1);			}		return(0);		/* break; */	case BIO_GHBN_CTRL_FLUSH:		for (i=0; i<GHBN_NUM; i++)			ghbn_cache[i].order=0;		break;	default:		return(0);		}	return(1);	}#endif#if 0static struct hostent *ghbn_dup(struct hostent *a)	{	struct hostent *ret;	int i,j;	MemCheck_off();	ret=(struct hostent *)OPENSSL_malloc(sizeof(struct hostent));	if (ret == NULL) return(NULL);	memset(ret,0,sizeof(struct hostent));	for (i=0; a->h_aliases[i] != NULL; i++)		;	i++;	ret->h_aliases = (char **)OPENSSL_malloc(i*sizeof(char *));	if (ret->h_aliases == NULL)		goto err;	memset(ret->h_aliases, 0, i*sizeof(char *));	for (i=0; a->h_addr_list[i] != NULL; i++)		;	i++;	ret->h_addr_list=(char **)OPENSSL_malloc(i*sizeof(char *));	if (ret->h_addr_list == NULL)		goto err;	memset(ret->h_addr_list, 0, i*sizeof(char *));	j=strlen(a->h_name)+1;	if ((ret->h_name=OPENSSL_malloc(j)) == NULL) goto err;	memcpy((char *)ret->h_name,a->h_name,j);	for (i=0; a->h_aliases[i] != NULL; i++)		{		j=strlen(a->h_aliases[i])+1;		if ((ret->h_aliases[i]=OPENSSL_malloc(j)) == NULL) goto err;		memcpy(ret->h_aliases[i],a->h_aliases[i],j);		}	ret->h_length=a->h_length;	ret->h_addrtype=a->h_addrtype;	for (i=0; a->h_addr_list[i] != NULL; i++)		{		if ((ret->h_addr_list[i]=OPENSSL_malloc(a->h_length)) == NULL)			goto err;		memcpy(ret->h_addr_list[i],a->h_addr_list[i],a->h_length);		}	if (0)		{err:			if (ret != NULL)			ghbn_free(ret);		ret=NULL;		}	MemCheck_on();	return(ret);	}static void ghbn_free(struct hostent *a)	{	int i;	if(a == NULL)	    return;	if (a->h_aliases != NULL)		{		for (i=0; a->h_aliases[i] != NULL; i++)			OPENSSL_free(a->h_aliases[i]);		OPENSSL_free(a->h_aliases);		}	if (a->h_addr_list != NULL)		{		for (i=0; a->h_addr_list[i] != NULL; i++)			OPENSSL_free(a->h_addr_list[i]);		OPENSSL_free(a->h_addr_list);		}	if (a->h_name != NULL) OPENSSL_free(a->h_name);	OPENSSL_free(a);	}#endifstruct hostent *BIO_gethostbyname(const char *name)	{#if 1	/* Caching gethostbyname() results forever is wrong,	 * so we have to let the true gethostbyname() worry about this */#if (defined(NETWARE_BSDSOCK) && !defined(__NOVELL_LIBC__))	return gethostbyname((char*)name);#else	return gethostbyname(name);#endif#else	struct hostent *ret;	int i,lowi=0,j;	unsigned long low= (unsigned long)-1;#  if 0	/* It doesn't make sense to use locking here: The function interface	 * is not thread-safe, because threads can never be sure when	 * some other thread destroys the data they were given a pointer to.	 */	CRYPTO_w_lock(CRYPTO_LOCK_GETHOSTBYNAME);#  endif	j=strlen(name);	if (j < 128)		{		for (i=0; i<GHBN_NUM; i++)			{			if (low > ghbn_cache[i].order)				{				low=ghbn_cache[i].order;				lowi=i;				}