source: vendor/3.6.23/lib/util/util_getent.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 16 years ago

Samba 3.5.0: Initial import
File size: 6.8 KB
Line 
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 3 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, see <http://www.gnu.org/licenses/>.
19*/
20
21#include "includes.h"
22
23
24/****************************************************************
25 Returns a single linked list of group entries.
26 Use grent_free() to free it after use.
27****************************************************************/
28
29struct sys_grent * getgrent_list(void)
30{
31 struct sys_grent *glist;
32 struct sys_grent *gent;
33 struct group *grp;
34
35 gent = malloc_p(struct sys_grent);
36 if (gent == NULL) {
37 DEBUG (0, ("Out of memory in getgrent_list!\n"));
38 return NULL;
39 }
40 memset(gent, '\0', sizeof(struct sys_grent));
41 glist = gent;
42
43 setgrent();
44 grp = getgrent();
45 if (grp == NULL) {
46 endgrent();
47 SAFE_FREE(glist);
48 return NULL;
49 }
50
51 while (grp != NULL) {
52 int i,num;
53
54 if (grp->gr_name) {
55 if ((gent->gr_name = strdup(grp->gr_name)) == NULL)
56 goto err;
57 }
58 if (grp->gr_passwd) {
59 if ((gent->gr_passwd = strdup(grp->gr_passwd)) == NULL)
60 goto err;
61 }
62 gent->gr_gid = grp->gr_gid;
63
64 /* number of strings in gr_mem */
65 for (num = 0; grp->gr_mem[num]; num++)
66 ;
67
68 /* alloc space for gr_mem string pointers */
69 if ((gent->gr_mem = malloc_array_p(char *, num+1)) == NULL)
70 goto err;
71
72 memset(gent->gr_mem, '\0', (num+1) * sizeof(char *));
73
74 for (i=0; i < num; i++) {
75 if ((gent->gr_mem[i] = strdup(grp->gr_mem[i])) == NULL)
76 goto err;
77 }
78 gent->gr_mem[num] = NULL;
79
80 grp = getgrent();
81 if (grp) {
82 gent->next = malloc_p(struct sys_grent);
83 if (gent->next == NULL)
84 goto err;
85 gent = gent->next;
86 memset(gent, '\0', sizeof(struct sys_grent));
87 }
88 }
89
90 endgrent();
91 return glist;
92
93 err:
94
95 endgrent();
96 DEBUG(0, ("Out of memory in getgrent_list!\n"));
97 grent_free(glist);
98 return NULL;
99}
100
101/****************************************************************
102 Free the single linked list of group entries made by
103 getgrent_list()
104****************************************************************/
105
106void grent_free (struct sys_grent *glist)
107{
108 while (glist) {
109 struct sys_grent *prev;
110
111 SAFE_FREE(glist->gr_name);
112 SAFE_FREE(glist->gr_passwd);
113 if (glist->gr_mem) {
114 int i;
115 for (i = 0; glist->gr_mem[i]; i++)
116 SAFE_FREE(glist->gr_mem[i]);
117 SAFE_FREE(glist->gr_mem);
118 }
119 prev = glist;
120 glist = glist->next;
121 SAFE_FREE(prev);
122 }
123}
124
125/****************************************************************
126 Returns a single linked list of passwd entries.
127 Use pwent_free() to free it after use.
128****************************************************************/
129
130struct sys_pwent * getpwent_list(void)
131{
132 struct sys_pwent *plist;
133 struct sys_pwent *pent;
134 struct passwd *pwd;
135
136 pent = malloc_p(struct sys_pwent);
137 if (pent == NULL) {
138 DEBUG (0, ("Out of memory in getpwent_list!\n"));
139 return NULL;
140 }
141 plist = pent;
142
143 setpwent();
144 pwd = getpwent();
145 while (pwd != NULL) {
146 memset(pent, '\0', sizeof(struct sys_pwent));
147 if (pwd->pw_name) {
148 if ((pent->pw_name = strdup(pwd->pw_name)) == NULL)
149 goto err;
150 }
151 if (pwd->pw_passwd) {
152 if ((pent->pw_passwd = strdup(pwd->pw_passwd)) == NULL)
153 goto err;
154 }
155 pent->pw_uid = pwd->pw_uid;
156 pent->pw_gid = pwd->pw_gid;
157 if (pwd->pw_gecos) {
158 if ((pent->pw_name = strdup(pwd->pw_gecos)) == NULL)
159 goto err;
160 }
161 if (pwd->pw_dir) {
162 if ((pent->pw_name = strdup(pwd->pw_dir)) == NULL)
163 goto err;
164 }
165 if (pwd->pw_shell) {
166 if ((pent->pw_name = strdup(pwd->pw_shell)) == NULL)
167 goto err;
168 }
169
170 pwd = getpwent();
171 if (pwd) {
172 pent->next = malloc_p(struct sys_pwent);
173 if (pent->next == NULL)
174 goto err;
175 pent = pent->next;
176 }
177 }
178
179 endpwent();
180 return plist;
181
182 err:
183
184 endpwent();
185 DEBUG(0, ("Out of memory in getpwent_list!\n"));
186 pwent_free(plist);
187 return NULL;
188}
189
190/****************************************************************
191 Free the single linked list of passwd entries made by
192 getpwent_list()
193****************************************************************/
194
195void pwent_free (struct sys_pwent *plist)
196{
197 while (plist) {
198 struct sys_pwent *prev;
199
200 SAFE_FREE(plist->pw_name);
201 SAFE_FREE(plist->pw_passwd);
202 SAFE_FREE(plist->pw_gecos);
203 SAFE_FREE(plist->pw_dir);
204 SAFE_FREE(plist->pw_shell);
205
206 prev = plist;
207 plist = plist->next;
208 SAFE_FREE(prev);
209 }
210}
211
212/****************************************************************
213 Add the individual group users onto the list.
214****************************************************************/
215
216static struct sys_userlist *add_members_to_userlist(struct sys_userlist *list_head, const struct group *grp)
217{
218 size_t num_users, i;
219
220 /* Count the number of users. */
221 for (num_users = 0; grp->gr_mem[num_users]; num_users++)
222 ;
223
224 for (i = 0; i < num_users; i++) {
225 struct sys_userlist *entry = malloc_p(struct sys_userlist);
226 if (entry == NULL) {
227 free_userlist(list_head);
228 return NULL;
229 }
230 entry->unix_name = (char *)strdup(grp->gr_mem[i]);
231 if (entry->unix_name == NULL) {
232 SAFE_FREE(entry);
233 free_userlist(list_head);
234 return NULL;
235 }
236 DLIST_ADD(list_head, entry);
237 }
238 return list_head;
239}
240
241/****************************************************************
242 Get the list of UNIX users in a group.
243 We have to enumerate the /etc/group file as some UNIX getgrnam()
244 calls won't do that for us (notably Tru64 UNIX).
245****************************************************************/
246
247struct sys_userlist *get_users_in_group(const char *gname)
248{
249 struct sys_userlist *list_head = NULL;
250 struct group *gptr;
251
252#if !defined(BROKEN_GETGRNAM)
253 if ((gptr = (struct group *)getgrnam(gname)) == NULL)
254 return NULL;
255 return add_members_to_userlist(list_head, gptr);
256#else
257 /* BROKEN_GETGRNAM - True64 */
258 setgrent();
259 while((gptr = getgrent()) != NULL) {
260 if (strequal(gname, gptr->gr_name)) {
261 list_head = add_members_to_userlist(list_head, gptr);
262 if (list_head == NULL)
263 return NULL;
264 }
265 }
266 endgrent();
267 return list_head;
268#endif
269}
270
271/****************************************************************
272 Free list allocated above.
273****************************************************************/
274
275void free_userlist(struct sys_userlist *list_head)
276{
277 while (list_head) {
278 struct sys_userlist *old_head = list_head;
279 DLIST_REMOVE(list_head, list_head);
280 SAFE_FREE(old_head->unix_name);
281 SAFE_FREE(old_head);
282 }
283}
Note: See TracBrowser for help on using the repository browser.