generic-library/openssl
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

Combat gcc 4.4.1 aliasing rules. (from HEAD)

Browse Source
This commit is contained in:
Dr. Stephen Henson 2009-11-09 14:09:53 +00:00
parent f923bba73c
commit f62d1ea3d5
1 changed files with 67 additions and 46 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

113
crypto/bio/b_sock.c
View File

@ -588,14 +588,13 @@ static int get_ip(const char *str, unsigned char ip[4])
int BIO_get_accept_socket(char *host, int bind_mode) int BIO_get_accept_socket(char *host, int bind_mode)
{ {
int ret=0; int ret=0;
union {
struct sockaddr sa;
struct sockaddr_in sa_in;
#if OPENSSL_USE_IPV6 #if OPENSSL_USE_IPV6
# define ossl_sock_family(s) s.ss_family struct sockaddr_in6 sa_in6;
struct sockaddr_storage server,client;
#else
# define ossl_sock_family(s) s.sa_family
struct sockaddr server,client;
#endif #endif
struct sockaddr_in *sa_in; } server,client;
int s=INVALID_SOCKET,cs; int s=INVALID_SOCKET,cs;
unsigned char ip[4]; unsigned char ip[4];
unsigned short port; unsigned short port;
@ -666,11 +665,10 @@ int BIO_get_accept_socket(char *host, int bind_mode)
} }
if ((*p_getaddrinfo.f)(h,p,&hint,&res)) break; if ((*p_getaddrinfo.f)(h,p,&hint,&res)) break;
#if OPENSSL_USE_IPV6
memcpy(&server, res->ai_addr, res->ai_addrlen); memcpy(&server, res->ai_addr,
#else res->ai_addrlen<=sizeof(server)?res->ai_addrlen:sizeof(server));
server = *res->ai_addr;
#endif
(*p_freeaddrinfo.f)(res); (*p_freeaddrinfo.f)(res);
goto again; goto again;
} while (0); } while (0);
@ -679,12 +677,11 @@ int BIO_get_accept_socket(char *host, int bind_mode)
if (!BIO_get_port(p,&port)) goto err; if (!BIO_get_port(p,&port)) goto err;
memset((char *)&server,0,sizeof(server)); memset((char *)&server,0,sizeof(server));
sa_in = (struct sockaddr_in *)&server; server.sa_in.sin_family=AF_INET;
sa_in->sin_family=AF_INET; server.sa_in.sin_port=htons(port);
sa_in->sin_port=htons(port);
if (h == NULL || strcmp(h,"*") == 0) if (h == NULL || strcmp(h,"*") == 0)
sa_in->sin_addr.s_addr=INADDR_ANY; server.sa_in.sin_addr.s_addr=INADDR_ANY;
else else
{ {
if (!BIO_get_host_ip(h,&(ip[0]))) goto err; if (!BIO_get_host_ip(h,&(ip[0]))) goto err;
@ -693,11 +690,11 @@ int BIO_get_accept_socket(char *host, int bind_mode)
((unsigned long)ip[1]<<16L)| ((unsigned long)ip[1]<<16L)|
((unsigned long)ip[2]<< 8L)| ((unsigned long)ip[2]<< 8L)|
((unsigned long)ip[3]); ((unsigned long)ip[3]);
sa_in->sin_addr.s_addr=htonl(l); server.sa_in.sin_addr.s_addr=htonl(l);
} }
again: 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) if (s == INVALID_SOCKET)
{ {
SYSerr(SYS_F_SOCKET,get_last_socket_error()); SYSerr(SYS_F_SOCKET,get_last_socket_error());
@ -715,7 +712,7 @@ again:
bind_mode=BIO_BIND_NORMAL; bind_mode=BIO_BIND_NORMAL;
} }
#endif #endif
if (bind(s,(struct sockaddr *)&server,sizeof(server)) == -1) if (bind(s,&server.sa,sizeof(server)) == -1)
{ {
#ifdef SO_REUSEADDR #ifdef SO_REUSEADDR
err_num=get_last_socket_error(); err_num=get_last_socket_error();
@ -726,29 +723,24 @@ again:
if (h == NULL || strcmp(h,"*") == 0) if (h == NULL || strcmp(h,"*") == 0)
{ {
#if OPENSSL_USE_IPV6 #if OPENSSL_USE_IPV6
if (ossl_sock_family(client) == AF_INET6) if (client.sa.sa_family == AF_INET6)
{ {
struct sockaddr_in6 *sin6 = memset(&client.sa_in6.sin6_addr,0,sizeof(client.sa_in6.sin6_addr));
(struct sockaddr_in6 *)&client; client.sa_in6.sin6_addr.s6_addr[15]=1;
memset(&sin6->sin6_addr,0,sizeof(sin6->sin6_addr));
sin6->sin6_addr.s6_addr[15]=1;
} }
else else
#endif #endif
if (ossl_sock_family(client) == AF_INET) if (client.sa.sa_family == AF_INET)
{ {
struct sockaddr_in *sin4 = client.sa_in.sin_addr.s_addr=htonl(0x7F000001);
(struct sockaddr_in *)&client;
sin4->sin_addr.s_addr=htonl(0x7F000001);
} }
else goto err; 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) if (cs != INVALID_SOCKET)
{ {
int ii; int ii;
ii=connect(cs,(struct sockaddr *)&client, ii=connect(cs,&client.sa,sizeof(client));
sizeof(client));
closesocket(cs); closesocket(cs);
if (ii == INVALID_SOCKET) if (ii == INVALID_SOCKET)
{ {
@ -787,21 +779,51 @@ err:
int BIO_accept(int sock, char **addr) int BIO_accept(int sock, char **addr)
{ {
int ret=INVALID_SOCKET; int ret=INVALID_SOCKET;
struct sockaddr from;
struct sockaddr_in *sa_in;
unsigned long l; unsigned long l;
unsigned short port; unsigned short port;
int len;
char *p; char *p;
memset(&from,0,sizeof(from)); struct {
len=sizeof(from); /*
/* Note: under VMS with SOCKETSHR the fourth parameter is currently * As for following union. Trouble is that there are platforms
* of type (int *) whereas under other systems it is (void *) if * that have socklen_t and there are platforms that don't, on
* you don't have a cast it will choke the compiler: if you do * some platforms socklen_t is int and on some size_t. So what
* have a cast then you can either go for (int *) or (void *). * 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 (ret == INVALID_SOCKET)
{ {
if(BIO_sock_should_retry(ret)) return -2; if(BIO_sock_should_retry(ret)) return -2;
@ -833,9 +855,9 @@ int BIO_accept(int sock, char **addr)
} }
if (p_getnameinfo.p==(void *)-1) break; 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; NI_NUMERICHOST|NI_NUMERICSERV)) break;
nl = strlen(h)+strlen(s)+2; if (len<24) len=24; nl = strlen(h)+strlen(s)+2;
p = *addr; p = *addr;
if (p) { *p = '\0'; p = OPENSSL_realloc(p,nl); } if (p) { *p = '\0'; p = OPENSSL_realloc(p,nl); }
else { p = OPENSSL_malloc(nl); } else { p = OPENSSL_malloc(nl); }
@ -849,10 +871,9 @@ int BIO_accept(int sock, char **addr)
goto end; goto end;
} while(0); } while(0);
#endif #endif
if (from.sa_family != AF_INET) goto end; if (sa.from.sa.sa_family != AF_INET) goto end;
sa_in = (struct sockaddr_in *)&from; l=ntohl(sa.from.sa_in.sin_addr.s_addr);
l=ntohl(sa_in->sin_addr.s_addr); port=ntohs(sa.from.sa_in.sin_port);
port=ntohs(sa_in->sin_port);
if (*addr == NULL) if (*addr == NULL)
{ {
if ((p=OPENSSL_malloc(24)) == NULL) if ((p=OPENSSL_malloc(24)) == NULL)