Changeset 745 for trunk/server/nsswitch/libwbclient/wbc_sid.c

Timestamp:

Nov 27, 2012, 4:43:17 PM (13 years ago)

Author:

Silvan Scherrer

Message:

Samba Server: updated trunk to 3.6.0

Location:

trunk/server

Files:

• . (modified) (1 prop)
• nsswitch/libwbclient/wbc_sid.c (modified) (34 diffs)

trunk/server/nsswitch/libwbclient/wbc_sid.c

@@ -5 +5 @@
 
    Copyright (C) Gerald (Jerry) Carter 2007
+   Copyright (C) Volker Lendecke 2010
 
 
@@ -25 +26 @@
 #include "replace.h"
 #include "libwbclient.h"
-
-
-/* Convert a binary SID to a character string */
-wbcErr wbcSidToString(const struct wbcDomainSid *sid,
-                      char **sid_string)
-{
-        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+#include "../winbind_client.h"
+
+/* Convert a sid to a string into a buffer. Return the string
+ * length. If buflen is too small, return the string length that would
+ * result if it was long enough. */
+int wbcSidToStringBuf(const struct wbcDomainSid *sid, char *buf, int buflen)
+{
         uint32_t id_auth;
-        int i;
-        char *tmp = NULL;
+        int i, ofs;
 
         if (!sid) {
-                wbc_status = WBC_ERR_INVALID_SID;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
+                strlcpy(buf, "(NULL SID)", buflen);
+                return 10;      /* strlen("(NULL SID)") */
+        }
+
+        /*
+         * BIG NOTE: this function only does SIDS where the identauth is not
+         * >= ^32 in a range of 2^48.
+         */
 
         id_auth = sid->id_auth[5] +
@@ -46 +51 @@
                 (sid->id_auth[2] << 24);
 
-        tmp = talloc_asprintf(NULL, "S-%d-%d", sid->sid_rev_num, id_auth);
-        BAIL_ON_PTR_ERROR(tmp, wbc_status);
-
-        for (i=0; i<sid->num_auths; i++) {
-                char *tmp2;
-                tmp2 = talloc_asprintf_append(tmp, "-%u", sid->sub_auths[i]);
-                BAIL_ON_PTR_ERROR(tmp2, wbc_status);
-
-                tmp = tmp2;
-        }
-
-        *sid_string = tmp;
-        tmp = NULL;
-
-        wbc_status = WBC_ERR_SUCCESS;
-
-done:
-        talloc_free(tmp);
-
-        return wbc_status;
+        ofs = snprintf(buf, buflen, "S-%u-%lu",
+                       (unsigned int)sid->sid_rev_num, (unsigned long)id_auth);
+
+        for (i = 0; i < sid->num_auths; i++) {
+                ofs += snprintf(buf + ofs, MAX(buflen - ofs, 0), "-%lu",
+                                (unsigned long)sid->sub_auths[i]);
+        }
+        return ofs;
+}
+
+/* Convert a binary SID to a character string */
+wbcErr wbcSidToString(const struct wbcDomainSid *sid,
+                      char **sid_string)
+{
+        char buf[WBC_SID_STRING_BUFLEN];
+        char *result;
+        int len;
+
+        if (!sid) {
+                return WBC_ERR_INVALID_SID;
+        }
+
+        len = wbcSidToStringBuf(sid, buf, sizeof(buf));
+
+        if (len+1 > sizeof(buf)) {
+                return WBC_ERR_INVALID_SID;
+        }
+
+        result = (char *)wbcAllocateMemory(len+1, 1, NULL);
+        if (result == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+        memcpy(result, buf, len+1);
+
+        *sid_string = result;
+        return WBC_ERR_SUCCESS;
 }
 
@@ -132 +153 @@
                 sid->sub_auths[sid->num_auths++] = x;
 
-                if ((*q!='-') || (*q=='\0'))
+                if (*q != '-') {
                         break;
+                }
                 p = q + 1;
         }
@@ -150 +172 @@
 
 }
+
 
 /* Convert a domain and name to SID */
@@ -194 +217 @@
 }
 
+
 /* Convert a SID to a domain and name */
 wbcErr wbcLookupSid(const struct wbcDomainSid *sid,
@@ -203 +227 @@
         struct winbindd_response response;
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
-        char *sid_string = NULL;
-        char *domain = NULL;
-        char *name = NULL;
-        enum wbcSidType name_type = WBC_SID_NAME_USE_NONE;
+        char *domain, *name;
 
         if (!sid) {
-                wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
+                return WBC_ERR_INVALID_PARAM;
         }
 
@@ -218 +238 @@
         ZERO_STRUCT(response);
 
-        /* dst is already null terminated from the memset above */
-
-        wbc_status = wbcSidToString(sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
+        wbcSidToStringBuf(sid, request.data.sid, sizeof(request.data.sid));
 
         /* Make request */
 
-        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSID,
-                                           &request,
-                                           &response);
-        BAIL_ON_WBC_ERROR(wbc_status);
+        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSID, &request,
+                                        &response);
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                return wbc_status;
+        }
 
         /* Copy out result */
 
-        domain = talloc_strdup(NULL, response.data.name.dom_name);
-        BAIL_ON_PTR_ERROR(domain, wbc_status);
-
-        name = talloc_strdup(NULL, response.data.name.name);
-        BAIL_ON_PTR_ERROR(name, wbc_status);
-
-        name_type = (enum wbcSidType)response.data.name.type;
-
+        wbc_status = WBC_ERR_NO_MEMORY;
+        domain = NULL;
+        name = NULL;
+
+        domain = wbcStrDup(response.data.name.dom_name);
+        if (domain == NULL) {
+                goto done;
+        }
+        name = wbcStrDup(response.data.name.name);
+        if (name == NULL) {
+                goto done;
+        }
+        if (pdomain != NULL) {
+                *pdomain = domain;
+                domain = NULL;
+        }
+        if (pname != NULL) {
+                *pname = name;
+                name = NULL;
+        }
+        if (pname_type != NULL) {
+                *pname_type = (enum wbcSidType)response.data.name.type;
+        }
         wbc_status = WBC_ERR_SUCCESS;
-
- done:
-        if (WBC_ERROR_IS_OK(wbc_status)) {
-                if (pdomain != NULL) {
-                        *pdomain = domain;
-                } else {
-                        TALLOC_FREE(domain);
-                }
-                if (pname != NULL) {
-                        *pname = name;
-                } else {
-                        TALLOC_FREE(name);
-                }
-                if (pname_type != NULL) {
-                        *pname_type = name_type;
-                }
-        }
-        else {
-#if 0
-                /*
-                 * Found by Coverity: In this particular routine we can't end
-                 * up here with a non-NULL name. Further up there are just two
-                 * exit paths that lead here, neither of which leave an
-                 * allocated name. If you add more paths up there, re-activate
-                 * this.
-                 */
-                if (name != NULL) {
-                        talloc_free(name);
-                }
-#endif
-                if (domain != NULL) {
-                        talloc_free(domain);
-                }
-        }
-
+done:
+        wbcFreeMemory(name);
+        wbcFreeMemory(domain);
+        return wbc_status;
+}
+
+static void wbcDomainInfosDestructor(void *ptr)
+{
+        struct wbcDomainInfo *i = (struct wbcDomainInfo *)ptr;
+
+        while (i->short_name != NULL) {
+                wbcFreeMemory(i->short_name);
+                wbcFreeMemory(i->dns_name);
+                i += 1;
+        }
+}
+
+static void wbcTranslatedNamesDestructor(void *ptr)
+{
+        struct wbcTranslatedName *n = (struct wbcTranslatedName *)ptr;
+
+        while (n->name != NULL) {
+                free(n->name);
+                n += 1;
+        }
+}
+
+wbcErr wbcLookupSids(const struct wbcDomainSid *sids, int num_sids,
+                     struct wbcDomainInfo **pdomains, int *pnum_domains,
+                     struct wbcTranslatedName **pnames)
+{
+        struct winbindd_request request;
+        struct winbindd_response response;
+        wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
+        int buflen, i, extra_len, num_domains, num_names;
+        char *sidlist, *p, *q, *extra_data;
+        struct wbcDomainInfo *domains = NULL;
+        struct wbcTranslatedName *names = NULL;
+
+        buflen = num_sids * (WBC_SID_STRING_BUFLEN + 1) + 1;
+
+        sidlist = (char *)malloc(buflen);
+        if (sidlist == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+
+        p = sidlist;
+
+        for (i=0; i<num_sids; i++) {
+                int remaining;
+                int len;
+
+                remaining = buflen - (p - sidlist);
+
+                len = wbcSidToStringBuf(&sids[i], p, remaining);
+                if (len > remaining) {
+                        free(sidlist);
+                        return WBC_ERR_UNKNOWN_FAILURE;
+                }
+
+                p += len;
+                *p++ = '\n';
+        }
+        *p++ = '\0';
+
+        ZERO_STRUCT(request);
+        ZERO_STRUCT(response);
+
+        request.extra_data.data = sidlist;
+        request.extra_len = p - sidlist;
+
+        wbc_status = wbcRequestResponse(WINBINDD_LOOKUPSIDS,
+                                        &request, &response);
+        free(sidlist);
+        if (!WBC_ERROR_IS_OK(wbc_status)) {
+                return wbc_status;
+        }
+
+        extra_len = response.length - sizeof(struct winbindd_response);
+        extra_data = (char *)response.extra_data.data;
+
+        if ((extra_len <= 0) || (extra_data[extra_len-1] != '\0')) {
+                goto wbc_err_invalid;
+        }
+
+        p = extra_data;
+
+        num_domains = strtoul(p, &q, 10);
+        if (*q != '\n') {
+                goto wbc_err_invalid;
+        }
+        p = q+1;
+
+        domains = (struct wbcDomainInfo *)wbcAllocateMemory(
+                num_domains+1, sizeof(struct wbcDomainInfo),
+                wbcDomainInfosDestructor);
+        if (domains == NULL) {
+                wbc_status = WBC_ERR_NO_MEMORY;
+                goto fail;
+        }
+
+        for (i=0; i<num_domains; i++) {
+
+                q = strchr(p, ' ');
+                if (q == NULL) {
+                        goto wbc_err_invalid;
+                }
+                *q = '\0';
+                wbc_status = wbcStringToSid(p, &domains[i].sid);
+                if (!WBC_ERROR_IS_OK(wbc_status)) {
+                        goto fail;
+                }
+                p = q+1;
+
+                q = strchr(p, '\n');
+                if (q == NULL) {
+                        goto wbc_err_invalid;
+                }
+                *q = '\0';
+                domains[i].short_name = wbcStrDup(p);
+                if (domains[i].short_name == NULL) {
+                        wbc_status = WBC_ERR_NO_MEMORY;
+                        goto fail;
+                }
+                p = q+1;
+        }
+
+        num_names = strtoul(p, &q, 10);
+        if (*q != '\n') {
+                goto wbc_err_invalid;
+        }
+        p = q+1;
+
+        if (num_names != num_sids) {
+                goto wbc_err_invalid;
+        }
+
+        names = (struct wbcTranslatedName *)wbcAllocateMemory(
+                num_names+1, sizeof(struct wbcTranslatedName),
+                wbcTranslatedNamesDestructor);
+        if (names == NULL) {
+                wbc_status = WBC_ERR_NO_MEMORY;
+                goto fail;
+        }
+
+        for (i=0; i<num_names; i++) {
+
+                names[i].domain_index = strtoul(p, &q, 10);
+                if (*q != ' ') {
+                        goto wbc_err_invalid;
+                }
+                p = q+1;
+
+                names[i].type = strtoul(p, &q, 10);
+                if (*q != ' ') {
+                        goto wbc_err_invalid;
+                }
+                p = q+1;
+
+                q = strchr(p, '\n');
+                if (q == NULL) {
+                        goto wbc_err_invalid;
+                }
+                *q = '\0';
+                names[i].name = wbcStrDup(p);
+                if (names[i].name == NULL) {
+                        wbc_status = WBC_ERR_NO_MEMORY;
+                        goto fail;
+                }
+                p = q+1;
+        }
+        if (*p != '\0') {
+                goto wbc_err_invalid;
+        }
+
+        *pdomains = domains;
+        *pnames = names;
+        winbindd_free_response(&response);
+        return WBC_ERR_SUCCESS;
+
+wbc_err_invalid:
+        wbc_status = WBC_ERR_INVALID_RESPONSE;
+fail:
+        winbindd_free_response(&response);
+        wbcFreeMemory(domains);
+        wbcFreeMemory(names);
         return wbc_status;
 }
@@ -296 +477 @@
         struct winbindd_request request;
         struct winbindd_response response;
-        char *sid_string = NULL;
         char *domain_name = NULL;
         const char **names = NULL;
@@ -312 +492 @@
         }
 
-        wbc_status = wbcSidToString(dom_sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
+        wbcSidToStringBuf(dom_sid, request.data.sid, sizeof(request.data.sid));
 
         /* Even if all the Rids were of maximum 32bit values,
@@ -325 +501 @@
         ridbuf_size = (sizeof(char)*11) * num_rids + 1;
 
-        ridlist = talloc_zero_array(NULL, char, ridbuf_size);
+        ridlist = (char *)malloc(ridbuf_size);
         BAIL_ON_PTR_ERROR(ridlist, wbc_status);
 
         len = 0;
-        for (i=0; i<num_rids && (len-1)>0; i++) {
-                char ridstr[12];
-
-                len = strlen(ridlist);
-                p = ridlist + len;
-
-                snprintf( ridstr, sizeof(ridstr)-1, "%u\n", rids[i]);
-                strncat(p, ridstr, ridbuf_size-len-1);
-        }
+        for (i=0; i<num_rids; i++) {
+                len += snprintf(ridlist + len, ridbuf_size - len, "%u\n",
+                                rids[i]);
+        }
+        ridlist[len] = '\0';
+        len += 1;
 
         request.extra_data.data = ridlist;
-        request.extra_len = strlen(ridlist)+1;
+        request.extra_len = len;
 
         wbc_status = wbcRequestResponse(WINBINDD_LOOKUPRIDS,
                                         &request,
                                         &response);
-        talloc_free(ridlist);
+        free(ridlist);
         BAIL_ON_WBC_ERROR(wbc_status);
 
-        domain_name = talloc_strdup(NULL, response.data.domain_name);
+        domain_name = wbcStrDup(response.data.domain_name);
         BAIL_ON_PTR_ERROR(domain_name, wbc_status);
 
-        names = talloc_array(NULL, const char*, num_rids);
+        names = wbcAllocateStringArray(num_rids);
         BAIL_ON_PTR_ERROR(names, wbc_status);
 
-        types = talloc_array(NULL, enum wbcSidType, num_rids);
+        types = (enum wbcSidType *)wbcAllocateMemory(
+                num_rids, sizeof(enum wbcSidType), NULL);
         BAIL_ON_PTR_ERROR(types, wbc_status);
 
@@ -364 +538 @@
                 if (*p == '\0') {
                         wbc_status = WBC_ERR_INVALID_RESPONSE;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -371 +545 @@
                 if (*q != ' ') {
                         wbc_status = WBC_ERR_INVALID_RESPONSE;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
@@ -378 +552 @@
                 if ((q = strchr(p, '\n')) == NULL) {
                         wbc_status = WBC_ERR_INVALID_RESPONSE;
-                        BAIL_ON_WBC_ERROR(wbc_status);
+                        goto done;
                 }
 
                 *q = '\0';
 
-                names[i] = talloc_strdup(names, p);
+                names[i] = strdup(p);
                 BAIL_ON_PTR_ERROR(names[i], wbc_status);
 
@@ -391 +565 @@
         if (*p != '\0') {
                 wbc_status = WBC_ERR_INVALID_RESPONSE;
-                BAIL_ON_WBC_ERROR(wbc_status);
+                goto done;
         }
 
@@ -397 +571 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
+        winbindd_free_response(&response);
 
         if (WBC_ERROR_IS_OK(wbc_status)) {
@@ -407 +579 @@
         }
         else {
-                if (domain_name)
-                        talloc_free(domain_name);
-                if (names)
-                        talloc_free(names);
-                if (types)
-                        talloc_free(types);
+                wbcFreeMemory(domain_name);
+                wbcFreeMemory(names);
+                wbcFreeMemory(types);
         }
 
@@ -428 +597 @@
         struct winbindd_request request;
         struct winbindd_response response;
-        char *sid_string = NULL;
         struct wbcDomainSid *sids = NULL;
         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
@@ -443 +611 @@
         }
 
-        wbc_status = wbcSidToString(user_sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
+        wbcSidToStringBuf(user_sid, request.data.sid, sizeof(request.data.sid));
 
         if (domain_groups_only) {
@@ -466 +630 @@
         }
 
-        sids = talloc_array(NULL, struct wbcDomainSid,
-                            response.data.num_entries);
+        sids = (struct wbcDomainSid *)wbcAllocateMemory(
+                response.data.num_entries, sizeof(struct wbcDomainSid),
+                NULL);
         BAIL_ON_PTR_ERROR(sids, wbc_status);
 
@@ -487 +652 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
+        winbindd_free_response(&response);
         if (sids) {
-                talloc_free(sids);
+                wbcFreeMemory(sids);
         }
 
@@ -519 +682 @@
         struct winbindd_request request;
         struct winbindd_response response;
-        char *sid_string = NULL;
-        ssize_t sid_len;
         ssize_t extra_data_len = 0;
         char * extra_data = NULL;
@@ -535 +696 @@
         if (!dom_sid) {
                 wbc_status = WBC_ERR_INVALID_PARAM;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        wbc_status = wbcSidToString(dom_sid, &sid_string);
-        BAIL_ON_WBC_ERROR(wbc_status);
-
-        strncpy(request.data.sid, sid_string, sizeof(request.data.sid)-1);
-        wbcFreeMemory(sid_string);
-        sid_string = NULL;
-
-        /* Lets assume each sid is around 54 characters
-         * S-1-5-AAAAAAAAAAA-BBBBBBBBBBB-CCCCCCCCCCC-DDDDDDDDDDD\n */
-        buflen = 54 * num_sids;
-        extra_data = talloc_array(NULL, char, buflen);
+                goto done;
+        }
+
+        wbcSidToStringBuf(dom_sid, request.data.sid, sizeof(request.data.sid));
+
+        /* Lets assume each sid is around 57 characters
+         * S-1-5-21-AAAAAAAAAAA-BBBBBBBBBBB-CCCCCCCCCCC-DDDDDDDDDDD\n */
+        buflen = 57 * num_sids;
+        extra_data = (char *)malloc(buflen);
         if (!extra_data) {
                 wbc_status = WBC_ERR_NO_MEMORY;
-                BAIL_ON_WBC_ERROR(wbc_status);
+                goto done;
         }
 
         /* Build the sid list */
         for (i=0; i<num_sids; i++) {
-                if (sid_string) {
-                        wbcFreeMemory(sid_string);
-                        sid_string = NULL;
-                }
-                wbc_status = wbcSidToString(&sids[i], &sid_string);
-                BAIL_ON_WBC_ERROR(wbc_status);
-
-                sid_len = strlen(sid_string);
+                char sid_str[WBC_SID_STRING_BUFLEN];
+                size_t sid_len;
+
+                sid_len = wbcSidToStringBuf(&sids[i], sid_str, sizeof(sid_str));
 
                 if (buflen < extra_data_len + sid_len + 2) {
                         buflen *= 2;
-                        extra_data = talloc_realloc(NULL, extra_data,
-                            char, buflen);
+                        extra_data = (char *)realloc(extra_data, buflen);
                         if (!extra_data) {
                                 wbc_status = WBC_ERR_NO_MEMORY;
@@ -575 +726 @@
                 }
 
-                strncpy(&extra_data[extra_data_len], sid_string,
+                strncpy(&extra_data[extra_data_len], sid_str,
                         buflen - extra_data_len);
                 extra_data_len += sid_len;
@@ -581 +732 @@
                 extra_data[extra_data_len] = '\0';
         }
+        extra_data_len += 1;
 
         request.extra_data.data = extra_data;
@@ -593 +745 @@
             !response.extra_data.data) {
                 wbc_status = WBC_ERR_INVALID_RESPONSE;
-                BAIL_ON_WBC_ERROR(wbc_status);
-        }
-
-        rids = talloc_array(NULL, uint32_t,
-                            response.data.num_entries);
+                goto done;
+        }
+
+        rids = (uint32_t *)wbcAllocateMemory(response.data.num_entries,
+                                             sizeof(uint32_t), NULL);
         BAIL_ON_PTR_ERROR(sids, wbc_status);
 
@@ -619 +771 @@
 
  done:
-        if (sid_string) {
-                wbcFreeMemory(sid_string);
-        }
-        if (extra_data) {
-                talloc_free(extra_data);
-        }
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
-        if (rids) {
-                talloc_free(rids);
-        }
-
+        free(extra_data);
+        winbindd_free_response(&response);
+        wbcFreeMemory(rids);
         return wbc_status;
 }
@@ -663 +805 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
+        users = wbcAllocateStringArray(response.data.num_entries);
+        if (users == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+
         /* Look through extra data */
 
         next = (const char *)response.extra_data.data;
         while (next) {
-                const char **tmp;
-                const char *current = next;
-                char *k = strchr(next, ',');
+                const char *current;
+                char *k;
+
+                if (num_users >= response.data.num_entries) {
+                        wbc_status = WBC_ERR_INVALID_RESPONSE;
+                        goto done;
+                }
+
+                current = next;
+                k = strchr(next, ',');
+
                 if (k) {
                         k[0] = '\0';
@@ -677 +832 @@
                 }
 
-                tmp = talloc_realloc(NULL, users,
-                                     const char *,
-                                     num_users+1);
-                BAIL_ON_PTR_ERROR(tmp, wbc_status);
-                users = tmp;
-
-                users[num_users] = talloc_strdup(users, current);
+                users[num_users] = strdup(current);
                 BAIL_ON_PTR_ERROR(users[num_users], wbc_status);
-
-                num_users++;
-        }
-
-        *_num_users = num_users;
+                num_users += 1;
+        }
+        if (num_users != response.data.num_entries) {
+                wbc_status = WBC_ERR_INVALID_RESPONSE;
+                goto done;
+        }
+
+        *_num_users = response.data.num_entries;
         *_users = users;
         users = NULL;
@@ -695 +847 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
-        if (users) {
-                talloc_free(users);
-        }
+        winbindd_free_response(&response);
+        wbcFreeMemory(users);
         return wbc_status;
 }
@@ -731 +879 @@
         BAIL_ON_WBC_ERROR(wbc_status);
 
+        groups = wbcAllocateStringArray(response.data.num_entries);
+        if (groups == NULL) {
+                return WBC_ERR_NO_MEMORY;
+        }
+
         /* Look through extra data */
 
         next = (const char *)response.extra_data.data;
         while (next) {
-                const char **tmp;
-                const char *current = next;
-                char *k = strchr(next, ',');
+                const char *current;
+                char *k;
+
+                if (num_groups >= response.data.num_entries) {
+                        wbc_status = WBC_ERR_INVALID_RESPONSE;
+                        goto done;
+                }
+
+                current = next;
+                k = strchr(next, ',');
+
                 if (k) {
                         k[0] = '\0';
@@ -745 +906 @@
                 }
 
-                tmp = talloc_realloc(NULL, groups,
-                                     const char *,
-                                     num_groups+1);
-                BAIL_ON_PTR_ERROR(tmp, wbc_status);
-                groups = tmp;
-
-                groups[num_groups] = talloc_strdup(groups, current);
+                groups[num_groups] = strdup(current);
                 BAIL_ON_PTR_ERROR(groups[num_groups], wbc_status);
-
-                num_groups++;
-        }
-
-        *_num_groups = num_groups;
+                num_groups += 1;
+        }
+        if (num_groups != response.data.num_entries) {
+                wbc_status = WBC_ERR_INVALID_RESPONSE;
+                goto done;
+        }
+
+        *_num_groups = response.data.num_entries;
         *_groups = groups;
         groups = NULL;
@@ -763 +921 @@
 
  done:
-        if (response.extra_data.data) {
-                free(response.extra_data.data);
-        }
-        if (groups) {
-                talloc_free(groups);
-        }
+        winbindd_free_response(&response);
+        wbcFreeMemory(groups);
         return wbc_status;
 }
@@ -797 +951 @@
                 wbcFreeMemory(name);
 
-                name = talloc_strdup(NULL, pwd->pw_gecos);
+                name = wbcStrDup(pwd->pw_gecos);
+                wbcFreeMemory(pwd);
                 BAIL_ON_PTR_ERROR(name, wbc_status);
         }