2 Unix SMB/CIFS implementation.
3 SMB torture tester - winbind struct based protocol
4 Copyright (C) Stefan Metzmacher 2007
5 Copyright (C) Michael Adam 2007
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.
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.
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/>.
23 #include "torture/torture.h"
24 #include "torture/winbind/proto.h"
25 #include "nsswitch/winbind_client.h"
26 #include "libcli/security/security.h"
27 #include "librpc/gen_ndr/netlogon.h"
28 #include "param/param.h"
29 #include "auth/pam_errors.h"
31 #define DO_STRUCT_REQ_REP_EXT(op,req,rep,expected,strict,warnaction,cmt) do { \
32 NSS_STATUS __got, __expected = (expected); \
33 __got = winbindd_request_response(op, req, rep); \
34 if (__got != __expected) { \
35 const char *__cmt = (cmt); \
37 torture_result(torture, TORTURE_FAIL, \
38 __location__ ": " __STRING(op) \
39 " returned %d, expected %d%s%s", \
41 (__cmt) ? ": " : "", \
42 (__cmt) ? (__cmt) : ""); \
45 torture_warning(torture, \
46 __location__ ": " __STRING(op) \
47 " returned %d, expected %d%s%s", \
49 (__cmt) ? ": " : "", \
50 (__cmt) ? (__cmt) : ""); \
56 #define DO_STRUCT_REQ_REP(op,req,rep) do { \
57 bool __noop = false; \
58 DO_STRUCT_REQ_REP_EXT(op,req,rep,NSS_STATUS_SUCCESS,true,__noop=true,NULL); \
61 static bool torture_winbind_struct_interface_version(struct torture_context *torture)
63 struct winbindd_request req;
64 struct winbindd_response rep;
69 torture_comment(torture, "Running WINBINDD_INTERFACE_VERSION (struct based)\n");
71 DO_STRUCT_REQ_REP(WINBINDD_INTERFACE_VERSION, &req, &rep);
73 torture_assert_int_equal(torture,
74 rep.data.interface_version,
75 WINBIND_INTERFACE_VERSION,
76 "winbind server and client doesn't match");
81 static bool torture_winbind_struct_ping(struct torture_context *torture)
83 struct timeval tv = timeval_current();
84 int timelimit = torture_setting_int(torture, "timelimit", 5);
87 torture_comment(torture,
88 "Running WINBINDD_PING (struct based) for %d seconds\n",
91 while (timeval_elapsed(&tv) < timelimit) {
92 DO_STRUCT_REQ_REP(WINBINDD_PING, NULL, NULL);
96 torture_comment(torture,
97 "%u (%.1f/s) WINBINDD_PING (struct based)\n",
98 total, total / timeval_elapsed(&tv));
104 static char winbind_separator(struct torture_context *torture)
106 struct winbindd_response rep;
110 DO_STRUCT_REQ_REP(WINBINDD_INFO, NULL, &rep);
112 return rep.data.info.winbind_separator;
115 static bool torture_winbind_struct_info(struct torture_context *torture)
117 struct winbindd_response rep;
118 const char *separator;
122 torture_comment(torture, "Running WINBINDD_INFO (struct based)\n");
124 DO_STRUCT_REQ_REP(WINBINDD_INFO, NULL, &rep);
126 separator = torture_setting_string(torture,
127 "winbindd separator",
128 lp_winbind_separator(torture->lp_ctx));
129 torture_assert_int_equal(torture,
130 rep.data.info.winbind_separator,
132 "winbind separator doesn't match");
134 torture_comment(torture, "Samba Version '%s'\n",
135 rep.data.info.samba_version);
140 static bool torture_winbind_struct_priv_pipe_dir(struct torture_context *torture)
142 struct winbindd_response rep;
143 const char *default_dir;
144 const char *expected_dir;
149 torture_comment(torture, "Running WINBINDD_PRIV_PIPE_DIR (struct based)\n");
151 DO_STRUCT_REQ_REP(WINBINDD_PRIV_PIPE_DIR, NULL, &rep);
153 got_dir = (const char *)rep.extra_data.data;
155 torture_assert(torture, got_dir, "NULL WINBINDD_PRIV_PIPE_DIR\n");
157 default_dir = lock_path(torture, torture->lp_ctx,
158 WINBINDD_PRIV_SOCKET_SUBDIR);
159 expected_dir = torture_setting_string(torture,
160 "winbindd private pipe dir",
163 torture_assert_str_equal(torture, got_dir, expected_dir,
164 "WINBINDD_PRIV_PIPE_DIR doesn't match");
166 SAFE_FREE(rep.extra_data.data);
170 static bool torture_winbind_struct_netbios_name(struct torture_context *torture)
172 struct winbindd_response rep;
173 const char *expected;
177 torture_comment(torture, "Running WINBINDD_NETBIOS_NAME (struct based)\n");
179 DO_STRUCT_REQ_REP(WINBINDD_NETBIOS_NAME, NULL, &rep);
181 expected = torture_setting_string(torture,
182 "winbindd netbios name",
183 lp_netbios_name(torture->lp_ctx));
184 expected = strupper_talloc(torture, expected);
186 torture_assert_str_equal(torture,
187 rep.data.netbios_name, expected,
188 "winbindd's netbios name doesn't match");
193 static bool get_winbind_domain(struct torture_context *torture, char **domain)
195 struct winbindd_response rep;
199 DO_STRUCT_REQ_REP(WINBINDD_DOMAIN_NAME, NULL, &rep);
201 *domain = talloc_strdup(torture, rep.data.domain_name);
202 torture_assert(torture, domain, "talloc error");
207 static bool torture_winbind_struct_domain_name(struct torture_context *torture)
209 const char *expected;
212 torture_comment(torture, "Running WINBINDD_DOMAIN_NAME (struct based)\n");
214 expected = torture_setting_string(torture,
215 "winbindd netbios domain",
216 lp_workgroup(torture->lp_ctx));
218 get_winbind_domain(torture, &domain);
220 torture_assert_str_equal(torture, domain, expected,
221 "winbindd's netbios domain doesn't match");
226 static bool torture_winbind_struct_check_machacc(struct torture_context *torture)
229 bool strict = torture_setting_bool(torture, "strict mode", false);
230 struct winbindd_response rep;
234 torture_comment(torture, "Running WINBINDD_CHECK_MACHACC (struct based)\n");
237 DO_STRUCT_REQ_REP_EXT(WINBINDD_CHECK_MACHACC, NULL, &rep,
238 NSS_STATUS_SUCCESS, strict, ok = false,
239 "WINBINDD_CHECK_MACHACC");
242 torture_assert(torture,
243 strlen(rep.data.auth.nt_status_string)>0,
244 "Failed with empty nt_status_string");
246 torture_warning(torture,"%s:%s:%s:%d\n",
247 nt_errstr(NT_STATUS(rep.data.auth.nt_status)),
248 rep.data.auth.nt_status_string,
249 rep.data.auth.error_string,
250 rep.data.auth.pam_error);
254 torture_assert_ntstatus_ok(torture,
255 NT_STATUS(rep.data.auth.nt_status),
256 "WINBINDD_CHECK_MACHACC ok: nt_status");
258 torture_assert_str_equal(torture,
259 rep.data.auth.nt_status_string,
260 nt_errstr(NT_STATUS_OK),
261 "WINBINDD_CHECK_MACHACC ok:nt_status_string");
263 torture_assert_str_equal(torture,
264 rep.data.auth.error_string,
265 get_friendly_nt_error_msg(NT_STATUS_OK),
266 "WINBINDD_CHECK_MACHACC ok: error_string");
268 torture_assert_int_equal(torture,
269 rep.data.auth.pam_error,
270 nt_status_to_pam(NT_STATUS_OK),
271 "WINBINDD_CHECK_MACHACC ok: pam_error");
276 struct torture_trust_domain {
277 const char *netbios_name;
278 const char *dns_name;
282 static bool get_trusted_domains(struct torture_context *torture,
283 struct torture_trust_domain **_d)
285 struct winbindd_request req;
286 struct winbindd_response rep;
287 struct torture_trust_domain *d = NULL;
290 const char *extra_data;
295 DO_STRUCT_REQ_REP(WINBINDD_LIST_TRUSTDOM, &req, &rep);
297 extra_data = (char *)rep.extra_data.data;
298 torture_assert(torture, extra_data, "NULL trust list");
300 while (next_token(&extra_data, line, "\n", sizeof(fstring))) {
303 d = talloc_realloc(torture, d,
304 struct torture_trust_domain,
306 ZERO_STRUCT(d[dcount+1]);
309 p = strchr(lp, '\\');
310 torture_assert(torture, p, "missing 1st '\\' in line");
312 d[dcount].netbios_name = talloc_strdup(d, lp);
313 torture_assert(torture, strlen(d[dcount].netbios_name) > 0,
314 "empty netbios_name");
317 p = strchr(lp, '\\');
318 torture_assert(torture, p, "missing 2nd '\\' in line");
320 d[dcount].dns_name = talloc_strdup(d, lp);
321 /* it's ok to have an empty dns_name */
324 d[dcount].sid = dom_sid_parse_talloc(d, lp);
325 torture_assert(torture, d[dcount].sid,
326 "failed to parse sid");
330 SAFE_FREE(rep.extra_data.data);
332 torture_assert(torture, dcount >= 2,
333 "The list of trusted domain should contain 2 entries");
339 static bool torture_winbind_struct_list_trustdom(struct torture_context *torture)
341 struct winbindd_request req;
342 struct winbindd_response rep;
346 struct torture_trust_domain *listd = NULL;
349 torture_comment(torture, "Running WINBINDD_LIST_TRUSTDOM (struct based)\n");
354 req.data.list_all_domains = false;
356 DO_STRUCT_REQ_REP(WINBINDD_LIST_TRUSTDOM, &req, &rep);
358 list1 = (char *)rep.extra_data.data;
359 torture_assert(torture, list1, "NULL trust list");
361 torture_comment(torture, "%s\n", list1);
366 req.data.list_all_domains = true;
368 DO_STRUCT_REQ_REP(WINBINDD_LIST_TRUSTDOM, &req, &rep);
370 list2 = (char *)rep.extra_data.data;
371 torture_assert(torture, list2, "NULL trust list");
374 * The list_all_domains parameter should be ignored
376 torture_assert_str_equal(torture, list2, list1, "list_all_domains not ignored");
381 ok = get_trusted_domains(torture, &listd);
382 torture_assert(torture, ok, "failed to get trust list");
384 for (i=0; listd[i].netbios_name; i++) {
386 struct dom_sid *builtin_sid;
388 builtin_sid = dom_sid_parse_talloc(torture, SID_BUILTIN);
390 torture_assert_str_equal(torture,
391 listd[i].netbios_name,
393 "first domain should be 'BUILTIN'");
395 torture_assert_str_equal(torture,
398 "BUILTIN domain should not have a dns name");
400 ok = dom_sid_equal(builtin_sid,
402 torture_assert(torture, ok, "BUILTIN domain should have S-1-5-32");
408 * TODO: verify the content of the 2nd and 3rd (in member server mode)
416 static bool torture_winbind_struct_domain_info(struct torture_context *torture)
419 struct torture_trust_domain *listd = NULL;
422 torture_comment(torture, "Running WINBINDD_DOMAIN_INFO (struct based)\n");
424 ok = get_trusted_domains(torture, &listd);
425 torture_assert(torture, ok, "failed to get trust list");
427 for (i=0; listd[i].netbios_name; i++) {
428 struct winbindd_request req;
429 struct winbindd_response rep;
431 char *flagstr = talloc_strdup(torture," ");
436 fstrcpy(req.domain_name, listd[i].netbios_name);
438 DO_STRUCT_REQ_REP(WINBINDD_DOMAIN_INFO, &req, &rep);
440 torture_assert_str_equal(torture,
441 rep.data.domain_info.name,
442 listd[i].netbios_name,
443 "Netbios domain name doesn't match");
445 torture_assert_str_equal(torture,
446 rep.data.domain_info.alt_name,
448 "DNS domain name doesn't match");
450 sid = dom_sid_parse_talloc(torture, rep.data.domain_info.sid);
451 torture_assert(torture, sid, "Failed to parse SID");
453 ok = dom_sid_equal(listd[i].sid, sid);
454 torture_assert(torture, ok, "SID's doesn't match");
456 if (rep.data.domain_info.primary) {
457 flagstr = talloc_strdup_append(flagstr, "PR ");
460 if (rep.data.domain_info.active_directory) {
461 torture_assert(torture,
462 strlen(rep.data.domain_info.alt_name)>0,
463 "Active Directory without DNS name");
464 flagstr = talloc_strdup_append(flagstr, "AD ");
467 if (rep.data.domain_info.native_mode) {
468 torture_assert(torture,
469 rep.data.domain_info.active_directory,
470 "Native-Mode, but no Active Directory");
471 flagstr = talloc_strdup_append(flagstr, "NA ");
474 torture_comment(torture, "DOMAIN '%s' => '%s' [%s]\n",
475 rep.data.domain_info.name,
476 rep.data.domain_info.alt_name,
483 static bool torture_winbind_struct_getdcname(struct torture_context *torture)
486 bool strict = torture_setting_bool(torture, "strict mode", false);
487 struct torture_trust_domain *listd = NULL;
490 torture_comment(torture, "Running WINBINDD_GETDCNAME (struct based)\n");
492 ok = get_trusted_domains(torture, &listd);
493 torture_assert(torture, ok, "failed to get trust list");
495 for (i=0; listd[i].netbios_name; i++) {
496 struct winbindd_request req;
497 struct winbindd_response rep;
502 fstrcpy(req.domain_name, listd[i].netbios_name);
505 DO_STRUCT_REQ_REP_EXT(WINBINDD_GETDCNAME, &req, &rep,
507 (i <2 || strict), ok = false,
508 talloc_asprintf(torture, "DOMAIN '%s'",
512 /* TODO: check rep.data.dc_name; */
513 torture_comment(torture, "DOMAIN '%s' => DCNAME '%s'\n",
514 req.domain_name, rep.data.dc_name);
520 static bool torture_winbind_struct_dsgetdcname(struct torture_context *torture)
523 bool strict = torture_setting_bool(torture, "strict mode", false);
524 struct torture_trust_domain *listd = NULL;
528 torture_comment(torture, "Running WINBINDD_DSGETDCNAME (struct based)\n");
530 ok = get_trusted_domains(torture, &listd);
531 torture_assert(torture, ok, "failed to get trust list");
533 for (i=0; listd[i].netbios_name; i++) {
534 struct winbindd_request req;
535 struct winbindd_response rep;
540 if (strlen(listd[i].dns_name) == 0) continue;
543 * TODO: remove this and let winbindd give no dns name
546 if (strcmp(listd[i].dns_name, listd[i].netbios_name) == 0) {
550 fstrcpy(req.domain_name, listd[i].dns_name);
552 /* TODO: test more flag combinations */
553 req.flags = DS_DIRECTORY_SERVICE_REQUIRED;
556 DO_STRUCT_REQ_REP_EXT(WINBINDD_DSGETDCNAME, &req, &rep,
559 talloc_asprintf(torture, "DOMAIN '%s'",
563 /* TODO: check rep.data.dc_name; */
564 torture_comment(torture, "DOMAIN '%s' => DCNAME '%s'\n",
565 req.domain_name, rep.data.dc_name);
571 torture_warning(torture, "WINBINDD_DSGETDCNAME"
572 " was not tested with %d non-AD domains",
577 torture_assert(torture, count > 0,
578 "WiNBINDD_DSGETDCNAME was not tested");
584 static bool get_user_list(struct torture_context *torture, char ***users)
586 struct winbindd_request req;
587 struct winbindd_response rep;
591 const char *extra_data;
596 DO_STRUCT_REQ_REP(WINBINDD_LIST_USERS, &req, &rep);
598 extra_data = (char *)rep.extra_data.data;
599 torture_assert(torture, extra_data, "NULL extra data");
602 next_token(&extra_data, name, ",", sizeof(fstring));
605 u = talloc_realloc(torture, u, char *, count + 2);
607 u[count] = talloc_strdup(u, name);
610 SAFE_FREE(rep.extra_data.data);
616 static bool torture_winbind_struct_list_users(struct torture_context *torture)
622 torture_comment(torture, "Running WINBINDD_LIST_USERS (struct based)\n");
624 ok = get_user_list(torture, &users);
625 torture_assert(torture, ok, "failed to get group list");
627 for (count = 0; users[count]; count++) { }
629 torture_comment(torture, "got %d users\n", count);
634 static bool get_group_list(struct torture_context *torture, char ***groups)
636 struct winbindd_request req;
637 struct winbindd_response rep;
641 const char *extra_data;
646 DO_STRUCT_REQ_REP(WINBINDD_LIST_GROUPS, &req, &rep);
648 extra_data = (char *)rep.extra_data.data;
649 torture_assert(torture, extra_data, "NULL extra data");
652 next_token(&extra_data, name, ",", sizeof(fstring));
655 g = talloc_realloc(torture, g, char *, count + 2);
657 g[count] = talloc_strdup(g, name);
660 SAFE_FREE(rep.extra_data.data);
666 static bool torture_winbind_struct_list_groups(struct torture_context *torture)
672 torture_comment(torture, "Running WINBINDD_LIST_GROUPS (struct based)\n");
674 ok = get_group_list(torture, &groups);
675 torture_assert(torture, ok, "failed to get group list");
677 for (count = 0; groups[count]; count++) { }
679 torture_comment(torture, "got %d groups\n", count);
684 struct torture_domain_sequence {
685 const char *netbios_name;
689 static bool get_sequence_numbers(struct torture_context *torture,
690 struct torture_domain_sequence **seqs)
692 struct winbindd_request req;
693 struct winbindd_response rep;
694 const char *extra_data;
697 struct torture_domain_sequence *s = NULL;
702 DO_STRUCT_REQ_REP(WINBINDD_SHOW_SEQUENCE, &req, &rep);
704 extra_data = (char *)rep.extra_data.data;
705 torture_assert(torture, extra_data, "NULL sequence list");
707 while (next_token(&extra_data, line, "\n", sizeof(fstring))) {
711 s = talloc_realloc(torture, s, struct torture_domain_sequence,
713 ZERO_STRUCT(s[count+1]);
717 torture_assert(torture, p, "invalid line format");
719 s[count].netbios_name = talloc_strdup(s, lp);
722 torture_assert(torture, strncmp(lp, ": ", 2) == 0,
723 "invalid line format");
725 if (strcmp(lp, "DISCONNECTED") == 0) {
728 seq = (uint32_t)strtol(lp, &p, 10);
729 torture_assert(torture, (*p == '\0'),
730 "invalid line format");
731 torture_assert(torture, (seq != (uint32_t)-1),
732 "sequence number -1 encountered");
738 SAFE_FREE(rep.extra_data.data);
740 torture_assert(torture, count >= 2, "The list of domain sequence "
741 "numbers should contain 2 entries");
747 static bool torture_winbind_struct_show_sequence(struct torture_context *torture)
751 struct torture_trust_domain *domlist = NULL;
752 struct torture_domain_sequence *s = NULL;
754 torture_comment(torture, "Running WINBINDD_SHOW_SEQUENCE (struct based)\n");
756 ok = get_sequence_numbers(torture, &s);
757 torture_assert(torture, ok, "failed to get list of sequence numbers");
759 ok = get_trusted_domains(torture, &domlist);
760 torture_assert(torture, ok, "failed to get trust list");
762 for (i=0; domlist[i].netbios_name; i++) {
763 struct winbindd_request req;
764 struct winbindd_response rep;
767 torture_assert(torture, s[i].netbios_name,
768 "more domains recieved in second run");
769 torture_assert_str_equal(torture, domlist[i].netbios_name,
771 "inconsistent order of domain lists");
775 fstrcpy(req.domain_name, domlist[i].netbios_name);
777 DO_STRUCT_REQ_REP(WINBINDD_SHOW_SEQUENCE, &req, &rep);
779 seq = rep.data.sequence_number;
782 torture_assert(torture, (seq != (uint32_t)-1),
783 "BUILTIN domain disconnected");
785 torture_assert(torture, (seq != (uint32_t)-1),
786 "local domain disconnected");
790 if (seq == (uint32_t)-1) {
791 torture_comment(torture, " * %s : DISCONNECTED\n",
794 torture_comment(torture, " * %s : %d\n",
795 req.domain_name, seq);
797 torture_assert(torture, (seq >= s[i].seq),
798 "illegal sequence number encountered");
804 static bool torture_winbind_struct_setpwent(struct torture_context *torture)
806 struct winbindd_request req;
807 struct winbindd_response rep;
809 torture_comment(torture, "Running WINBINDD_SETPWENT (struct based)\n");
814 DO_STRUCT_REQ_REP(WINBINDD_SETPWENT, &req, &rep);
819 static bool torture_winbind_struct_getpwent(struct torture_context *torture)
821 struct winbindd_request req;
822 struct winbindd_response rep;
823 struct winbindd_pw *pwent;
825 torture_comment(torture, "Running WINBINDD_GETPWENT (struct based)\n");
827 torture_comment(torture, " - Running WINBINDD_SETPWENT first\n");
830 DO_STRUCT_REQ_REP(WINBINDD_SETPWENT, &req, &rep);
832 torture_comment(torture, " - Running WINBINDD_GETPWENT now\n");
835 req.data.num_entries = 1;
836 DO_STRUCT_REQ_REP(WINBINDD_GETPWENT, &req, &rep);
837 pwent = (struct winbindd_pw *)rep.extra_data.data;
838 torture_assert(torture, (pwent != NULL), "NULL pwent");
839 torture_comment(torture, "name: %s, uid: %d, gid: %d, shell: %s\n",
840 pwent->pw_name, pwent->pw_uid, pwent->pw_gid,
846 static bool torture_winbind_struct_endpwent(struct torture_context *torture)
848 struct winbindd_request req;
849 struct winbindd_response rep;
851 torture_comment(torture, "Running WINBINDD_ENDPWENT (struct based)\n");
856 DO_STRUCT_REQ_REP(WINBINDD_ENDPWENT, &req, &rep);
861 /* Copy of parse_domain_user from winbindd_util.c. Parse a string of the
862 form DOMAIN/user into a domain and a user */
864 static bool parse_domain_user(struct torture_context *torture,
865 const char *domuser, fstring domain,
868 char *p = strchr(domuser, winbind_separator(torture));
872 /* Maybe it was a UPN? */
873 if ((p = strchr(domuser, '@')) != NULL) {
875 fstrcpy(user, domuser);
879 fstrcpy(user, domuser);
880 get_winbind_domain(torture, &dom);
881 fstrcpy(domain, dom);
886 fstrcpy(domain, domuser);
887 domain[PTR_DIFF(p, domuser)] = 0;
893 static bool lookup_name_sid_list(struct torture_context *torture, char **list)
897 for (count = 0; list[count]; count++) {
898 struct winbindd_request req;
899 struct winbindd_response rep;
906 parse_domain_user(torture, list[count], req.data.name.dom_name,
909 DO_STRUCT_REQ_REP(WINBINDD_LOOKUPNAME, &req, &rep);
911 sid = talloc_strdup(torture, rep.data.sid.sid);
916 fstrcpy(req.data.sid, sid);
918 DO_STRUCT_REQ_REP(WINBINDD_LOOKUPSID, &req, &rep);
920 name = talloc_asprintf(torture, "%s%c%s",
921 rep.data.name.dom_name,
922 winbind_separator(torture),
925 torture_assert_casestr_equal(torture, list[count], name,
926 "LOOKUP_SID after LOOKUP_NAME != id");
929 torture_comment(torture, " %s -> %s -> %s\n", list[count],
940 static bool name_is_in_list(const char *name, const char **list)
944 for (count = 0; list[count]; count++) {
945 if (strequal(name, list[count])) {
952 static bool torture_winbind_struct_lookup_name_sid(struct torture_context *torture)
954 struct winbindd_request req;
955 struct winbindd_response rep;
956 const char *invalid_sid = "S-0-0-7";
958 const char *invalid_user = "noone";
960 bool strict = torture_setting_bool(torture, "strict mode", false);
966 torture_comment(torture, "Running WINBINDD_LOOKUP_NAME_SID (struct based)\n");
968 ok = get_user_list(torture, &users);
969 torture_assert(torture, ok, "failed to retrieve list of users");
970 lookup_name_sid_list(torture, users);
972 ok = get_group_list(torture, &groups);
973 torture_assert(torture, ok, "failed to retrieve list of groups");
974 lookup_name_sid_list(torture, groups);
979 fstrcpy(req.data.sid, invalid_sid);
982 DO_STRUCT_REQ_REP_EXT(WINBINDD_LOOKUPSID, &req, &rep,
986 talloc_asprintf(torture,
987 "invalid sid %s was resolved",
993 /* try to find an invalid name... */
996 get_winbind_domain(torture, &domain);
999 invalid_name = talloc_asprintf(torture, "%s\\%s%u",
1001 invalid_user, count);
1002 } while(name_is_in_list(invalid_name, (const char **)users) ||
1003 name_is_in_list(invalid_name, (const char **)groups));
1005 fstrcpy(req.data.name.dom_name, domain);
1006 fstrcpy(req.data.name.name,
1007 talloc_asprintf(torture, "%s%u", invalid_user,
1011 DO_STRUCT_REQ_REP_EXT(WINBINDD_LOOKUPNAME, &req, &rep,
1012 NSS_STATUS_NOTFOUND,
1015 talloc_asprintf(torture,
1016 "invalid name %s was resolved",
1020 talloc_free(groups);
1025 struct torture_suite *torture_winbind_struct_init(void)
1027 struct torture_suite *suite = torture_suite_create(talloc_autofree_context(), "STRUCT");
1029 torture_suite_add_simple_test(suite, "INTERFACE_VERSION", torture_winbind_struct_interface_version);
1030 torture_suite_add_simple_test(suite, "PING", torture_winbind_struct_ping);
1031 torture_suite_add_simple_test(suite, "INFO", torture_winbind_struct_info);
1032 torture_suite_add_simple_test(suite, "PRIV_PIPE_DIR", torture_winbind_struct_priv_pipe_dir);
1033 torture_suite_add_simple_test(suite, "NETBIOS_NAME", torture_winbind_struct_netbios_name);
1034 torture_suite_add_simple_test(suite, "DOMAIN_NAME", torture_winbind_struct_domain_name);
1035 torture_suite_add_simple_test(suite, "CHECK_MACHACC", torture_winbind_struct_check_machacc);
1036 torture_suite_add_simple_test(suite, "LIST_TRUSTDOM", torture_winbind_struct_list_trustdom);
1037 torture_suite_add_simple_test(suite, "DOMAIN_INFO", torture_winbind_struct_domain_info);
1038 torture_suite_add_simple_test(suite, "GETDCNAME", torture_winbind_struct_getdcname);
1039 torture_suite_add_simple_test(suite, "DSGETDCNAME", torture_winbind_struct_dsgetdcname);
1040 torture_suite_add_simple_test(suite, "LIST_USERS", torture_winbind_struct_list_users);
1041 torture_suite_add_simple_test(suite, "LIST_GROUPS", torture_winbind_struct_list_groups);
1042 torture_suite_add_simple_test(suite, "SHOW_SEQUENCE", torture_winbind_struct_show_sequence);
1043 torture_suite_add_simple_test(suite, "SETPWENT", torture_winbind_struct_setpwent);
1044 torture_suite_add_simple_test(suite, "GETPWENT", torture_winbind_struct_getpwent);
1045 torture_suite_add_simple_test(suite, "ENDPWENT", torture_winbind_struct_endpwent);
1046 torture_suite_add_simple_test(suite, "LOOKUP_NAME_SID", torture_winbind_struct_lookup_name_sid);
1048 suite->description = talloc_strdup(suite, "WINBIND - struct based protocol tests");