#include "cryptlib.h"
#include <openssl/bio.h>
#if defined(OPENSSL_SYS_NETWARE) && defined(NETWARE_BSDSOCK)
-#include "netdb.h"
+#include <netdb.h>
+#if defined(NETWARE_CLIB)
+#include <sys/ioctl.h>
+NETDB_DEFINE_CONTEXT
+#endif
#endif
#ifndef OPENSSL_NO_SOCK
static int wsa_init_done=0;
#endif
+/*
+ * WSAAPI specifier is required to make indirect calls to run-time
+ * linked WinSock 2 functions used in this module, to be specific
+ * [get|free]addrinfo and getnameinfo. This is because WinSock uses
+ * uses non-C calling convention, __stdcall vs. __cdecl, on x86
+ * Windows. On non-WinSock platforms WSAAPI needs to be void.
+ */
+#ifndef WSAAPI
+#define WSAAPI
+#endif
+
#if 0
static unsigned long BIO_ghbn_hits=0L;
static unsigned long BIO_ghbn_miss=0L;
/* Note: under VMS with SOCKETSHR, it seems like the first
* parameter is 'char *', instead of 'const char *'
*/
- s=getservbyname(
#ifndef CONST_STRICT
- (char *)
+ s=getservbyname((char *)str,"tcp");
+#else
+ s=getservbyname(str,"tcp");
#endif
- str,"tcp");
if(s != NULL)
*port_ptr=ntohs((unsigned short)s->s_port);
CRYPTO_w_unlock(CRYPTO_LOCK_GETSERVBYNAME);
int BIO_sock_error(int sock)
{
int j,i;
- int size;
+ union { size_t s; int i; } size;
- size=sizeof(int);
+#if defined(OPENSSL_SYS_BEOS_R5)
+ return 0;
+#endif
+
+ /* heuristic way to adapt for platforms that expect 64-bit optlen */
+ size.s=0, size.i=sizeof(j);
/* 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
#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;
/* Note: under VMS with SOCKETSHR, it seems like the first
* parameter is 'char *', instead of 'const char *'
*/
- ret=gethostbyname(
# ifndef CONST_STRICT
- (char *)
+ ret=gethostbyname((char *)name);
+# else
+ ret=gethostbyname(name);
# endif
- name);
if (ret == NULL)
goto end;
{
int err;
-#ifdef SIGINT
- signal(SIGINT,(void (*)(int))BIO_sock_cleanup);
-#endif
wsa_init_done=1;
memset(&wsa_state,0,sizeof(wsa_state));
/* Not making wsa_state available to the rest of the
if (!wsa_init_done)
{
-
-# ifdef SIGINT
- signal(SIGINT,(void (*)(int))BIO_sock_cleanup);
-# endif
-
wsa_init_done=1;
wVerReq = MAKEWORD( 2, 0 );
err = WSAStartup(wVerReq,&wsaData);
if (wsa_init_done)
{
wsa_init_done=0;
-#ifndef OPENSSL_SYS_WINCE
+#if 0 /* this call is claimed to be non-present in Winsock2 */
WSACancelBlockingCall();
#endif
WSACleanup();
#ifdef __DJGPP__
i=ioctlsocket(fd,type,(char *)arg);
#else
- i=ioctlsocket(fd,type,arg);
+# if defined(OPENSSL_SYS_VMS)
+ /* 2011-02-18 SMS.
+ * VMS ioctl() can't tolerate a 64-bit "void *arg", but we
+ * observe that all the consumers pass in an "unsigned long *",
+ * so we arrange a local copy with a short pointer, and use
+ * that, instead.
+ */
+# if __INITIAL_POINTER_SIZE == 64
+# define ARG arg_32p
+# pragma pointer_size save
+# pragma pointer_size 32
+ unsigned long arg_32;
+ unsigned long *arg_32p;
+# pragma pointer_size restore
+ arg_32p = &arg_32;
+ arg_32 = *((unsigned long *) arg);
+# else /* __INITIAL_POINTER_SIZE == 64 */
+# define ARG arg
+# endif /* __INITIAL_POINTER_SIZE == 64 [else] */
+# else /* defined(OPENSSL_SYS_VMS) */
+# define ARG arg
+# endif /* defined(OPENSSL_SYS_VMS) [else] */
+
+ i=ioctlsocket(fd,type,ARG);
#endif /* __DJGPP__ */
if (i < 0)
SYSerr(SYS_F_IOCTLSOCKET,get_last_socket_error());
int BIO_get_accept_socket(char *host, int bind_mode)
{
int ret=0;
- struct sockaddr server,client;
- struct sockaddr_in *sin;
- int s=INVALID_SOCKET,cs;
+ union {
+ struct sockaddr sa;
+ struct sockaddr_in sa_in;
+#if OPENSSL_USE_IPV6
+ struct sockaddr_in6 sa_in6;
+#endif
+ } server,client;
+ int s=INVALID_SOCKET,cs,addrlen;
unsigned char ip[4];
unsigned short port;
char *str=NULL,*e;
#ifdef EAI_FAMILY
do {
static union { void *p;
- int (*f)(const char *,const char *,
+ int (WSAAPI *f)(const char *,const char *,
const struct addrinfo *,
struct addrinfo **);
- } getaddrinfo = {NULL};
+ } p_getaddrinfo = {NULL};
static union { void *p;
- void (*f)(struct addrinfo *);
- } freeaddrinfo = {NULL};
+ void (WSAAPI *f)(struct addrinfo *);
+ } p_freeaddrinfo = {NULL};
struct addrinfo *res,hint;
- if (getaddrinfo.p==NULL)
+ if (p_getaddrinfo.p==NULL)
{
- if ((getaddrinfo.p=DSO_global_lookup("getaddrinfo"))==NULL ||
- (freeaddrinfo.p=DSO_global_lookup("freeaddrinfo"))==NULL)
- getaddrinfo.p=(void*)-1;
+ if ((p_getaddrinfo.p=DSO_global_lookup("getaddrinfo"))==NULL ||
+ (p_freeaddrinfo.p=DSO_global_lookup("freeaddrinfo"))==NULL)
+ p_getaddrinfo.p=(void*)-1;
}
- if (getaddrinfo.p==(void *)-1) break;
+ if (p_getaddrinfo.p==(void *)-1) break;
/* '::port' enforces IPv6 wildcard listener. Some OSes,
* e.g. Solaris, default to IPv6 without any hint. Also
* note that commonly IPv6 wildchard socket can service
* IPv4 connections just as well... */
memset(&hint,0,sizeof(hint));
+ hint.ai_flags = AI_PASSIVE;
if (h)
{
if (strchr(h,':'))
{
if (h[1]=='\0') h=NULL;
-#ifdef AF_INET6
+#if OPENSSL_USE_IPV6
hint.ai_family = AF_INET6;
#else
h=NULL;
#endif
}
else if (h[0]=='*' && h[1]=='\0')
+ {
+ hint.ai_family = AF_INET;
h=NULL;
+ }
}
- if ((*getaddrinfo.f)(h,p,&hint,&res)) break;
- server = *res->ai_addr;
- (*freeaddrinfo.f)(res);
+ if ((*p_getaddrinfo.f)(h,p,&hint,&res)) break;
+
+ addrlen = res->ai_addrlen<=sizeof(server) ?
+ res->ai_addrlen :
+ sizeof(server);
+ memcpy(&server, res->ai_addr, addrlen);
+
+ (*p_freeaddrinfo.f)(res);
goto again;
} while (0);
#endif
if (!BIO_get_port(p,&port)) goto err;
memset((char *)&server,0,sizeof(server));
- sin = (struct sockaddr_in *)&server;
- sin->sin_family=AF_INET;
- sin->sin_port=htons(port);
+ server.sa_in.sin_family=AF_INET;
+ server.sa_in.sin_port=htons(port);
+ addrlen = sizeof(server.sa_in);
if (h == NULL || strcmp(h,"*") == 0)
- sin->sin_addr.s_addr=INADDR_ANY;
+ server.sa_in.sin_addr.s_addr=INADDR_ANY;
else
{
if (!BIO_get_host_ip(h,&(ip[0]))) goto err;
((unsigned long)ip[1]<<16L)|
((unsigned long)ip[2]<< 8L)|
((unsigned long)ip[3]);
- sin->sin_addr.s_addr=htonl(l);
+ server.sa_in.sin_addr.s_addr=htonl(l);
}
again:
- s=socket(server.sa_family,SOCK_STREAM,SOCKET_PROTOCOL);
+ s=socket(server.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL);
if (s == INVALID_SOCKET)
{
SYSerr(SYS_F_SOCKET,get_last_socket_error());
bind_mode=BIO_BIND_NORMAL;
}
#endif
- if (bind(s,&server,sizeof(server)) == -1)
+ if (bind(s,&server.sa,addrlen) == -1)
{
#ifdef SO_REUSEADDR
err_num=get_last_socket_error();
if ((bind_mode == BIO_BIND_REUSEADDR_IF_UNUSED) &&
+#ifdef OPENSSL_SYS_WINDOWS
+ /* Some versions of Windows define EADDRINUSE to
+ * a dummy value.
+ */
+ (err_num == WSAEADDRINUSE))
+#else
(err_num == EADDRINUSE))
+#endif
{
client = server;
if (h == NULL || strcmp(h,"*") == 0)
{
-#ifdef AF_INET6
- if (client.sa_family == AF_INET6)
+#if OPENSSL_USE_IPV6
+ if (client.sa.sa_family == AF_INET6)
{
- struct sockaddr_in6 *sin =
- (struct sockaddr_in6 *)&client;
- memset(&sin->sin6_addr,0,sizeof(sin->sin6_addr));
- sin->sin6_addr.s6_addr[15]=1;
+ memset(&client.sa_in6.sin6_addr,0,sizeof(client.sa_in6.sin6_addr));
+ client.sa_in6.sin6_addr.s6_addr[15]=1;
}
else
#endif
- if (client.sa_family == AF_INET)
+ if (client.sa.sa_family == AF_INET)
{
- struct sockaddr_in *sin =
- (struct sockaddr_in *)&client;
- sin->sin_addr.s_addr=htonl(0x7F000001);
+ client.sa_in.sin_addr.s_addr=htonl(0x7F000001);
}
else goto err;
}
- cs=socket(client.sa_family,SOCK_STREAM,SOCKET_PROTOCOL);
+ cs=socket(client.sa.sa_family,SOCK_STREAM,SOCKET_PROTOCOL);
if (cs != INVALID_SOCKET)
{
int ii;
- ii=connect(cs,(struct sockaddr *)&client,
- sizeof(client));
+ ii=connect(cs,&client.sa,addrlen);
closesocket(cs);
if (ii == INVALID_SOCKET)
{
int BIO_accept(int sock, char **addr)
{
int ret=INVALID_SOCKET;
- struct sockaddr from;
- struct sockaddr_in *sin;
unsigned long l;
unsigned short port;
- int len;
char *p;
- memset(&from,0,sizeof(from));
- len=sizeof(from);
- /* Note: under VMS with SOCKETSHR the fourth parameter is currently
- * of type (int *) 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 (int *) or (void *).
+ struct {
+ /*
+ * As for following union. Trouble is that there are platforms
+ * that have socklen_t and there are platforms that don't, on
+ * some platforms socklen_t is int and on some size_t. So what
+ * one can do? One can cook #ifdef spaghetti, which is nothing
+ * but masochistic. Or one can do union between int and size_t.
+ * One naturally does it primarily for 64-bit platforms where
+ * sizeof(int) != sizeof(size_t). But would it work? Note that
+ * if size_t member is initialized to 0, then later int member
+ * assignment naturally does the job on little-endian platforms
+ * regardless accept's expectations! What about big-endians?
+ * If accept expects int*, then it works, and if size_t*, then
+ * length value would appear as unreasonably large. But this
+ * won't prevent it from filling in the address structure. The
+ * trouble of course would be if accept returns more data than
+ * actual buffer can accomodate and overwrite stack... That's
+ * where early OPENSSL_assert comes into picture. Besides, the
+ * only 64-bit big-endian platform found so far that expects
+ * size_t* is HP-UX, where stack grows towards higher address.
+ * <appro>
*/
- ret=accept(sock,&from,(void *)&len);
+ union { size_t s; int i; } len;
+ union {
+ struct sockaddr sa;
+ struct sockaddr_in sa_in;
+#if OPENSSL_USE_IPV6
+ struct sockaddr_in6 sa_in6;
+#endif
+ } from;
+ } sa;
+
+ sa.len.s=0;
+ sa.len.i=sizeof(sa.from);
+ memset(&sa.from,0,sizeof(sa.from));
+ ret=accept(sock,&sa.from.sa,(void *)&sa.len);
+ if (sizeof(sa.len.i)!=sizeof(sa.len.s) && sa.len.i==0)
+ {
+ OPENSSL_assert(sa.len.s<=sizeof(sa.from));
+ sa.len.i = (int)sa.len.s;
+ /* use sa.len.i from this point */
+ }
if (ret == INVALID_SOCKET)
{
if(BIO_sock_should_retry(ret)) return -2;
if (addr == NULL) goto end;
#ifdef EAI_FAMILY
-# ifdef OPENSSL_SYS_VMS
-# define SOCKLEN_T size_t
-# else
-# define SOCKLEN_T socklen_t
-#endif
do {
char h[NI_MAXHOST],s[NI_MAXSERV];
- size_t l;
+ size_t nl;
static union { void *p;
- int (*f)(const struct sockaddr *,SOCKLEN_T,
+ int (WSAAPI *f)(const struct sockaddr *,size_t/*socklen_t*/,
char *,size_t,char *,size_t,int);
- } getnameinfo = {NULL};
-
- if (getnameinfo.p==NULL)
+ } p_getnameinfo = {NULL};
+ /* 2nd argument to getnameinfo is specified to
+ * be socklen_t. Unfortunately there is a number
+ * of environments where socklen_t is not defined.
+ * As it's passed by value, it's safe to pass it
+ * as size_t... <appro> */
+
+ if (p_getnameinfo.p==NULL)
{
- if ((getnameinfo.p=DSO_global_lookup("getnameinfo"))==NULL)
- getnameinfo.p=(void*)-1;
+ if ((p_getnameinfo.p=DSO_global_lookup("getnameinfo"))==NULL)
+ p_getnameinfo.p=(void*)-1;
}
- if (getnameinfo.p==(void *)-1) break;
+ if (p_getnameinfo.p==(void *)-1) break;
- if ((*getnameinfo.f)(&from,sizeof(from),h,sizeof(h),s,sizeof(s),
+ if ((*p_getnameinfo.f)(&sa.from.sa,sa.len.i,h,sizeof(h),s,sizeof(s),
NI_NUMERICHOST|NI_NUMERICSERV)) break;
- l = strlen(h)+strlen(s)+2; if (len<24) len=24;
+ nl = strlen(h)+strlen(s)+2;
p = *addr;
- if (p) { *p = '\0'; p = OPENSSL_realloc(p,l); }
- else { p = OPENSSL_malloc(l); }
+ if (p) { *p = '\0'; p = OPENSSL_realloc(p,nl); }
+ else { p = OPENSSL_malloc(nl); }
if (p==NULL)
{
BIOerr(BIO_F_BIO_ACCEPT,ERR_R_MALLOC_FAILURE);
goto end;
}
*addr = p;
- BIO_snprintf(*addr,l,"%s:%s",h,s);
+ BIO_snprintf(*addr,nl,"%s:%s",h,s);
goto end;
} while(0);
#endif
- if (from.sa_family != AF_INET) goto end;
- sin = (struct sockaddr_in *)&from;
- l=ntohl(sin->sin_addr.s_addr);
- port=ntohs(sin->sin_port);
+ if (sa.from.sa.sa_family != AF_INET) goto end;
+ l=ntohl(sa.from.sa_in.sin_addr.s_addr);
+ port=ntohs(sa.from.sa_in.sin_port);
if (*addr == NULL)
{
if ((p=OPENSSL_malloc(24)) == NULL)
#endif
return(ret == 0);
}
-#endif
int BIO_socket_nbio(int s, int mode)
{
#endif
return(ret == 0);
}
+#endif