Combat gcc 4.4.1 aliasing rules. (from HEAD)
authorDr. Stephen Henson <steve@openssl.org>
Mon, 9 Nov 2009 14:09:53 +0000 (14:09 +0000)
committerDr. Stephen Henson <steve@openssl.org>
Mon, 9 Nov 2009 14:09:53 +0000 (14:09 +0000)
crypto/bio/b_sock.c

index 57aec21..5dc6cf4 100644 (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 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;
@@ -666,11 +665,10 @@ int BIO_get_accept_socket(char *host, int bind_mode)
                }
 
        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);
@@ -679,12 +677,11 @@ int BIO_get_accept_socket(char *host, int bind_mode)
        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;
@@ -693,11 +690,11 @@ int BIO_get_accept_socket(char *host, int bind_mode)
                        ((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());
@@ -715,7 +712,7 @@ again:
                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();
@@ -726,29 +723,24 @@ again:
                        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)
                                        {
@@ -787,21 +779,51 @@ err:
 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;
@@ -833,9 +855,9 @@ int BIO_accept(int sock, char **addr)
                }
        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);               }
@@ -849,10 +871,9 @@ int BIO_accept(int sock, char **addr)
        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)