Changeset 736 for branches/samba-3.5.x/source3/libsmb/namequery.c

Timestamp:

Nov 12, 2012, 5:38:52 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server 3.5: update branche to 3.5.16

File:

• branches/samba-3.5.x/source3/libsmb/namequery.c (modified) (14 diffs)

branches/samba-3.5.x/source3/libsmb/namequery.c

@@ -572 +572 @@
                         "looking for duplicate address/port pairs\n"));
 
-        /* one loop to remove duplicates */
+        /* One loop to set duplicates to a zero addr. */
         for ( i=0; i<count; i++ ) {
                 if ( is_zero_addr((struct sockaddr *)&iplist[i].ss)) {
@@ -586 +586 @@
         }
 
-        /* one loop to clean up any holes we left */
-        /* first ip should never be a zero_ip() */
-        for (i = 0; i<count; ) {
-                if (is_zero_addr((struct sockaddr *)&iplist[i].ss) ) {
-                        if (i != count-1) {
-                                memmove(&iplist[i], &iplist[i+1],
-                                        (count - i - 1)*sizeof(iplist[i]));
+        /* Now remove any addresses set to zero above. */
+        for (i = 0; i < count; i++) {
+                while (i < count &&
+                                is_zero_addr((struct sockaddr *)&iplist[i].ss)) {
+                        if (count-i-1>0) {
+                                memmove(&iplist[i],
+                                        &iplist[i+1],
+                                        (count-i-1)*sizeof(struct ip_service));
                         }
                         count--;
-                        continue;
-                }
-                i++;
+                }
         }
 
@@ -850 +849 @@
 
 /********************************************************
- convert an array if struct sockaddr_storage to struct ip_service
+ Convert an array if struct sockaddr_storage to struct ip_service
  return false on failure.  Port is set to PORT_NONE;
+ pcount is [in/out] - it is the length of ss_list on input,
+ and the length of return_iplist on output as we remove any
+ zero addresses from ss_list.
 *********************************************************/
 
 static bool convert_ss2service(struct ip_service **return_iplist,
                 const struct sockaddr_storage *ss_list,
-                int count)
+                int *pcount)
 {
         int i;
-
-        if ( count==0 || !ss_list )
+        int orig_count = *pcount;
+        int real_count = 0;
+
+        if (orig_count==0 || !ss_list )
                 return False;
 
+        /* Filter out zero addrs. */
+        for ( i=0; i<orig_count; i++ ) {
+                if (is_zero_addr((struct sockaddr *)&ss_list[i])) {
+                        continue;
+                }
+                real_count++;
+        }
+        if (real_count==0) {
+                return false;
+        }
+
         /* copy the ip address; port will be PORT_NONE */
-        if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, count)) ==
+        if ((*return_iplist = SMB_MALLOC_ARRAY(struct ip_service, real_count)) ==
                         NULL) {
                 DEBUG(0,("convert_ip2service: malloc failed "
-                        "for %d enetries!\n", count ));
+                        "for %d enetries!\n", real_count ));
                 return False;
         }
 
-        for ( i=0; i<count; i++ ) {
-                (*return_iplist)[i].ss   = ss_list[i];
-                (*return_iplist)[i].port = PORT_NONE;
-        }
-
+        for ( i=0, real_count = 0; i<orig_count; i++ ) {
+                if (is_zero_addr((struct sockaddr *)&ss_list[i])) {
+                        continue;
+                }
+                (*return_iplist)[real_count].ss   = ss_list[i];
+                (*return_iplist)[real_count].port = PORT_NONE;
+                real_count++;
+        }
+
+        *pcount = real_count;
         return true;
 }
@@ -948 +968 @@
 
         status = NT_STATUS_OK;
-        if (!convert_ss2service(return_iplist, ss_list, *return_count) )
+        if (!convert_ss2service(return_iplist, ss_list, return_count) )
                 status = NT_STATUS_INVALID_PARAMETER;
 
@@ -1083 +1103 @@
 
         status = NT_STATUS_OK;
-        if (!convert_ss2service(return_iplist, ss_list, *return_count))
+        if (!convert_ss2service(return_iplist, ss_list, return_count))
                 status = NT_STATUS_INVALID_PARAMETER;
 
@@ -1231 +1251 @@
                 memcpy(&ss, res->ai_addr, res->ai_addrlen);
 
+                if (is_zero_addr((struct sockaddr *)&ss)) {
+                        continue;
+                }
+
                 *return_count += 1;
 
@@ -1264 +1288 @@
                             int *return_count)
 {
-        int                     i, j;
+        int                     i;
         NTSTATUS                status;
         TALLOC_CTX              *ctx;
@@ -1313 +1337 @@
 
         for (i=0;i<numdcs;i++) {
-                numaddrs += MAX(dcs[i].num_ips,1);
+                if (!dcs[i].ss_s) {
+                        numaddrs += 1;
+                } else {
+                        numaddrs += dcs[i].num_ips;
+                }
         }
 
@@ -1327 +1355 @@
 
         *return_count = 0;
-        i = 0;
-        j = 0;
-        while ( i < numdcs && (*return_count<numaddrs) ) {
-                struct ip_service *r = &(*return_iplist)[*return_count];
-
-                r->port = dcs[i].port;
-
-                /* If we don't have an IP list for a name, lookup it up */
-
+
+        for (i = 0; i < numdcs; i++) {
+                /* If we don't have an IP list for a name, look it up */
                 if (!dcs[i].ss_s) {
-                        interpret_string_addr(&r->ss, dcs[i].hostname, 0);
-                        i++;
-                        j = 0;
+                        /* We need to get all IP addresses here. */
+                        struct addrinfo *res = NULL;
+                        struct addrinfo *p;
+                        int extra_addrs = 0;
+
+                        if (!interpret_string_addr_internal(&res,
+                                                dcs[i].hostname,
+                                                0)) {
+                                continue;
+                        }
+                        /* Add in every IP from the lookup. How
+                           many is that ? */
+                        for (p = res; p; p = p->ai_next) {
+                                if (is_zero_addr((struct sockaddr *)p->ai_addr)) {
+                                        continue;
+                                }
+                                extra_addrs++;
+                        }
+                        if (extra_addrs > 1) {
+                                /* We need to expand the return_iplist array
+                                   as we only budgeted for one address. */
+                                numaddrs += (extra_addrs-1);
+                                *return_iplist = SMB_REALLOC_ARRAY(*return_iplist,
+                                                struct ip_service,
+                                                numaddrs);
+                                if (*return_iplist == NULL) {
+                                        if (res) {
+                                                freeaddrinfo(res);
+                                        }
+                                        talloc_destroy(ctx);
+                                        return NT_STATUS_NO_MEMORY;
+                                }
+                        }
+                        for (p = res; p; p = p->ai_next) {
+                                (*return_iplist)[*return_count].port = dcs[i].port;
+                                memcpy(&(*return_iplist)[*return_count].ss,
+                                                p->ai_addr,
+                                                p->ai_addrlen);
+                                if (is_zero_addr((struct sockaddr *)&(*return_iplist)[*return_count].ss)) {
+                                        continue;
+                                }
+                                (*return_count)++;
+                                /* Should never happen, but still... */
+                                if (*return_count>=numaddrs) {
+                                        break;
+                                }
+                        }
+                        if (res) {
+                                freeaddrinfo(res);
+                        }
                 } else {
-                        /* use the IP addresses from the SRV sresponse */
-
-                        if ( j >= dcs[i].num_ips ) {
-                                i++;
-                                j = 0;
-                                continue;
-                        }
-
-                        r->ss = dcs[i].ss_s[j];
-                        j++;
-                }
-
-                /* make sure it is a valid IP.  I considered checking the
-                 * negative connection cache, but this is the wrong place
-                 * for it. Maybe only as a hack. After think about it, if
-                 * all of the IP addresses returned from DNS are dead, what
-                 * hope does a netbios name lookup have ? The standard reason
-                 * for falling back to netbios lookups is that our DNS server
-                 * doesn't know anything about the DC's   -- jerry */
-
-                if (!is_zero_addr((struct sockaddr *)&r->ss)) {
-                        (*return_count)++;
+                        /* use all the IP addresses from the SRV sresponse */
+                        int j;
+                        for (j = 0; j < dcs[i].num_ips; j++) {
+                                (*return_iplist)[*return_count].port = dcs[i].port;
+                                (*return_iplist)[*return_count].ss = dcs[i].ss_s[j];
+                                if (is_zero_addr((struct sockaddr *)&(*return_iplist)[*return_count].ss)) {
+                                        continue;
+                                }
+                                (*return_count)++;
+                                /* Should never happen, but still... */
+                                if (*return_count>=numaddrs) {
+                                        break;
+                                }
+                        }
                 }
         }
@@ -1419 +1480 @@
                         return NT_STATUS_INVALID_PARAMETER;
                 }
+                if (is_zero_addr((struct sockaddr *)&(*return_iplist)->ss)) {
+                        SAFE_FREE(*return_iplist);
+                        return NT_STATUS_UNSUCCESSFUL;
+                }
                 *return_count = 1;
                 return NT_STATUS_OK;
@@ -1426 +1491 @@
 
         if (namecache_fetch(name, name_type, return_iplist, return_count)) {
+                *return_count = remove_duplicate_addrs2(*return_iplist,
+                                        *return_count );
                 /* This could be a negative response */
                 if (*return_count > 0) {
@@ -1520 +1587 @@
         the iplist when the PDC is down will cause two sets of timeouts. */
 
-        if ( *return_count ) {
-                *return_count = remove_duplicate_addrs2(*return_iplist,
-                                        *return_count );
-        }
+        *return_count = remove_duplicate_addrs2(*return_iplist, *return_count );
 
         /* Save in name cache */
@@ -1539 +1603 @@
         }
 
-        namecache_store(name, name_type, *return_count, *return_iplist);
+        if (*return_count) {
+                namecache_store(name, name_type, *return_count, *return_iplist);
+        }
 
         /* Display some debugging info */
@@ -2002 +2068 @@
            explicit password servers */
 
-        if (local_count) {
-                local_count = remove_duplicate_addrs2(return_iplist,
-                                local_count );
-        }
+        local_count = remove_duplicate_addrs2(return_iplist, local_count );
 
         /* For DC's we always prioritize IPv4 due to W2K3 not