source: branches/samba-3.5.x/source3/lib/netapi/tests/netgroup.c

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

Samba 3.5.0: Initial import
File size: 10.3 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 * NetGroup testsuite
4 * Copyright (C) Guenther Deschner 2008
5 *
6 * This program is free software; you can redistribute it and/or modify
7 * it under the terms of the GNU General Public License as published by
8 * the Free Software Foundation; either version 3 of the License, or
9 * (at your option) any later version.
10 *
11 * This program is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 * GNU General Public License for more details.
15 *
16 * You should have received a copy of the GNU General Public License
17 * along with this program; if not, see <http://www.gnu.org/licenses/>.
18 */
19
20#include <sys/types.h>
21#include <inttypes.h>
22#include <stdio.h>
23#include <stdlib.h>
24#include <string.h>
25
26#include <netapi.h>
27
28#include "common.h"
29
30static NET_API_STATUS test_netgroupenum(const char *hostname,
31 uint32_t level,
32 const char *groupname)
33{
34 NET_API_STATUS status;
35 uint32_t entries_read = 0;
36 uint32_t total_entries = 0;
37 uint32_t resume_handle = 0;
38 int found_group = 0;
39 const char *current_name = NULL;
40 uint8_t *buffer = NULL;
41 int i;
42
43 struct GROUP_INFO_0 *info0 = NULL;
44 struct GROUP_INFO_1 *info1 = NULL;
45 struct GROUP_INFO_2 *info2 = NULL;
46 struct GROUP_INFO_3 *info3 = NULL;
47
48 printf("testing NetGroupEnum level %d\n", level);
49
50 do {
51 status = NetGroupEnum(hostname,
52 level,
53 &buffer,
54 120, //(uint32_t)-1,
55 &entries_read,
56 &total_entries,
57 &resume_handle);
58 if (status == 0 || status == ERROR_MORE_DATA) {
59 switch (level) {
60 case 0:
61 info0 = (struct GROUP_INFO_0 *)buffer;
62 break;
63 case 1:
64 info1 = (struct GROUP_INFO_1 *)buffer;
65 break;
66 case 2:
67 info2 = (struct GROUP_INFO_2 *)buffer;
68 break;
69 case 3:
70 info3 = (struct GROUP_INFO_3 *)buffer;
71 break;
72 default:
73 return -1;
74 }
75
76 for (i=0; i<entries_read; i++) {
77
78 switch (level) {
79 case 0:
80 current_name = info0->grpi0_name;
81 break;
82 case 1:
83 current_name = info1->grpi1_name;
84 break;
85 case 2:
86 current_name = info2->grpi2_name;
87 break;
88 case 3:
89 current_name = info3->grpi3_name;
90 break;
91 default:
92 break;
93 }
94
95 if (strcasecmp(current_name, groupname) == 0) {
96 found_group = 1;
97 }
98
99 switch (level) {
100 case 0:
101 info0++;
102 break;
103 case 1:
104 info1++;
105 break;
106 case 2:
107 info2++;
108 break;
109 case 3:
110 info3++;
111 break;
112 }
113 }
114 NetApiBufferFree(buffer);
115 }
116 } while (status == ERROR_MORE_DATA);
117
118 if (status) {
119 return status;
120 }
121
122 if (!found_group) {
123 printf("failed to get group\n");
124 return -1;
125 }
126
127 return 0;
128}
129
130static NET_API_STATUS test_netgroupgetusers(const char *hostname,
131 uint32_t level,
132 const char *groupname,
133 const char *username)
134{
135 NET_API_STATUS status;
136 uint32_t entries_read = 0;
137 uint32_t total_entries = 0;
138 uint32_t resume_handle = 0;
139 int found_user = 0;
140 const char *current_name = NULL;
141 uint8_t *buffer = NULL;
142 int i;
143
144 struct GROUP_USERS_INFO_0 *info0 = NULL;
145 struct GROUP_USERS_INFO_1 *info1 = NULL;
146
147 printf("testing NetGroupGetUsers level %d\n", level);
148
149 do {
150 status = NetGroupGetUsers(hostname,
151 groupname,
152 level,
153 &buffer,
154 (uint32_t)-1,
155 &entries_read,
156 &total_entries,
157 &resume_handle);
158 if (status == 0 || status == ERROR_MORE_DATA) {
159
160 switch (level) {
161 case 0:
162 info0 = (struct GROUP_USERS_INFO_0 *)buffer;
163 break;
164 case 1:
165 info1 = (struct GROUP_USERS_INFO_1 *)buffer;
166 break;
167 default:
168 break;
169 }
170 for (i=0; i<entries_read; i++) {
171 switch (level) {
172 case 0:
173 current_name = info0->grui0_name;
174 break;
175 case 1:
176 current_name = info1->grui1_name;
177 break;
178 default:
179 break;
180 }
181
182 if (username && strcasecmp(current_name, username) == 0) {
183 found_user = 1;
184 }
185
186 switch (level) {
187 case 0:
188 info0++;
189 break;
190 case 1:
191 info1++;
192 break;
193 }
194 }
195 NetApiBufferFree(buffer);
196 }
197 } while (status == ERROR_MORE_DATA);
198
199 if (status) {
200 return status;
201 }
202
203 if (username && !found_user) {
204 printf("failed to get user\n");
205 return -1;
206 }
207
208 return 0;
209}
210
211static NET_API_STATUS test_netgroupsetusers(const char *hostname,
212 const char *groupname,
213 uint32_t level,
214 size_t num_entries,
215 const char **names)
216{
217 NET_API_STATUS status;
218 uint8_t *buffer = NULL;
219 int i = 0;
220 size_t buf_size = 0;
221
222 struct GROUP_USERS_INFO_0 *g0 = NULL;
223 struct GROUP_USERS_INFO_1 *g1 = NULL;
224
225 printf("testing NetGroupSetUsers level %d\n", level);
226
227 switch (level) {
228 case 0:
229 buf_size = sizeof(struct GROUP_USERS_INFO_0) * num_entries;
230
231 status = NetApiBufferAllocate(buf_size, (void **)&g0);
232 if (status) {
233 goto out;
234 }
235
236 for (i=0; i<num_entries; i++) {
237 g0[i].grui0_name = names[i];
238 }
239
240 buffer = (uint8_t *)g0;
241 break;
242 case 1:
243 buf_size = sizeof(struct GROUP_USERS_INFO_1) * num_entries;
244
245 status = NetApiBufferAllocate(buf_size, (void **)&g1);
246 if (status) {
247 goto out;
248 }
249
250 for (i=0; i<num_entries; i++) {
251 g1[i].grui1_name = names[i];
252 }
253
254 buffer = (uint8_t *)g1;
255 break;
256 default:
257 break;
258 }
259
260 /* NetGroupSetUsers */
261
262 status = NetGroupSetUsers(hostname,
263 groupname,
264 level,
265 buffer,
266 num_entries);
267 if (status) {
268 goto out;
269 }
270
271 out:
272 NetApiBufferFree(buffer);
273 return status;
274}
275
276NET_API_STATUS netapitest_group(struct libnetapi_ctx *ctx,
277 const char *hostname)
278{
279 NET_API_STATUS status = 0;
280 const char *username, *groupname, *groupname2;
281 uint8_t *buffer = NULL;
282 struct GROUP_INFO_0 g0;
283 uint32_t parm_err = 0;
284 uint32_t levels[] = { 0, 1, 2, 3};
285 uint32_t enum_levels[] = { 0, 1, 2, 3};
286 uint32_t getmem_levels[] = { 0, 1};
287 int i;
288
289 printf("NetGroup tests\n");
290
291 username = "torture_test_user";
292 groupname = "torture_test_group";
293 groupname2 = "torture_test_group2";
294
295 /* cleanup */
296 NetGroupDel(hostname, groupname);
297 NetGroupDel(hostname, groupname2);
298 NetUserDel(hostname, username);
299
300 /* add a group */
301
302 g0.grpi0_name = groupname;
303
304 printf("testing NetGroupAdd\n");
305
306 status = NetGroupAdd(hostname, 0, (uint8_t *)&g0, &parm_err);
307 if (status) {
308 NETAPI_STATUS(ctx, status, "NetGroupAdd");
309 goto out;
310 }
311
312 /* 2nd add must fail */
313
314 status = NetGroupAdd(hostname, 0, (uint8_t *)&g0, &parm_err);
315 if (status == 0) {
316 NETAPI_STATUS(ctx, status, "NetGroupAdd");
317 goto out;
318 }
319
320 /* test enum */
321
322 for (i=0; i<ARRAY_SIZE(enum_levels); i++) {
323
324 status = test_netgroupenum(hostname, enum_levels[i], groupname);
325 if (status) {
326 NETAPI_STATUS(ctx, status, "NetGroupEnum");
327 goto out;
328 }
329 }
330
331 /* basic queries */
332
333 for (i=0; i<ARRAY_SIZE(levels); i++) {
334
335 printf("testing NetGroupGetInfo level %d\n", levels[i]);
336
337 status = NetGroupGetInfo(hostname, groupname, levels[i], &buffer);
338 if (status && status != 124) {
339 NETAPI_STATUS(ctx, status, "NetGroupGetInfo");
340 goto out;
341 }
342 }
343
344 /* group rename */
345
346 g0.grpi0_name = groupname2;
347
348 printf("testing NetGroupSetInfo level 0\n");
349
350 status = NetGroupSetInfo(hostname, groupname, 0, (uint8_t *)&g0, &parm_err);
351 switch (status) {
352 case 0:
353 break;
354 case 50: /* not supported */
355 case 124: /* not implemented */
356 groupname2 = groupname;
357 goto skip_rename;
358 default:
359 NETAPI_STATUS(ctx, status, "NetGroupSetInfo");
360 goto out;
361 }
362
363 /* should not exist anymore */
364
365 status = NetGroupDel(hostname, groupname);
366 if (status == 0) {
367 NETAPI_STATUS(ctx, status, "NetGroupDel");
368 goto out;
369 }
370
371 skip_rename:
372 /* query info */
373
374 for (i=0; i<ARRAY_SIZE(levels); i++) {
375
376 status = NetGroupGetInfo(hostname, groupname2, levels[i], &buffer);
377 if (status && status != 124) {
378 NETAPI_STATUS(ctx, status, "NetGroupGetInfo");
379 goto out;
380 }
381 }
382
383 /* add user to group */
384
385 status = test_netuseradd(hostname, username);
386 if (status) {
387 NETAPI_STATUS(ctx, status, "NetUserAdd");
388 goto out;
389 }
390
391 /* should not be member */
392
393 for (i=0; i<ARRAY_SIZE(getmem_levels); i++) {
394
395 status = test_netgroupgetusers(hostname, getmem_levels[i], groupname2, NULL);
396 if (status) {
397 NETAPI_STATUS(ctx, status, "NetGroupGetUsers");
398 goto out;
399 }
400 }
401
402 printf("testing NetGroupAddUser\n");
403
404 status = NetGroupAddUser(hostname, groupname2, username);
405 if (status) {
406 NETAPI_STATUS(ctx, status, "NetGroupAddUser");
407 goto out;
408 }
409
410 /* should be member */
411
412 for (i=0; i<ARRAY_SIZE(getmem_levels); i++) {
413
414 status = test_netgroupgetusers(hostname, getmem_levels[i], groupname2, username);
415 if (status) {
416 NETAPI_STATUS(ctx, status, "NetGroupGetUsers");
417 goto out;
418 }
419 }
420
421 printf("testing NetGroupDelUser\n");
422
423 status = NetGroupDelUser(hostname, groupname2, username);
424 if (status) {
425 NETAPI_STATUS(ctx, status, "NetGroupDelUser");
426 goto out;
427 }
428
429 /* should not be member */
430
431 status = test_netgroupgetusers(hostname, 0, groupname2, NULL);
432 if (status) {
433 NETAPI_STATUS(ctx, status, "NetGroupGetUsers");
434 goto out;
435 }
436
437 /* set it again via exlicit member set */
438
439 status = test_netgroupsetusers(hostname, groupname2, 0, 1, &username);
440 if (status) {
441 NETAPI_STATUS(ctx, status, "NetGroupSetUsers");
442 goto out;
443 }
444
445 /* should be member */
446
447 status = test_netgroupgetusers(hostname, 0, groupname2, username);
448 if (status) {
449 NETAPI_STATUS(ctx, status, "NetGroupGetUsers");
450 goto out;
451 }
452#if 0
453 /* wipe out member list */
454
455 status = test_netgroupsetusers(hostname, groupname2, 0, 0, NULL);
456 if (status) {
457 NETAPI_STATUS(ctx, status, "NetGroupSetUsers");
458 goto out;
459 }
460
461 /* should not be member */
462
463 status = test_netgroupgetusers(hostname, 0, groupname2, NULL);
464 if (status) {
465 NETAPI_STATUS(ctx, status, "NetGroupGetUsers");
466 goto out;
467 }
468#endif
469 status = NetUserDel(hostname, username);
470 if (status) {
471 NETAPI_STATUS(ctx, status, "NetUserDel");
472 goto out;
473 }
474
475 /* delete */
476
477 printf("testing NetGroupDel\n");
478
479 status = NetGroupDel(hostname, groupname2);
480 if (status) {
481 NETAPI_STATUS(ctx, status, "NetGroupDel");
482 goto out;
483 };
484
485 /* should not exist anymore */
486
487 status = NetGroupGetInfo(hostname, groupname2, 0, &buffer);
488 if (status == 0) {
489 NETAPI_STATUS_MSG(ctx, status, "NetGroupGetInfo", "expected failure and error code");
490 goto out;
491 };
492
493 status = 0;
494
495 printf("NetGroup tests succeeded\n");
496 out:
497 if (status != 0) {
498 printf("NetGroup testsuite failed with: %s\n",
499 libnetapi_get_error_string(ctx, status));
500 }
501
502 return status;
503}
Note: See TracBrowser for help on using the repository browser.