![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to tsgetgrpw.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / plugins / sudoers|
Return to tsgetgrpw.c CVS log | Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / sudo / plugins / sudoers |
1.1 misho 1: /*
2: * Copyright (c) 2005, 2008, 2010-2011 Todd C. Miller <Todd.Miller@courtesan.com>
3: *
4: * Permission to use, copy, modify, and distribute this software for any
5: * purpose with or without fee is hereby granted, provided that the above
6: * copyright notice and this permission notice appear in all copies.
7: *
8: * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9: * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10: * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11: * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12: * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13: * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14: * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15: */
16:
17: /*
18: * Trivial replacements for the libc get{gr,pw}{uid,nam}() routines
19: * for use by testsudoers in the sudo test harness.
20: * We need our own since many platforms don't provide set{pw,gr}file().
21: */
22:
23: #include <config.h>
24:
25: #include <sys/types.h>
26: #include <sys/param.h>
27: #include <stdio.h>
28: #ifdef STDC_HEADERS
29: # include <stdlib.h>
30: # include <stddef.h>
31: #else
32: # ifdef HAVE_STDLIB_H
33: # include <stdlib.h>
34: # endif
35: #endif /* STDC_HEADERS */
36: #ifdef HAVE_STRING_H
37: # if defined(HAVE_MEMORY_H) && !defined(STDC_HEADERS)
38: # include <memory.h>
39: # endif
40: # include <string.h>
41: #endif /* HAVE_STRING_H */
42: #ifdef HAVE_STRINGS_H
43: # include <strings.h>
44: #endif /* HAVE_STRINGS_H */
45: #include <fcntl.h>
46: #include <limits.h>
47:
48: #include "tsgetgrpw.h"
49: #include "sudoers.h"
50:
51: #ifndef LINE_MAX
52: # define LINE_MAX 2048
53: #endif
54:
55: #undef GRMEM_MAX
56: #define GRMEM_MAX 200
57:
58: static FILE *pwf;
59: static const char *pwfile = "/etc/passwd";
60: static int pw_stayopen;
61:
62: static FILE *grf;
63: static const char *grfile = "/etc/group";
64: static int gr_stayopen;
65:
66: void setgrfile(const char *);
67: void setgrent(void);
68: void endgrent(void);
69: struct group *getgrent(void);
70: struct group *getgrnam(const char *);
71: struct group *getgrgid(gid_t);
72:
73: void setpwfile(const char *);
74: void setpwent(void);
75: void endpwent(void);
76: struct passwd *getpwent(void);
77: struct passwd *getpwnam(const char *);
78: struct passwd *getpwuid(uid_t);
79:
80: void
81: setpwfile(const char *file)
82: {
83: pwfile = file;
84: if (pwf != NULL)
85: endpwent();
86: }
87:
88: void
89: setpwent(void)
90: {
91: if (pwf == NULL) {
92: pwf = fopen(pwfile, "r");
93: if (pwf != NULL)
94: fcntl(fileno(pwf), F_SETFD, FD_CLOEXEC);
95: } else {
96: rewind(pwf);
97: }
98: pw_stayopen = 1;
99: }
100:
101: void
102: endpwent(void)
103: {
104: if (pwf != NULL) {
105: fclose(pwf);
106: pwf = NULL;
107: }
108: pw_stayopen = 0;
109: }
110:
111: struct passwd *
112: getpwent(void)
113: {
114: static struct passwd pw;
115: static char pwbuf[LINE_MAX];
116: size_t len;
117: char *cp, *colon;
118:
119: if ((colon = fgets(pwbuf, sizeof(pwbuf), pwf)) == NULL)
120: return NULL;
121:
122: zero_bytes(&pw, sizeof(pw));
123: if ((colon = strchr(cp = colon, ':')) == NULL)
124: return NULL;
125: *colon++ = '\0';
126: pw.pw_name = cp;
127: if ((colon = strchr(cp = colon, ':')) == NULL)
128: return NULL;
129: *colon++ = '\0';
130: pw.pw_passwd = cp;
131: if ((colon = strchr(cp = colon, ':')) == NULL)
132: return NULL;
133: *colon++ = '\0';
134: pw.pw_uid = atoi(cp);
135: if ((colon = strchr(cp = colon, ':')) == NULL)
136: return NULL;
137: *colon++ = '\0';
138: pw.pw_gid = atoi(cp);
139: if ((colon = strchr(cp = colon, ':')) == NULL)
140: return NULL;
141: *colon++ = '\0';
142: pw.pw_gecos = cp;
143: if ((colon = strchr(cp = colon, ':')) == NULL)
144: return NULL;
145: *colon++ = '\0';
146: pw.pw_dir = cp;
147: pw.pw_shell = colon;
148: len = strlen(colon);
149: if (len > 0 && colon[len - 1] == '\n')
150: colon[len - 1] = '\0';
151: return &pw;
152: }
153:
154: struct passwd *
155: getpwnam(const char *name)
156: {
157: struct passwd *pw;
158:
159: if (pwf == NULL) {
160: if ((pwf = fopen(pwfile, "r")) == NULL)
161: return NULL;
162: fcntl(fileno(pwf), F_SETFD, FD_CLOEXEC);
163: } else {
164: rewind(pwf);
165: }
166: while ((pw = getpwent()) != NULL) {
167: if (strcmp(pw->pw_name, name) == 0)
168: break;
169: }
170: if (!pw_stayopen) {
171: fclose(pwf);
172: pwf = NULL;
173: }
174: return pw;
175: }
176:
177: struct passwd *
178: getpwuid(uid_t uid)
179: {
180: struct passwd *pw;
181:
182: if (pwf == NULL) {
183: if ((pwf = fopen(pwfile, "r")) == NULL)
184: return NULL;
185: fcntl(fileno(pwf), F_SETFD, FD_CLOEXEC);
186: } else {
187: rewind(pwf);
188: }
189: while ((pw = getpwent()) != NULL) {
190: if (pw->pw_uid == uid)
191: break;
192: }
193: if (!pw_stayopen) {
194: fclose(pwf);
195: pwf = NULL;
196: }
197: return pw;
198: }
199:
200: void
201: setgrfile(const char *file)
202: {
203: grfile = file;
204: if (grf != NULL)
205: endgrent();
206: }
207:
208: void
209: setgrent(void)
210: {
211: if (grf == NULL) {
212: grf = fopen(grfile, "r");
213: if (grf != NULL)
214: fcntl(fileno(grf), F_SETFD, FD_CLOEXEC);
215: } else {
216: rewind(grf);
217: }
218: gr_stayopen = 1;
219: }
220:
221: void
222: endgrent(void)
223: {
224: if (grf != NULL) {
225: fclose(grf);
226: grf = NULL;
227: }
228: gr_stayopen = 0;
229: }
230:
231: struct group *
232: getgrent(void)
233: {
234: static struct group gr;
235: static char grbuf[LINE_MAX], *gr_mem[GRMEM_MAX+1];
236: size_t len;
237: char *cp, *colon;
238: int n;
239:
240: if ((colon = fgets(grbuf, sizeof(grbuf), grf)) == NULL)
241: return NULL;
242:
243: zero_bytes(&gr, sizeof(gr));
244: if ((colon = strchr(cp = colon, ':')) == NULL)
245: return NULL;
246: *colon++ = '\0';
247: gr.gr_name = cp;
248: if ((colon = strchr(cp = colon, ':')) == NULL)
249: return NULL;
250: *colon++ = '\0';
251: gr.gr_passwd = cp;
252: if ((colon = strchr(cp = colon, ':')) == NULL)
253: return NULL;
254: *colon++ = '\0';
255: gr.gr_gid = atoi(cp);
256: len = strlen(colon);
257: if (len > 0 && colon[len - 1] == '\n')
258: colon[len - 1] = '\0';
259: if (*colon != '\0') {
260: gr.gr_mem = gr_mem;
261: cp = strtok(colon, ",");
262: for (n = 0; cp != NULL && n < GRMEM_MAX; n++) {
263: gr.gr_mem[n] = cp;
264: cp = strtok(NULL, ",");
265: }
266: gr.gr_mem[n++] = NULL;
267: } else
268: gr.gr_mem = NULL;
269: return &gr;
270: }
271:
272: struct group *
273: getgrnam(const char *name)
274: {
275: struct group *gr;
276:
277: if (grf == NULL) {
278: if ((grf = fopen(grfile, "r")) == NULL)
279: return NULL;
280: fcntl(fileno(grf), F_SETFD, FD_CLOEXEC);
281: } else {
282: rewind(grf);
283: }
284: while ((gr = getgrent()) != NULL) {
285: if (strcmp(gr->gr_name, name) == 0)
286: break;
287: }
288: if (!gr_stayopen) {
289: fclose(grf);
290: grf = NULL;
291: }
292: return gr;
293: }
294:
295: struct group *
296: getgrgid(gid_t gid)
297: {
298: struct group *gr;
299:
300: if (grf == NULL) {
301: if ((grf = fopen(grfile, "r")) == NULL)
302: return NULL;
303: fcntl(fileno(grf), F_SETFD, FD_CLOEXEC);
304: } else {
305: rewind(grf);
306: }
307: while ((gr = getgrent()) != NULL) {
308: if (gr->gr_gid == gid)
309: break;
310: }
311: if (!gr_stayopen) {
312: fclose(grf);
313: grf = NULL;
314: }
315: return gr;
316: }