Ignore:
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:
2 edited

Legend:

Unmodified
Added
Removed

  • trunk/server

  • trunk/server/nsswitch/libwbclient/wbc_pwd.c

    r414 r745  
    2525#include "replace.h"
    2626#include "libwbclient.h"
     27#include "../winbind_client.h"
    2728
    2829/** @brief The maximum number of pwent structs to get from winbindd
    … …  
    4041 **/
    4142
     43static void wbcPasswdDestructor(void *ptr)
     44{
     45        struct passwd *pw = (struct passwd *)ptr;
     46        free(pw->pw_name);
     47        free(pw->pw_passwd);
     48        free(pw->pw_gecos);
     49        free(pw->pw_shell);
     50        free(pw->pw_dir);
     51}
     52
    4253static struct passwd *copy_passwd_entry(struct winbindd_pw *p)
    4354{
    44         struct passwd *pwd = NULL;
    45         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
    46 
    47         pwd = talloc(NULL, struct passwd);
    48         BAIL_ON_PTR_ERROR(pwd, wbc_status);
    49 
    50         pwd->pw_name = talloc_strdup(pwd,p->pw_name);
    51         BAIL_ON_PTR_ERROR(pwd->pw_name, wbc_status);
    52 
    53         pwd->pw_passwd = talloc_strdup(pwd, p->pw_passwd);
    54         BAIL_ON_PTR_ERROR(pwd->pw_passwd, wbc_status);
    55 
    56         pwd->pw_gecos = talloc_strdup(pwd, p->pw_gecos);
    57         BAIL_ON_PTR_ERROR(pwd->pw_gecos, wbc_status);
    58 
    59         pwd->pw_shell = talloc_strdup(pwd, p->pw_shell);
    60         BAIL_ON_PTR_ERROR(pwd->pw_shell, wbc_status);
    61 
    62         pwd->pw_dir = talloc_strdup(pwd, p->pw_dir);
    63         BAIL_ON_PTR_ERROR(pwd->pw_dir, wbc_status);
    64 
    65         pwd->pw_uid = p->pw_uid;
    66         pwd->pw_gid = p->pw_gid;
    67 
    68 done:
    69         if (!WBC_ERROR_IS_OK(wbc_status)) {
    70                 talloc_free(pwd);
    71                 pwd = NULL;
    72         }
    73 
    74         return pwd;
     55        struct passwd *pw = NULL;
     56
     57        pw = (struct passwd *)wbcAllocateMemory(1, sizeof(struct passwd),
     58                                                wbcPasswdDestructor);
     59        if (pw == NULL) {
     60                return NULL;
     61        }
     62        pw->pw_name = strdup(p->pw_name);
     63        if (pw->pw_name == NULL) {
     64                goto fail;
     65        }
     66        pw->pw_passwd = strdup(p->pw_passwd);
     67        if (pw->pw_passwd == NULL) {
     68                goto fail;
     69        }
     70        pw->pw_gecos = strdup(p->pw_gecos);
     71        if (pw->pw_gecos == NULL) {
     72                goto fail;
     73        }
     74        pw->pw_shell = strdup(p->pw_shell);
     75        if (pw->pw_shell == NULL) {
     76                goto fail;
     77        }
     78        pw->pw_dir = strdup(p->pw_dir);
     79        if (pw->pw_dir == NULL) {
     80                goto fail;
     81        }
     82        pw->pw_uid = p->pw_uid;
     83        pw->pw_gid = p->pw_gid;
     84        return pw;
     85
     86fail:
     87        wbcFreeMemory(pw);
     88        return NULL;
    7589}
    7690
    … …  
    7892 *
    7993 **/
     94
     95static void wbcGroupDestructor(void *ptr)
     96{
     97        struct group *gr = (struct group *)ptr;
     98        int i;
     99
     100        free(gr->gr_name);
     101        free(gr->gr_passwd);
     102
     103        /* if the array was partly created this can be NULL */
     104        if (gr->gr_mem == NULL) {
     105                return;
     106        }
     107
     108        for (i=0; gr->gr_mem[i] != NULL; i++) {
     109                free(gr->gr_mem[i]);
     110        }
     111        free(gr->gr_mem);
     112}
    80113
    81114static struct group *copy_group_entry(struct winbindd_gr *g,
    82115                                      char *mem_buf)
    83116{
    84         struct group *grp = NULL;
    85         wbcErr wbc_status = WBC_ERR_UNKNOWN_FAILURE;
     117        struct group *gr = NULL;
    86118        int i;
    87119        char *mem_p, *mem_q;
    88120
    89         grp = talloc(NULL, struct group);
    90         BAIL_ON_PTR_ERROR(grp, wbc_status);
    91 
    92         grp->gr_name = talloc_strdup(grp, g->gr_name);
    93         BAIL_ON_PTR_ERROR(grp->gr_name, wbc_status);
    94 
    95         grp->gr_passwd = talloc_strdup(grp, g->gr_passwd);
    96         BAIL_ON_PTR_ERROR(grp->gr_passwd, wbc_status);
    97 
    98         grp->gr_gid = g->gr_gid;
    99 
    100         grp->gr_mem = talloc_array(grp, char*, g->num_gr_mem+1);
     121        gr = (struct group *)wbcAllocateMemory(
     122                1, sizeof(struct group), wbcGroupDestructor);
     123        if (gr == NULL) {
     124                return NULL;
     125        }
     126
     127        gr->gr_name = strdup(g->gr_name);
     128        if (gr->gr_name == NULL) {
     129                goto fail;
     130        }
     131        gr->gr_passwd = strdup(g->gr_passwd);
     132        if (gr->gr_passwd == NULL) {
     133                goto fail;
     134        }
     135        gr->gr_gid = g->gr_gid;
     136
     137        gr->gr_mem = (char **)calloc(g->num_gr_mem+1, sizeof(char *));
     138        if (gr->gr_mem == NULL) {
     139                goto fail;
     140        }
    101141
    102142        mem_p = mem_q = mem_buf;
    103143        for (i=0; i<g->num_gr_mem && mem_p; i++) {
    104                 if ((mem_q = strchr(mem_p, ',')) != NULL) {
     144                mem_q = strchr(mem_p, ',');
     145                if (mem_q != NULL) {
    105146                        *mem_q = '\0';
    106147                }
    107148
    108                 grp->gr_mem[i] = talloc_strdup(grp, mem_p);
    109                 BAIL_ON_PTR_ERROR(grp->gr_mem[i], wbc_status);
     149                gr->gr_mem[i] = strdup(mem_p);
     150                if (gr->gr_mem[i] == NULL) {
     151                        goto fail;
     152                }
    110153
    111154                if (mem_q == NULL) {
    … …  
    115158                mem_p = mem_q + 1;
    116159        }
    117         grp->gr_mem[i] = NULL;
    118 
    119         wbc_status = WBC_ERR_SUCCESS;
    120 
    121 done:
    122         if (!WBC_ERROR_IS_OK(wbc_status)) {
    123                 talloc_free(grp);
    124                 grp = NULL;
    125         }
    126 
    127         return grp;
     160        gr->gr_mem[i] = NULL;
     161
     162        return gr;
     163
     164fail:
     165        wbcFreeMemory(gr);
     166        return NULL;
    128167}
    129168
    … …  
    198237        struct winbindd_request request;
    199238        struct winbindd_response response;
    200         char * sid_string = NULL;
    201239
    202240        if (!pwd) {
    … …  
    205243        }
    206244
    207         wbc_status = wbcSidToString(sid, &sid_string);
    208         BAIL_ON_WBC_ERROR(wbc_status);
    209 
    210245        /* Initialize request */
    211246
    … …  
    213248        ZERO_STRUCT(response);
    214249
    215         strncpy(request.data.sid, sid_string, sizeof(request.data.sid));
     250        wbcSidToStringBuf(sid, request.data.sid, sizeof(request.data.sid));
    216251
    217252        wbc_status = wbcRequestResponse(WINBINDD_GETPWSID,
    … …  
    224259
    225260 done:
    226         if (sid_string) {
    227                 wbcFreeMemory(sid_string);
    228         }
    229 
    230261        return wbc_status;
    231262}
    … …  
    262293
    263294 done:
    264         if (response.extra_data.data)
    265                 free(response.extra_data.data);
     295        winbindd_free_response(&response);
    266296
    267297        return wbc_status;
    … …  
    297327
    298328 done:
    299         if (response.extra_data.data)
    300                 free(response.extra_data.data);
     329        winbindd_free_response(&response);
    301330
    302331        return wbc_status;
    … …  
    325354        if (pw_cache_size > 0) {
    326355                pw_cache_idx = pw_cache_size = 0;
    327                 if (pw_response.extra_data.data) {
    328                         free(pw_response.extra_data.data);
    329                 }
     356                winbindd_free_response(&pw_response);
    330357        }
    331358
    … …  
    347374        if (pw_cache_size > 0) {
    348375                pw_cache_idx = pw_cache_size = 0;
    349                 if (pw_response.extra_data.data) {
    350                         free(pw_response.extra_data.data);
    351                 }
     376                winbindd_free_response(&pw_response);
    352377        }
    353378
    … …  
    376401        pw_cache_idx = 0;
    377402
    378         if (pw_response.extra_data.data) {
    379                 free(pw_response.extra_data.data);
    380                 ZERO_STRUCT(pw_response);
    381         }
     403        winbindd_free_response(&pw_response);
    382404
    383405        ZERO_STRUCT(request);
    … …  
    427449        if (gr_cache_size > 0) {
    428450                gr_cache_idx = gr_cache_size = 0;
    429                 if (gr_response.extra_data.data) {
    430                         free(gr_response.extra_data.data);
    431                 }
     451                winbindd_free_response(&gr_response);
    432452        }
    433453
    … …  
    449469        if (gr_cache_size > 0) {
    450470                gr_cache_idx = gr_cache_size = 0;
    451                 if (gr_response.extra_data.data) {
    452                         free(gr_response.extra_data.data);
    453                 }
     471                winbindd_free_response(&gr_response);
    454472        }
    455473
    … …  
    479497        gr_cache_idx = 0;
    480498
    481         if (gr_response.extra_data.data) {
    482                 free(gr_response.extra_data.data);
    483                 ZERO_STRUCT(gr_response);
    484         }
     499        winbindd_free_response(&gr_response);
    485500
    486501        ZERO_STRUCT(request);
    … …  
    528543        gr_cache_idx = 0;
    529544
    530         if (gr_response.extra_data.data) {
    531                 free(gr_response.extra_data.data);
    532                 ZERO_STRUCT(gr_response);
    533         }
     545        winbindd_free_response(&gr_response);
     546        ZERO_STRUCT(gr_response);
    534547
    535548        ZERO_STRUCT(request);
    … …  
    587600        BAIL_ON_WBC_ERROR(wbc_status);
    588601
    589         groups = talloc_array(NULL, gid_t, response.data.num_entries);
     602        groups = (gid_t *)wbcAllocateMemory(
     603                response.data.num_entries, sizeof(gid_t), NULL);
    590604        BAIL_ON_PTR_ERROR(groups, wbc_status);
    591605
    … …  
    601615
    602616 done:
    603         if (response.extra_data.data) {
    604                 free(response.extra_data.data);
    605         }
    606         if (groups) {
    607                 talloc_free(groups);
    608         }
    609 
    610         return wbc_status;
    611 }
     617        winbindd_free_response(&response);
     618        wbcFreeMemory(groups);
     619        return wbc_status;
     620}
Note: See TracChangeset for help on using the changeset viewer.