Changeset 988 for vendor/current/lib/addns/dnssock.c

Timestamp:

Nov 24, 2016, 1:14:11 PM (9 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: update vendor to version 4.4.3

File:

• vendor/current/lib/addns/dnssock.c (modified) (21 diffs)

vendor/current/lib/addns/dnssock.c

@@ -28 +28 @@
 #include <unistd.h>
 #include "system/select.h"
+#include "../lib/util/debug.h"
 
 static int destroy_dns_connection(struct dns_connection *conn)
@@ -41 +42 @@
                                struct dns_connection **result )
 {
-        uint32_t ulAddress;
-        struct hostent *pHost;
-        struct sockaddr_in s_in;
+        struct addrinfo hints;
+        struct addrinfo *ai_result = NULL;
+        struct addrinfo *rp;
         struct dns_connection *conn;
-        int res;
+        int ret;
+        char service[16];
+
+        snprintf(service, sizeof(service), "%d", DNS_TCP_PORT);
 
         if (!(conn = talloc(mem_ctx, struct dns_connection))) {
@@ -51 +55 @@
         }
 
-        if ( (ulAddress = inet_addr( nameserver )) == INADDR_NONE ) {
-                if ( (pHost = gethostbyname( nameserver )) == NULL ) {
-                        TALLOC_FREE(conn);
-                        return ERROR_DNS_INVALID_NAME_SERVER;
-                }
-                memcpy( &ulAddress, pHost->h_addr, pHost->h_length );
-        }
-
-        conn->s = socket( PF_INET, SOCK_STREAM, 0 );
-        if (conn->s == -1) {
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_STREAM;
+        hints.ai_flags = 0;
+        hints.ai_protocol = IPPROTO_TCP;
+
+        ret = getaddrinfo(nameserver, service, &hints, &ai_result);
+        if (ret != 0) {
+                DEBUG(1,("dns_tcp_open: getaddrinfo: %s\n", gai_strerror(ret)));
+                TALLOC_FREE(conn);
+                return ERROR_DNS_INVALID_NAME_SERVER;
+        }
+
+        for (rp = ai_result; rp != NULL; rp = rp->ai_next) {
+                conn->s = socket(rp->ai_family,
+                                rp->ai_socktype,
+                                rp->ai_protocol);
+                if (conn->s == -1) {
+                        continue;
+                }
+                do {
+                        ret = connect(conn->s, rp->ai_addr, rp->ai_addrlen);
+                } while ((ret == -1) && (errno == EINTR));
+                if (ret != -1) {
+                        /* Successful connect */
+                        break;
+                }
+                close(conn->s);
+        }
+
+        freeaddrinfo(ai_result);
+
+        /* Failed to connect with any address */
+        if (rp == NULL) {
                 TALLOC_FREE(conn);
                 return ERROR_DNS_CONNECTION_FAILED;
@@ -67 +95 @@
         talloc_set_destructor(conn, destroy_dns_connection);
 
-        s_in.sin_family = AF_INET;
-        s_in.sin_addr.s_addr = ulAddress;
-        s_in.sin_port = htons( DNS_TCP_PORT );
-
-        res = connect(conn->s, (struct sockaddr*)&s_in, sizeof( s_in ));
-        if (res == -1) {
-                TALLOC_FREE(conn);
-                return ERROR_DNS_CONNECTION_FAILED;
-        }
-
         conn->hType = DNS_TCP;
-
         *result = conn;
         return ERROR_DNS_SUCCESS;
@@ -84 +101 @@
 
 /********************************************************************
-********************************************************************/
+ * ********************************************************************/
 
 static DNS_ERROR dns_udp_open( const char *nameserver,
@@ -90 +107 @@
                                struct dns_connection **result )
 {
-        unsigned long ulAddress;
-        struct hostent *pHost;
-        struct sockaddr_in RecvAddr;
+        struct addrinfo hints;
+        struct addrinfo *ai_result = NULL;
+        struct addrinfo *rp;
+        struct sockaddr_storage RecvAddr;
         struct dns_connection *conn;
+        int ret;
+        socklen_t RecvAddrLen;
+        char service[16];
+
+        snprintf(service, sizeof(service), "%d", DNS_UDP_PORT);
 
         if (!(conn = talloc(NULL, struct dns_connection))) {
@@ -99 +122 @@
         }
 
-        if ( (ulAddress = inet_addr( nameserver )) == INADDR_NONE ) {
-                if ( (pHost = gethostbyname( nameserver )) == NULL ) {
-                        TALLOC_FREE(conn);
-                        return ERROR_DNS_INVALID_NAME_SERVER;
-                }
-                memcpy( &ulAddress, pHost->h_addr, pHost->h_length );
-        }
-
-        /* Create a socket for sending data */
-
-        conn->s = socket( AF_INET, SOCK_DGRAM, IPPROTO_UDP );
-        if (conn->s == -1) {
+        memset(&hints, 0, sizeof(struct addrinfo));
+        hints.ai_family = AF_UNSPEC;
+        hints.ai_socktype = SOCK_DGRAM;
+        hints.ai_flags = 0;
+        hints.ai_protocol = IPPROTO_UDP;
+
+        ret = getaddrinfo(nameserver, service, &hints, &ai_result);
+        if (ret != 0) {
+                DEBUG(1,("dns_ucp_open:getaddrinfo: %s\n", gai_strerror(ret)));
+                TALLOC_FREE(conn);
+                return ERROR_DNS_INVALID_NAME_SERVER;
+        }
+
+        for (rp = ai_result; rp != NULL; rp = rp->ai_next) {
+                conn->s = socket(rp->ai_family,
+                                rp->ai_socktype,
+                                rp->ai_protocol);
+                if (conn->s == -1) {
+                        continue;
+                }
+                ret = connect(conn->s, rp->ai_addr, rp->ai_addrlen);
+                if (ret != -1) {
+                        /* Successful connect */
+                        break;
+                }
+                close(conn->s);
+        }
+
+        freeaddrinfo(ai_result);
+
+        /* Failed to connect with any address */
+        if (rp == NULL) {
                 TALLOC_FREE(conn);
                 return ERROR_DNS_CONNECTION_FAILED;
@@ -118 +161 @@
 
         /* Set up the RecvAddr structure with the IP address of
-           the receiver (in this example case "123.456.789.1")
-           and the specified port number. */
-
-        ZERO_STRUCT(RecvAddr);
-        RecvAddr.sin_family = AF_INET;
-        RecvAddr.sin_port = htons( DNS_UDP_PORT );
-        RecvAddr.sin_addr.s_addr = ulAddress;
+           the receiver and the specified port number. */
+
+        RecvAddrLen = sizeof(RecvAddr);
+        if (getpeername(conn->s,
+                        (struct sockaddr *)&RecvAddr,
+                        &RecvAddrLen) == -1) {
+                TALLOC_FREE(conn);
+                return ERROR_DNS_CONNECTION_FAILED;
+        }
 
         conn->hType = DNS_UDP;
-        memcpy( &conn->RecvAddr, &RecvAddr, sizeof( struct sockaddr_in ) );
+        memcpy(&conn->RecvAddr, &RecvAddr, sizeof(struct sockaddr_storage));
 
         *result = conn;
@@ -136 +181 @@
 ********************************************************************/
 
-DNS_ERROR dns_open_connection( const char *nameserver, int32 dwType,
+DNS_ERROR dns_open_connection( const char *nameserver, int32_t dwType,
                     TALLOC_CTX *mem_ctx,
                     struct dns_connection **conn )
@@ -150 +195 @@
 }
 
-static DNS_ERROR write_all(int fd, uint8 *data, size_t len)
+static DNS_ERROR write_all(int fd, uint8_t *data, size_t len)
 {
         size_t total = 0;
@@ -156 +201 @@
         while (total < len) {
 
-                ssize_t ret = write(fd, data + total, len - total);
+                ssize_t ret;
+
+                do {
+                        ret = write(fd, data + total, len - total);
+                } while ((ret == -1) && (errno == EINTR));
 
                 if (ret <= 0) {
@@ -174 +223 @@
                               const struct dns_buffer *buf)
 {
-        uint16 len = htons(buf->offset);
+        uint16_t len = htons(buf->offset);
         DNS_ERROR err;
 
-        err = write_all(conn->s, (uint8 *)&len, sizeof(len));
+        err = write_all(conn->s, (uint8_t *)&len, sizeof(len));
         if (!ERR_DNS_IS_OK(err)) return err;
 
@@ -188 +237 @@
         ssize_t ret;
 
-        ret = sendto(conn->s, buf->data, buf->offset, 0,
+        do {
+                ret = sendto(conn->s, buf->data, buf->offset, 0,
                      (struct sockaddr *)&conn->RecvAddr,
                      sizeof(conn->RecvAddr));
+        } while ((ret == -1) && (errno == EINTR));
 
         if (ret != buf->offset) {
@@ -212 +263 @@
 }
 
-static DNS_ERROR read_all(int fd, uint8 *data, size_t len)
+static DNS_ERROR read_all(int fd, uint8_t *data, size_t len)
 {
         size_t total = 0;
@@ -226 +277 @@
 
                 fd_ready = poll(&pfd, 1, 10000);
+                if (fd_ready == -1) {
+                        if (errno == EINTR) {
+                                continue;
+                        }
+                        return ERROR_DNS_SOCKET_ERROR;
+                }
                 if ( fd_ready == 0 ) {
                         /* read timeout */
@@ -231 +288 @@
                 }
 
-                ret = read(fd, data + total, len - total);
+                do {
+                        ret = read(fd, data + total, len - total);
+                } while ((ret == -1) && (errno == EINTR));
+
                 if (ret <= 0) {
                         /* EOF or error */
@@ -249 +309 @@
         struct dns_buffer *buf;
         DNS_ERROR err;
-        uint16 len;
-
-        if (!(buf = TALLOC_ZERO_P(mem_ctx, struct dns_buffer))) {
-                return ERROR_DNS_NO_MEMORY;
-        }
-
-        err = read_all(conn->s, (uint8 *)&len, sizeof(len));
+        uint16_t len;
+
+        if (!(buf = talloc_zero(mem_ctx, struct dns_buffer))) {
+                return ERROR_DNS_NO_MEMORY;
+        }
+
+        err = read_all(conn->s, (uint8_t *)&len, sizeof(len));
         if (!ERR_DNS_IS_OK(err)) {
                 return err;
@@ -262 +322 @@
         buf->size = ntohs(len);
 
-        if (buf->size) {
-                if (!(buf->data = TALLOC_ARRAY(buf, uint8, buf->size))) {
-                        TALLOC_FREE(buf);
-                        return ERROR_DNS_NO_MEMORY;
-                }
-        } else {
-                buf->data = NULL;
-        }
-
-        err = read_all(conn->s, buf->data, buf->size);
+        if (buf->size == 0) {
+                *presult = buf;
+                return ERROR_DNS_SUCCESS;
+        }
+
+        if (!(buf->data = talloc_array(buf, uint8_t, buf->size))) {
+                TALLOC_FREE(buf);
+                return ERROR_DNS_NO_MEMORY;
+        }
+
+        err = read_all(conn->s, buf->data, talloc_get_size(buf->data));
         if (!ERR_DNS_IS_OK(err)) {
                 TALLOC_FREE(buf);
@@ -288 +349 @@
         ssize_t received;
 
-        if (!(buf = TALLOC_ZERO_P(mem_ctx, struct dns_buffer))) {
+        if (!(buf = talloc_zero(mem_ctx, struct dns_buffer))) {
                 return ERROR_DNS_NO_MEMORY;
         }
@@ -296 +357 @@
          */
 
-        if (!(buf->data = TALLOC_ARRAY(buf, uint8, 512))) {
+        if (!(buf->data = talloc_array(buf, uint8_t, 512))) {
                 TALLOC_FREE(buf);
                 return ERROR_DNS_NO_MEMORY;
         }
 
-        received = recv(conn->s, (void *)buf->data, 512, 0);
+        do {
+                received = recv(conn->s, (void *)buf->data, 512, 0);
+        } while ((received == -1) && (errno == EINTR));
 
         if (received == -1) {
@@ -341 +404 @@
         DNS_ERROR err;
 
-        err = dns_marshall_request(conn, req, &buf);
+        err = dns_marshall_request(mem_ctx, req, &buf);
         if (!ERR_DNS_IS_OK(err)) goto error;