Combat gcc 4.4.1 aliasing rules.

int BIO_get_accept_socket(char *host, int bind_mode)

	{

	int ret=0;

	union {

		struct sockaddr sa;

		struct sockaddr_in sa_in;

#if OPENSSL_USE_IPV6

# define ossl_sock_family(s) s.ss_family

	struct sockaddr_storage server,client;

#else

# define ossl_sock_family(s) s.sa_family

	struct sockaddr server,client;

		struct sockaddr_in6 sa_in6;

#endif

	struct sockaddr_in *sa_in;

	} server,client;

	int s=INVALID_SOCKET,cs;

	unsigned char ip[4];

	unsigned short port;

		}

	if ((*p_getaddrinfo.f)(h,p,&hint,&res)) break;

#if OPENSSL_USE_IPV6

	memcpy(&server, res->ai_addr, res->ai_addrlen);

#else

	server = *res->ai_addr;

#endif

	memcpy(&server, res->ai_addr,

		res->ai_addrlen<=sizeof(server)?res->ai_addrlen:sizeof(server));

	(*p_freeaddrinfo.f)(res);

	goto again;

	} while (0);

	if (!BIO_get_port(p,&port)) goto err;

	memset((char *)&server,0,sizeof(server));

	sa_in = (struct sockaddr_in *)&server;

	sa_in->sin_family=AF_INET;

	sa_in->sin_port=htons(port);

	server.sa_in.sin_family=AF_INET;

	server.sa_in.sin_port=htons(port);

	if (h == NULL || strcmp(h,"*") == 0)

		sa_in->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]);

		sa_in->sin_addr.s_addr=htonl(l);

		server.sa_in.sin_addr.s_addr=htonl(l);

		}

again:

	s=socket(ossl_sock_family(server),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,(struct sockaddr *)&server,sizeof(server)) == -1)

	if (bind(s,&server.sa,sizeof(server)) == -1)

		{

#ifdef SO_REUSEADDR

		err_num=get_last_socket_error();

			if (h == NULL || strcmp(h,"*") == 0)

				{

#if OPENSSL_USE_IPV6

				if (ossl_sock_family(client) == AF_INET6)

				if (client.sa.sa_family == AF_INET6)

					{

					struct sockaddr_in6 *sin6 =

						(struct sockaddr_in6 *)&client;

					memset(&sin6->sin6_addr,0,sizeof(sin6->sin6_addr));

					sin6->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 (ossl_sock_family(client) == AF_INET)

				if (client.sa.sa_family == AF_INET)

					{

					struct sockaddr_in *sin4 =

						(struct sockaddr_in *)&client;

					sin4->sin_addr.s_addr=htonl(0x7F000001);

					client.sa_in.sin_addr.s_addr=htonl(0x7F000001);

					}

				else	goto err;

				}

			cs=socket(ossl_sock_family(client),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,sizeof(client));

				closesocket(cs);

				if (ii == INVALID_SOCKET)

					{

int BIO_accept(int sock, char **addr)

	{

	int ret=INVALID_SOCKET;

	struct sockaddr from;

	struct sockaddr_in *sa_in;

	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 = (unsigned int)sa.len.s;

		}

	if (ret == INVALID_SOCKET)

		{

		if(BIO_sock_should_retry(ret)) return -2;

		}

	if (p_getnameinfo.p==(void *)-1) break;

	if ((*p_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;

	nl = 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,nl);	}

	else	{ p = OPENSSL_malloc(nl);		}

	goto end;

	} while(0);

#endif

	if (from.sa_family != AF_INET) goto end;

	sa_in = (struct sockaddr_in *)&from;

	l=ntohl(sa_in->sin_addr.s_addr);

	port=ntohs(sa_in->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)