← Back to branch summary

~ubuntu-branches/ubuntu/gutsy/samba/gutsy-updates

« back to all changes in this revision

Viewing changes to source/lib/util_getent.c

  • Committer: Bazaar Package Importer
  • Author(s): Andrew Mitchell
  • Date: 2006-11-28 20:14:37 UTC
  • mfrom: (0.10.1 upstream)
  • Revision ID: james.westby@ubuntu.com-20061128201437-a6x4lzlhempazocp
Tags: 3.0.23d-1ubuntu1
* Merge from debian unstable.
* Drop python2.4-samba, replace with python-samba. Added Conflicts/Replaces
  on python2.4-samba
* Drop track-connection-dos.patch, ubuntu-winbind-panic.patch, 
  ubuntu-fix-ldap.patch, ubuntu-setlocale.patch, ubuntu-setlocale-fixes.patch
* Remaining Ubuntu changes:
  - Revert Debian's installation of mount.cifs and umount.cifs as suid
  - Comment out the default [homes] shares and add more verbose comments to
    explain what they do and how they work (closes: launchpad.net/27608)
  - Add a "valid users = %S" stanza to the commented-out [homes] section, to
    show users how to restrict access to \\server\username to only username.
  - Change the (commented-out) "printer admin" example to use "@lpadmin"
    instead of "@ntadmin", since the lpadmin group is used for spool admin.
  - Alter the panic-action script to encourage users to report their
    bugs in Ubuntu packages to Ubuntu, rather than reporting to Debian.
    Modify text to more closely match the Debian script
  - Munge our init script to deal with the fact that our implementation
    (or lack thereof) of log_daemon_msg and log_progress_msg differs
    from Debian's implementation of the same (Ubuntu #19691)
  - Kept ubuntu-auxsrc.patch: some auxilliary sources (undocumented in 
    previous changelogs)
  - Set default workgroup to MSHOME

Show diffs side-by-side

added added

removed removed

Lines of Context:
source/lib/util_getent.c
1
 
/*
2
 
   Unix SMB/CIFS implementation.
3
 
   Samba utility functions
4
 
   Copyright (C) Simo Sorce 2001
5
 
   Copyright (C) Jeremy Allison 2001
6
 
 
7
 
   This program is free software; you can redistribute it and/or modify
8
 
   it under the terms of the GNU General Public License as published by
9
 
   the Free Software Foundation; either version 2 of the License, or
10
 
   (at your option) any later version.
11
 
   
12
 
   This program is distributed in the hope that it will be useful,
13
 
   but WITHOUT ANY WARRANTY; without even the implied warranty of
14
 
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15
 
   GNU General Public License for more details.
16
 
   
17
 
   You should have received a copy of the GNU General Public License
18
 
   along with this program; if not, write to the Free Software
19
 
   Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
20
 
*/
21
 
 
22
 
#include "includes.h"
23
 
 
24
 
 
25
 
/****************************************************************
26
 
 Returns a single linked list of group entries.
27
 
 Use grent_free() to free it after use.
28
 
****************************************************************/
29
 
 
30
 
struct sys_grent * getgrent_list(void)
31
 
{
32
 
        struct sys_grent *glist;
33
 
        struct sys_grent *gent;
34
 
        struct group *grp;
35
 
        
36
 
        gent = SMB_MALLOC_P(struct sys_grent);
37
 
        if (gent == NULL) {
38
 
                DEBUG (0, ("Out of memory in getgrent_list!\n"));
39
 
                return NULL;
40
 
        }
41
 
        memset(gent, '\0', sizeof(struct sys_grent));
42
 
        glist = gent;
43
 
        
44
 
        setgrent();
45
 
        grp = getgrent();
46
 
        if (grp == NULL) {
47
 
                endgrent();
48
 
                SAFE_FREE(glist);
49
 
                return NULL;
50
 
        }
51
 
 
52
 
        while (grp != NULL) {
53
 
                int i,num;
54
 
                
55
 
                if (grp->gr_name) {
56
 
                        if ((gent->gr_name = SMB_STRDUP(grp->gr_name)) == NULL)
57
 
                                goto err;
58
 
                }
59
 
                if (grp->gr_passwd) {
60
 
                        if ((gent->gr_passwd = SMB_STRDUP(grp->gr_passwd)) == NULL)
61
 
                                goto err;
62
 
                }
63
 
                gent->gr_gid = grp->gr_gid;
64
 
                
65
 
                /* number of strings in gr_mem */
66
 
                for (num = 0; grp->gr_mem[num]; num++)
67
 
                        ;
68
 
                
69
 
                /* alloc space for gr_mem string pointers */
70
 
                if ((gent->gr_mem = SMB_MALLOC_ARRAY(char *, num+1)) == NULL)
71
 
                        goto err;
72
 
 
73
 
                memset(gent->gr_mem, '\0', (num+1) * sizeof(char *));
74
 
 
75
 
                for (i=0; i < num; i++) {
76
 
                        if ((gent->gr_mem[i] = SMB_STRDUP(grp->gr_mem[i])) == NULL)
77
 
                                goto err;
78
 
                }
79
 
                gent->gr_mem[num] = NULL;
80
 
                
81
 
                grp = getgrent();
82
 
                if (grp) {
83
 
                        gent->next = SMB_MALLOC_P(struct sys_grent);
84
 
                        if (gent->next == NULL)
85
 
                                goto err;
86
 
                        gent = gent->next;
87
 
                        memset(gent, '\0', sizeof(struct sys_grent));
88
 
                }
89
 
        }
90
 
        
91
 
        endgrent();
92
 
        return glist;
93
 
 
94
 
  err:
95
 
 
96
 
        endgrent();
97
 
        DEBUG(0, ("Out of memory in getgrent_list!\n"));
98
 
        grent_free(glist);
99
 
        return NULL;
100
 
}
101
 
 
102
 
/****************************************************************
103
 
 Free the single linked list of group entries made by
104
 
 getgrent_list()
105
 
****************************************************************/
106
 
 
107
 
void grent_free (struct sys_grent *glist)
108
 
{
109
 
        while (glist) {
110
 
                struct sys_grent *prev;
111
 
                
112
 
                SAFE_FREE(glist->gr_name);
113
 
                SAFE_FREE(glist->gr_passwd);
114
 
                if (glist->gr_mem) {
115
 
                        int i;
116
 
                        for (i = 0; glist->gr_mem[i]; i++)
117
 
                                SAFE_FREE(glist->gr_mem[i]);
118
 
                        SAFE_FREE(glist->gr_mem);
119
 
                }
120
 
                prev = glist;
121
 
                glist = glist->next;
122
 
                SAFE_FREE(prev);
123
 
        }
124
 
}
125
 
 
126
 
/****************************************************************
127
 
 Returns a single linked list of passwd entries.
128
 
 Use pwent_free() to free it after use.
129
 
****************************************************************/
130
 
 
131
 
struct sys_pwent * getpwent_list(void)
132
 
{
133
 
        struct sys_pwent *plist;
134
 
        struct sys_pwent *pent;
135
 
        struct passwd *pwd;
136
 
        
137
 
        pent = SMB_MALLOC_P(struct sys_pwent);
138
 
        if (pent == NULL) {
139
 
                DEBUG (0, ("Out of memory in getpwent_list!\n"));
140
 
                return NULL;
141
 
        }
142
 
        plist = pent;
143
 
        
144
 
        setpwent();
145
 
        pwd = getpwent();
146
 
        while (pwd != NULL) {
147
 
                memset(pent, '\0', sizeof(struct sys_pwent));
148
 
                if (pwd->pw_name) {
149
 
                        if ((pent->pw_name = SMB_STRDUP(pwd->pw_name)) == NULL)
150
 
                                goto err;
151
 
                }
152
 
                if (pwd->pw_passwd) {
153
 
                        if ((pent->pw_passwd = SMB_STRDUP(pwd->pw_passwd)) == NULL)
154
 
                                goto err;
155
 
                }
156
 
                pent->pw_uid = pwd->pw_uid;
157
 
                pent->pw_gid = pwd->pw_gid;
158
 
                if (pwd->pw_gecos) {
159
 
                        if ((pent->pw_gecos = SMB_STRDUP(pwd->pw_gecos)) == NULL)
160
 
                                goto err;
161
 
                }
162
 
                if (pwd->pw_dir) {
163
 
                        if ((pent->pw_dir = SMB_STRDUP(pwd->pw_dir)) == NULL)
164
 
                                goto err;
165
 
                }
166
 
                if (pwd->pw_shell) {
167
 
                        if ((pent->pw_shell = SMB_STRDUP(pwd->pw_shell)) == NULL)
168
 
                                goto err;
169
 
                }
170
 
 
171
 
                pwd = getpwent();
172
 
                if (pwd) {
173
 
                        pent->next = SMB_MALLOC_P(struct sys_pwent);
174
 
                        if (pent->next == NULL)
175
 
                                goto err;
176
 
                        pent = pent->next;
177
 
                }
178
 
        }
179
 
        
180
 
        endpwent();
181
 
        return plist;
182
 
 
183
 
  err:
184
 
 
185
 
        endpwent();
186
 
        DEBUG(0, ("Out of memory in getpwent_list!\n"));
187
 
        pwent_free(plist);
188
 
        return NULL;
189
 
}
190
 
 
191
 
/****************************************************************
192
 
 Free the single linked list of passwd entries made by
193
 
 getpwent_list()
194
 
****************************************************************/
195
 
 
196
 
void pwent_free (struct sys_pwent *plist)
197
 
{
198
 
        while (plist) {
199
 
                struct sys_pwent *prev;
200
 
                
201
 
                SAFE_FREE(plist->pw_name);
202
 
                SAFE_FREE(plist->pw_passwd);
203
 
                SAFE_FREE(plist->pw_gecos);
204
 
                SAFE_FREE(plist->pw_dir);
205
 
                SAFE_FREE(plist->pw_shell);
206
 
 
207
 
                prev = plist;
208
 
                plist = plist->next;
209
 
                SAFE_FREE(prev);
210
 
        }
211
 
}
212
 
 
213
 
/****************************************************************
214
 
 Add the individual group users onto the list.
215
 
****************************************************************/
216
 
 
217
 
static struct sys_userlist *add_members_to_userlist(struct sys_userlist *list_head, const struct group *grp)
218
 
{
219
 
        size_t num_users, i;
220
 
 
221
 
        /* Count the number of users. */
222
 
        for (num_users = 0; grp->gr_mem[num_users]; num_users++)
223
 
                ;
224
 
 
225
 
        for (i = 0; i < num_users; i++) {
226
 
                struct sys_userlist *entry = SMB_MALLOC_P(struct sys_userlist);
227
 
                if (entry == NULL) {
228
 
                        free_userlist(list_head);
229
 
                        return NULL;
230
 
                }
231
 
                entry->unix_name = (char *)SMB_STRDUP(grp->gr_mem[i]);
232
 
                if (entry->unix_name == NULL) {
233
 
                        SAFE_FREE(entry);
234
 
                        free_userlist(list_head);
235
 
                        return NULL;
236
 
                }
237
 
                DLIST_ADD(list_head, entry);
238
 
        }
239
 
        return list_head;
240
 
}
241
 
 
242
 
/*****************************************************************
243
 
 Splits passed user or group name to domain and user/group name parts
244
 
 Returns True if name was splitted and False otherwise.
245
 
*****************************************************************/
246
 
 
247
 
static BOOL split_domain_and_name(const char *name, char *domain,
248
 
                                  char* username)
249
 
{
250
 
        char *p = strchr(name,*lp_winbind_separator());
251
 
        
252
 
        
253
 
        /* Parse a string of the form DOMAIN/user into a domain and a user */
254
 
        DEBUG(10,("split_domain_and_name: checking whether name |%s| local or "
255
 
                  "not\n", name));
256
 
        
257
 
        if (p) {
258
 
                fstrcpy(username, p+1);
259
 
                fstrcpy(domain, name);
260
 
                domain[PTR_DIFF(p, name)] = 0;
261
 
        } else if (lp_winbind_use_default_domain()) {
262
 
                fstrcpy(username, name);
263
 
                fstrcpy(domain, lp_workgroup());
264
 
        } else {
265
 
                return False;
266
 
        }
267
 
 
268
 
        DEBUG(10,("split_domain_and_name: all is fine, domain is |%s| and "
269
 
                  "name is |%s|\n", domain, username));
270
 
        return True;
271
 
}
272
 
 
273
 
/****************************************************************
274
 
 Get the list of UNIX users in a group.
275
 
 We have to enumerate the /etc/group file as some UNIX getgrnam()
276
 
 calls won't do that for us (notably Tru64 UNIX).
277
 
****************************************************************/
278
 
 
279
 
struct sys_userlist *get_users_in_group(const char *gname)
280
 
{
281
 
        struct sys_userlist *list_head = NULL;
282
 
        struct group *gptr;
283
 
        fstring domain;
284
 
        fstring groupname;
285
 
        DOM_SID sid;
286
 
        enum SID_NAME_USE name_type;
287
 
 
288
 
        /* No point using winbind if we can't split it in the
289
 
           first place */
290
 
        if (split_domain_and_name(gname, domain, groupname)) {
291
 
 
292
 
                /*
293
 
                 * If we're doing this via winbindd, don't do the
294
 
                 * entire group list enumeration as we know this is
295
 
                 * pointless (and slow).
296
 
                 */
297
 
                
298
 
                if (winbind_lookup_name(domain, groupname, &sid, &name_type) 
299
 
                    && name_type == SID_NAME_DOM_GRP) {
300
 
                        if ((gptr = (struct group *)getgrnam(gname)) == NULL)
301
 
                                return NULL;
302
 
                        return add_members_to_userlist(list_head, gptr);
303
 
                }
304
 
        }
305
 
        
306
 
#if !defined(BROKEN_GETGRNAM)
307
 
        if ((gptr = (struct group *)getgrnam(gname)) == NULL)
308
 
                return NULL;
309
 
        return add_members_to_userlist(list_head, gptr);
310
 
#else
311
 
        /* BROKEN_GETGRNAM - True64 */
312
 
        setgrent();
313
 
        while((gptr = getgrent()) != NULL) {
314
 
                if (strequal(gname, gptr->gr_name)) {
315
 
                        list_head = add_members_to_userlist(list_head, gptr);
316
 
                        if (list_head == NULL)
317
 
                                return NULL;
318
 
                }
319
 
        }
320
 
        endgrent();
321
 
        return list_head;
322
 
#endif
323
 
}
324
 
 
325
 
/****************************************************************
326
 
 Free list allocated above.
327
 
****************************************************************/
328
 
 
329
 
void free_userlist(struct sys_userlist *list_head)
330
 
{
331
 
        while (list_head) {
332
 
                struct sys_userlist *old_head = list_head;
333
 
                DLIST_REMOVE(list_head, list_head);
334
 
                SAFE_FREE(old_head->unix_name);
335
 
                SAFE_FREE(old_head);
336
 
        }
337
 
}