Debian Codegraph @

tests/nss_nwrap.c

raw
1 #include "config.h"
2
3 #include <errno.h>
4 #include <fcntl.h>
5 #include <stddef.h>
6 #include <stdint.h>
7 #include <string.h>
8 #include <pwd.h>
9 #include <grp.h>
10 #include <stdlib.h>
11
12 #include "../src/nss_utils.h"
13
14 #if defined(HAVE_NSS_H)
15 /* Linux and BSD */
16 #include <nss.h>
17
18 typedef enum nss_status NSS_STATUS;
19 #elif defined(HAVE_NSS_COMMON_H)
20 /* Solaris */
21 #include <nss_common.h>
22 #include <nss_dbdefs.h>
23 #include <nsswitch.h>
24
25 typedef nss_status_t NSS_STATUS;
26
27 # define NSS_STATUS_SUCCESS NSS_SUCCESS
28 # define NSS_STATUS_NOTFOUND NSS_NOTFOUND
29 # define NSS_STATUS_UNAVAIL NSS_UNAVAIL
30 # define NSS_STATUS_TRYAGAIN NSS_TRYAGAIN
31 #else
32 # error "No nsswitch support detected"
33 #endif
34
35 #ifndef discard_const
36 #define discard_const(ptr) ((void *)((uintptr_t)(ptr)))
37 #endif
38
39 #ifndef discard_const_p
40 #define discard_const_p(type, ptr) ((type *)discard_const(ptr))
41 #endif
42
43 NSS_STATUS _nss_nwrap_setpwent(void);
44 NSS_STATUS _nss_nwrap_endpwent(void);
45 NSS_STATUS _nss_nwrap_getpwent_r(struct passwd *result, char *buffer,
46 size_t buflen, int *errnop);
47 NSS_STATUS _nss_nwrap_getpwuid_r(uid_t uid, struct passwd *result,
48 char *buffer, size_t buflen, int *errnop);
49 NSS_STATUS _nss_nwrap_getpwnam_r(const char *name, struct passwd *result,
50 char *buffer, size_t buflen, int *errnop);
51 NSS_STATUS _nss_nwrap_setgrent(void);
52 NSS_STATUS _nss_nwrap_endgrent(void);
53 NSS_STATUS _nss_nwrap_getgrent_r(struct group *result,
54 char *buffer,
55 size_t buflen,
56 struct group **grdstp);
57 NSS_STATUS _nss_nwrap_getgrnam_r(const char *name,
58 struct group *result,
59 char *buffer,
60 size_t buflen,
61 struct group **grdstp);
62 NSS_STATUS _nss_nwrap_getgrgid_r(gid_t gid,
63 struct group *result,
64 char *buffer,
65 size_t buflen,
66 struct group **grdstp);
67 NSS_STATUS _nss_nwrap_initgroups_dyn(char *user, gid_t group, long int *start,
68 long int *size, gid_t **groups,
69 long int limit, int *errnop);
70
71 #ifndef PTR_DIFF
72 #define PTR_DIFF(p1, p2) ((ptrdiff_t)(((const char *)(p1)) - (const char *)(p2)))
73 #endif
74
75 static int pw_copy_r(const struct passwd *src,
76 struct passwd *dst,
77 char *buf,
78 size_t buflen,
79 struct passwd **dstp)
80 {
81 char *first;
82 char *last;
83 off_t ofs;
84
85 first = src->pw_name;
86
87 last = src->pw_shell;
88 while (*last) last++;
89
90 ofs = PTR_DIFF(last + 1, first);
91
92 if (ofs > (off_t) buflen) {
93 return ERANGE;
94 }
95
96 memcpy(buf, first, ofs);
97
98 ofs = PTR_DIFF(src->pw_name, first);
99 dst->pw_name = buf + ofs;
100 ofs = PTR_DIFF(src->pw_passwd, first);
101 dst->pw_passwd = buf + ofs;
102 dst->pw_uid = src->pw_uid;
103 dst->pw_gid = src->pw_gid;
104 #ifdef HAVE_STRUCT_PASSWD_PW_CLASS
105 ofs = PTR_DIFF(src->pw_class, first);
106 dst->pw_class = buf + ofs;
107 #endif /* HAVE_STRUCT_PASSWD_PW_CLASS */
108
109 #ifdef HAVE_STRUCT_PASSWD_PW_CHANGE
110 dst->pw_change = 0;
111 #endif /* HAVE_STRUCT_PASSWD_PW_CHANGE */
112
113 #ifdef HAVE_STRUCT_PASSWD_PW_EXPIRE
114 dst->pw_expire = 0;
115 #endif /* HAVE_STRUCT_PASSWD_PW_EXPIRE */
116
117 ofs = PTR_DIFF(src->pw_gecos, first);
118 dst->pw_gecos = buf + ofs;
119 ofs = PTR_DIFF(src->pw_dir, first);
120 dst->pw_dir = buf + ofs;
121 ofs = PTR_DIFF(src->pw_shell, first);
122 dst->pw_shell = buf + ofs;
123
124 if (dstp) {
125 *dstp = dst;
126 }
127
128 return 0;
129 }
130
131 NSS_STATUS _nss_nwrap_setpwent(void)
132 {
133 return NSS_STATUS_UNAVAIL;
134 }
135
136 NSS_STATUS _nss_nwrap_endpwent(void)
137 {
138 return NSS_STATUS_UNAVAIL;
139 }
140
141 NSS_STATUS _nss_nwrap_getpwent_r(struct passwd *result, char *buffer,
142 size_t buflen, int *errnop)
143 {
144 (void) result;
145 (void) buffer;
146 (void) buflen;
147 (void) errnop;
148
149 return NSS_STATUS_UNAVAIL;
150 }
151
152 NSS_STATUS _nss_nwrap_getpwuid_r(uid_t uid, struct passwd *result,
153 char *buffer, size_t buflen, int *errnop)
154 {
155 (void)errnop; /* unused */
156 if (uid == 424242) {
157 char buf[] = "hanswurst\0secret\0\0/home/hanswurst\0/bin/false";
158 const struct passwd src = {
159 .pw_name = &buf[0],
160 .pw_passwd = &buf[10],
161 .pw_uid = 424242,
162 .pw_gid = 424242,
163 .pw_gecos = &buf[17],
164 .pw_dir = &buf[18],
165 .pw_shell = &buf[34],
166 };
167 memset(buffer, '\0', buflen);
168 pw_copy_r(&src, result, buffer, buflen, NULL);
169 errnop = 0;
170
171 return NSS_STATUS_SUCCESS;
172 }
173
174 return NSS_STATUS_UNAVAIL;
175 }
176
177 NSS_STATUS _nss_nwrap_getpwnam_r(const char *name, struct passwd *result,
178 char *buffer, size_t buflen, int *errnop)
179 {
180 (void) name;
181 (void) result;
182 (void) buffer;
183 (void) buflen;
184 (void) errnop;
185
186 return NSS_STATUS_UNAVAIL;
187 }
188 static int grent_idx = 0;
189
190 NSS_STATUS _nss_nwrap_setgrent(void)
191 {
192 grent_idx = 0;
193 return NSS_STATUS_SUCCESS;
194 }
195
196 NSS_STATUS _nss_nwrap_endgrent(void)
197 {
198 grent_idx = 0;
199 return NSS_STATUS_SUCCESS;
200 }
201
202 static const struct group gr0 = {
203 .gr_name = discard_const_p(char, "wb_group_0"),
204 .gr_passwd = discard_const_p(char, "x"),
205 .gr_gid = 100010,
206 .gr_mem = (char *[]) {
207 discard_const_p(char, "alice"),
208 discard_const_p(char, "bob"),
209 NULL
210 },
211 };
212 static const struct group gr1 = {
213 .gr_name = discard_const_p(char, "wb_group_1"),
214 .gr_passwd = discard_const_p(char, "x"),
215 .gr_gid = 100011,
216 .gr_mem = (char *[]) {
217 discard_const_p(char, "alice"),
218 discard_const_p(char, "bob"),
219 NULL
220 },
221 };
222 static const struct group gr2 = {
223 .gr_name = discard_const_p(char, "wb_group_2"),
224 .gr_passwd = discard_const_p(char, "x"),
225 .gr_gid = 100012,
226 .gr_mem = (char *[]) {
227 discard_const_p(char, "alice"),
228 NULL
229 },
230 };
231
232 NSS_STATUS _nss_nwrap_getgrent_r(struct group *result,
233 char *buffer,
234 size_t buflen,
235 struct group **grdstp)
236 {
237 switch (grent_idx) {
238 int ret;
239 case 0:
240 ret = nwrap_gr_copy_r(&gr0, result, buffer, buflen, grdstp);
241 grent_idx++;
242 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
243 case 1:
244 ret = nwrap_gr_copy_r(&gr1, result, buffer, buflen, grdstp);
245 grent_idx++;
246 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
247 case 2:
248 ret = nwrap_gr_copy_r(&gr2, result, buffer, buflen, grdstp);
249 grent_idx++;
250 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
251 default:
252 return NSS_STATUS_NOTFOUND;
253 }
254 }
255
256 NSS_STATUS _nss_nwrap_getgrnam_r(const char *name,
257 struct group *result,
258 char *buffer,
259 size_t buflen,
260 struct group **grdstp)
261 {
262 int ret;
263
264 if (strcmp(name, "wb_group_0") == 0) {
265 ret = nwrap_gr_copy_r(&gr0, result, buffer, buflen, grdstp);
266 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
267 } else if (strcmp(name, "wb_group_1") == 0) {
268 ret = nwrap_gr_copy_r(&gr1, result, buffer, buflen, grdstp);
269 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
270 } else if (strcmp(name, "wb_group_2") == 0) {
271 ret = nwrap_gr_copy_r(&gr2, result, buffer, buflen, grdstp);
272 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
273 } else {
274 return NSS_STATUS_NOTFOUND;
275 }
276 }
277
278 NSS_STATUS _nss_nwrap_getgrgid_r(gid_t gid,
279 struct group *result,
280 char *buffer,
281 size_t buflen,
282 struct group **grdstp)
283 {
284 int ret;
285 switch (gid) {
286 case 100010:
287 ret = nwrap_gr_copy_r(&gr0, result, buffer, buflen, grdstp);
288 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
289 case 100011:
290 ret = nwrap_gr_copy_r(&gr1, result, buffer, buflen, grdstp);
291 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
292 case 100012:
293 ret = nwrap_gr_copy_r(&gr2, result, buffer, buflen, grdstp);
294 return ret == 0 ? NSS_STATUS_SUCCESS : NSS_STATUS_TRYAGAIN;
295 default:
296 return NSS_STATUS_NOTFOUND;
297 }
298 }
299
300 NSS_STATUS _nss_nwrap_initgroups_dyn(char *user, gid_t group, long int *start,
301 long int *size, gid_t **groups,
302 long int limit, int *errnop)
303 {
304 (void) user;
305 (void)group;
306 (void) limit;
307 (void) errnop;
308
309 if (!(strcmp(user, "alice") == 0 || strcmp(user, "bob") == 0)) {
310 return NSS_STATUS_SUCCESS;
311 }
312
313 if (*start + 4 >= *size) {
314 long int newsize;
315 gid_t *newgroups;
316
317 newsize = *size + 4;
318 if (limit > 0) {
319 if (newsize > limit) {
320 return NSS_STATUS_NOTFOUND;
321 }
322 }
323
324 newgroups =
325 (gid_t *)realloc((*groups), newsize * sizeof(**groups));
326 if (!newgroups) {
327 *errnop = ENOMEM;
328 return NSS_STATUS_NOTFOUND;
329 }
330 *groups = newgroups;
331 *size = newsize;
332 }
333
334 (*groups)[(*start)++] = 100010;
335 (*groups)[(*start)++] = 100011;
336 if (strcmp(user, "alice") == 0) {
337 (*groups)[(*start)++] = 100012;
338 }
339 return NSS_STATUS_SUCCESS;
340 }
341