- add 'print' to the DCERPC binding strings
[samba.git] / source4 / torture / rpc / netlogon.c
1 /* 
2    Unix SMB/CIFS implementation.
3
4    test suite for netlogon rpc operations
5
6    Copyright (C) Andrew Tridgell 2003
7    
8    This program is free software; you can redistribute it and/or modify
9    it under the terms of the GNU General Public License as published by
10    the Free Software Foundation; either version 2 of the License, or
11    (at your option) any later version.
12    
13    This program is distributed in the hope that it will be useful,
14    but WITHOUT ANY WARRANTY; without even the implied warranty of
15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16    GNU General Public License for more details.
17    
18    You should have received a copy of the GNU General Public License
19    along with this program; if not, write to the Free Software
20    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
21 */
22
23 #include "includes.h"
24
25
26 static BOOL test_LogonUasLogon(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
27 {
28         NTSTATUS status;
29         struct netr_LogonUasLogon r;
30
31         r.in.server_name = NULL;
32         r.in.username = lp_parm_string(-1, "torture", "username");
33         r.in.workstation = lp_netbios_name();
34
35         printf("Testing LogonUasLogon\n");
36
37         status = dcerpc_netr_LogonUasLogon(p, mem_ctx, &r);
38         if (!NT_STATUS_IS_OK(status)) {
39                 printf("LogonUasLogon - %s\n", nt_errstr(status));
40                 return False;
41         }
42
43         return True;
44         
45 }
46
47 static BOOL test_LogonUasLogoff(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
48 {
49         NTSTATUS status;
50         struct netr_LogonUasLogoff r;
51
52         r.in.server_name = NULL;
53         r.in.username = lp_parm_string(-1, "torture", "username");
54         r.in.workstation = lp_netbios_name();
55
56         printf("Testing LogonUasLogoff\n");
57
58         status = dcerpc_netr_LogonUasLogoff(p, mem_ctx, &r);
59         if (!NT_STATUS_IS_OK(status)) {
60                 printf("LogonUasLogoff - %s\n", nt_errstr(status));
61                 return False;
62         }
63
64         return True;
65         
66 }
67
68 static BOOL test_SetupCredentials(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
69                                   struct netr_CredentialState *creds)
70 {
71         NTSTATUS status;
72         struct netr_ServerReqChallenge r;
73         struct netr_ServerAuthenticate a;
74         const char *plain_pass;
75         uint8 mach_pwd[16];
76
77         printf("Testing ServerReqChallenge\n");
78
79         r.in.server_name = NULL;
80         r.in.computer_name = lp_netbios_name();
81         generate_random_buffer(r.in.credentials.data, sizeof(r.in.credentials.data), False);
82
83         status = dcerpc_netr_ServerReqChallenge(p, mem_ctx, &r);
84         if (!NT_STATUS_IS_OK(status)) {
85                 printf("ServerReqChallenge - %s\n", nt_errstr(status));
86                 return False;
87         }
88
89         plain_pass = secrets_fetch_machine_password();
90         if (!plain_pass) {
91                 printf("Unable to fetch machine password!\n");
92                 return False;
93         }
94
95         E_md4hash(plain_pass, mach_pwd);
96
97         creds_client_init(creds, &r.in.credentials, &r.out.credentials, mach_pwd,
98                           &a.in.credentials);
99
100         a.in.server_name = NULL;
101         a.in.username = talloc_asprintf(mem_ctx, "%s$", lp_netbios_name());
102         a.in.secure_channel_type = SEC_CHAN_BDC;
103         a.in.computer_name = lp_netbios_name();
104
105         printf("Testing ServerAuthenticate\n");
106
107         status = dcerpc_netr_ServerAuthenticate(p, mem_ctx, &a);
108         if (!NT_STATUS_IS_OK(status)) {
109                 printf("ServerAuthenticate - %s\n", nt_errstr(status));
110                 return False;
111         }
112
113         if (!creds_client_check(creds, &a.out.credentials)) {
114                 printf("Credential chaining failed\n");
115                 return False;
116         }
117
118         return True;
119 }
120
121 static BOOL test_SetupCredentials2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
122                                    struct netr_CredentialState *creds)
123 {
124         NTSTATUS status;
125         struct netr_ServerReqChallenge r;
126         struct netr_ServerAuthenticate2 a;
127         const char *plain_pass;
128         uint8 mach_pwd[16];
129         uint32 negotiate_flags = 0;
130
131         printf("Testing ServerReqChallenge\n");
132
133         r.in.server_name = NULL;
134         r.in.computer_name = lp_netbios_name();
135         generate_random_buffer(r.in.credentials.data, sizeof(r.in.credentials.data), False);
136
137         status = dcerpc_netr_ServerReqChallenge(p, mem_ctx, &r);
138         if (!NT_STATUS_IS_OK(status)) {
139                 printf("ServerReqChallenge - %s\n", nt_errstr(status));
140                 return False;
141         }
142
143         plain_pass = secrets_fetch_machine_password();
144         if (!plain_pass) {
145                 printf("Unable to fetch machine password!\n");
146                 return False;
147         }
148
149         E_md4hash(plain_pass, mach_pwd);
150
151         creds_client_init(creds, &r.in.credentials, &r.out.credentials, mach_pwd,
152                           &a.in.credentials);
153
154         a.in.server_name = NULL;
155         a.in.username = talloc_asprintf(mem_ctx, "%s$", lp_netbios_name());
156         a.in.secure_channel_type = SEC_CHAN_BDC;
157         a.in.computer_name = lp_netbios_name();
158         a.in.negotiate_flags = &negotiate_flags;
159         a.out.negotiate_flags = &negotiate_flags;
160
161         printf("Testing ServerAuthenticate2\n");
162
163         status = dcerpc_netr_ServerAuthenticate2(p, mem_ctx, &a);
164         if (!NT_STATUS_IS_OK(status)) {
165                 printf("ServerAuthenticate2 - %s\n", nt_errstr(status));
166                 return False;
167         }
168
169         if (!creds_client_check(creds, &a.out.credentials)) {
170                 printf("Credential chaining failed\n");
171                 return False;
172         }
173
174         printf("negotiate_flags=0x%08x\n", negotiate_flags);
175
176         return True;
177 }
178
179 /*
180   try a netlogon SamLogon
181 */
182 static BOOL test_SamLogon(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
183 {
184         NTSTATUS status;
185         struct netr_LogonSamLogon r;
186         struct netr_Authenticator auth, auth2;
187         struct netr_NetworkInfo ninfo;
188         const char *username = lp_parm_string(-1, "torture", "username");
189         const char *password = lp_parm_string(-1, "torture", "password");
190         struct netr_CredentialState creds;
191
192         if (!test_SetupCredentials2(p, mem_ctx, &creds)) {
193                 return False;
194         }
195
196         ninfo.logon_info.domain_name.string = lp_workgroup();
197         ninfo.logon_info.parameter_control = 0;
198         ninfo.logon_info.logon_id_low = 0;
199         ninfo.logon_info.logon_id_high = 0;
200         ninfo.logon_info.username.string = username;
201         ninfo.logon_info.workstation.string = lp_netbios_name();
202         generate_random_buffer(ninfo.challenge, 
203                                sizeof(ninfo.challenge), False);
204         ninfo.nt.length = 24;
205         ninfo.nt.data = talloc(mem_ctx, 24);
206         SMBNTencrypt(password, ninfo.challenge, ninfo.nt.data);
207         ninfo.lm.length = 24;
208         ninfo.lm.data = talloc(mem_ctx, 24);
209         SMBencrypt(password, ninfo.challenge, ninfo.lm.data);
210
211         ZERO_STRUCT(auth2);
212
213         creds_client_authenticator(&creds, &auth);
214
215         r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
216         r.in.workstation = lp_netbios_name();
217         r.in.credential = &auth;
218         r.in.authenticator = &auth2;
219         r.in.logon_level = 2;
220         r.in.logon.network = &ninfo;
221         r.in.validation_level = 2;
222
223         printf("Testing SamLogon\n");
224
225         status = dcerpc_netr_LogonSamLogon(p, mem_ctx, &r);
226         if (!NT_STATUS_IS_OK(status)) {
227                 printf("LogonSamLogon - %s\n", nt_errstr(status));
228                 return False;
229         }
230
231         if (!creds_client_check(&creds, &r.out.authenticator->cred)) {
232                 printf("Credential chaining failed\n");
233         }
234
235         return True;
236 }
237
238
239 /*
240   try a change password for our machine account
241 */
242 static BOOL test_SetPassword(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
243 {
244         NTSTATUS status;
245         struct netr_ServerPasswordSet r;
246         const char *password;
247         struct netr_CredentialState creds;
248
249         if (!test_SetupCredentials(p, mem_ctx, &creds)) {
250                 return False;
251         }
252
253         r.in.server_name = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
254         r.in.username = talloc_asprintf(mem_ctx, "%s$", lp_netbios_name());
255         r.in.secure_channel_type = SEC_CHAN_BDC;
256         r.in.computer_name = lp_netbios_name();
257
258         password = generate_random_str(8);
259         E_md4hash(password, r.in.new_password.data);
260
261         creds_client_encrypt(&creds, &r.in.new_password);
262
263         printf("Testing ServerPasswordSet on machine account\n");
264
265         creds_client_authenticator(&creds, &r.in.credential);
266
267         status = dcerpc_netr_ServerPasswordSet(p, mem_ctx, &r);
268         if (!NT_STATUS_IS_OK(status)) {
269                 printf("ServerPasswordSet - %s\n", nt_errstr(status));
270                 return False;
271         }
272
273         if (!secrets_store_machine_password(password)) {
274                 printf("Failed to save machine password\n");
275         }
276
277         if (!creds_client_check(&creds, &r.out.return_authenticator.cred)) {
278                 printf("Credential chaining failed\n");
279         }
280
281         /* by changing the machine password twice we test the credentials
282            chaining fully */
283         printf("Testing a second ServerPasswordSet on machine account\n");
284
285         creds_client_authenticator(&creds, &r.in.credential);
286
287         status = dcerpc_netr_ServerPasswordSet(p, mem_ctx, &r);
288         if (!NT_STATUS_IS_OK(status)) {
289                 printf("ServerPasswordSet - %s\n", nt_errstr(status));
290                 return False;
291         }
292
293         if (!creds_client_check(&creds, &r.out.return_authenticator.cred)) {
294                 printf("Credential chaining failed\n");
295         }
296
297         return True;
298 }
299
300
301 /* we remember the sequence numbers so we can easily do a DatabaseDelta */
302 static struct ULONG8 sequence_nums[3];
303
304 /*
305   try a netlogon DatabaseSync
306 */
307 static BOOL test_DatabaseSync(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
308 {
309         NTSTATUS status;
310         struct netr_DatabaseSync r;
311         struct netr_CredentialState creds;
312         const uint32 database_ids[] = {0, 1, 2}; 
313         int i;
314         BOOL ret = True;
315
316         if (!test_SetupCredentials(p, mem_ctx, &creds)) {
317                 return False;
318         }
319
320         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
321         r.in.computername = lp_netbios_name();
322         r.in.preferredmaximumlength = (uint32)-1;
323         ZERO_STRUCT(r.in.return_authenticator);
324
325         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
326                 r.in.sync_context = 0;
327                 r.in.database_id = database_ids[i];
328
329                 printf("Testing DatabaseSync of id %d\n", r.in.database_id);
330
331                 do {
332                         creds_client_authenticator(&creds, &r.in.credential);
333
334                         status = dcerpc_netr_DatabaseSync(p, mem_ctx, &r);
335                         if (!NT_STATUS_IS_OK(status) &&
336                             !NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
337                                 printf("DatabaseSync - %s\n", nt_errstr(status));
338                                 ret = False;
339                                 break;
340                         }
341
342                         if (!creds_client_check(&creds, &r.out.return_authenticator.cred)) {
343                                 printf("Credential chaining failed\n");
344                         }
345
346                         r.in.sync_context = r.out.sync_context;
347
348                         if (r.out.delta_enum_array &&
349                             r.out.delta_enum_array->num_deltas > 0 &&
350                             r.out.delta_enum_array->delta_enum[0].delta_type == 1 &&
351                             r.out.delta_enum_array->delta_enum[0].delta_union.domain) {
352                                 sequence_nums[r.in.database_id] = 
353                                         r.out.delta_enum_array->delta_enum[0].delta_union.domain->sequence_num;
354                                 printf("\tsequence_nums[%d]=0x%08x%08x\n",
355                                        r.in.database_id, 
356                                        sequence_nums[r.in.database_id].high,
357                                        sequence_nums[r.in.database_id].low);
358                         }
359                 } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
360         }
361
362         return ret;
363 }
364
365
366 /*
367   try a netlogon DatabaseDeltas
368 */
369 static BOOL test_DatabaseDeltas(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
370 {
371         NTSTATUS status;
372         struct netr_DatabaseDeltas r;
373         struct netr_CredentialState creds;
374         const uint32 database_ids[] = {0, 1, 2}; 
375         int i;
376         BOOL ret = True;
377
378         if (!test_SetupCredentials(p, mem_ctx, &creds)) {
379                 return False;
380         }
381
382         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
383         r.in.computername = lp_netbios_name();
384         r.in.preferredmaximumlength = (uint32)-1;
385         ZERO_STRUCT(r.in.return_authenticator);
386
387         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
388                 r.in.database_id = database_ids[i];
389                 r.in.sequence_num = sequence_nums[r.in.database_id];
390                 r.in.sequence_num.low -= 1;
391
392                 printf("Testing DatabaseDeltas of id %d at %d\n", 
393                        r.in.database_id, r.in.sequence_num.low);
394
395                 do {
396                         creds_client_authenticator(&creds, &r.in.credential);
397
398                         status = dcerpc_netr_DatabaseDeltas(p, mem_ctx, &r);
399                         if (!NT_STATUS_IS_OK(status) &&
400                             !NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
401                                 printf("DatabaseDeltas - %s\n", nt_errstr(status));
402                                 ret = False;
403                                 break;
404                         }
405
406                         if (!creds_client_check(&creds, &r.out.return_authenticator.cred)) {
407                                 printf("Credential chaining failed\n");
408                         }
409
410                         r.in.sequence_num.low++;
411                         r.in.sequence_num.high = 0;
412                 } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
413         }
414
415         return ret;
416 }
417
418
419 /*
420   try a netlogon AccountDeltas
421 */
422 static BOOL test_AccountDeltas(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
423 {
424         NTSTATUS status;
425         struct netr_AccountDeltas r;
426         struct netr_CredentialState creds;
427         BOOL ret = True;
428
429         if (!test_SetupCredentials(p, mem_ctx, &creds)) {
430                 return False;
431         }
432
433         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
434         r.in.computername = lp_netbios_name();
435         ZERO_STRUCT(r.in.return_authenticator);
436         creds_client_authenticator(&creds, &r.in.credential);
437         ZERO_STRUCT(r.in.uas);
438         r.in.count=10;
439         r.in.level=0;
440         r.in.buffersize=100;
441
442         printf("Testing AccountDeltas\n");
443
444         /* w2k3 returns "NOT IMPLEMENTED" for this call */
445         status = dcerpc_netr_AccountDeltas(p, mem_ctx, &r);
446         if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
447                 printf("AccountDeltas - %s\n", nt_errstr(status));
448                 ret = False;
449         }
450
451         return ret;
452 }
453
454 /*
455   try a netlogon AccountSync
456 */
457 static BOOL test_AccountSync(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
458 {
459         NTSTATUS status;
460         struct netr_AccountSync r;
461         struct netr_CredentialState creds;
462         BOOL ret = True;
463
464         if (!test_SetupCredentials(p, mem_ctx, &creds)) {
465                 return False;
466         }
467
468         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
469         r.in.computername = lp_netbios_name();
470         ZERO_STRUCT(r.in.return_authenticator);
471         creds_client_authenticator(&creds, &r.in.credential);
472         ZERO_STRUCT(r.in.recordid);
473         r.in.reference=0;
474         r.in.level=0;
475         r.in.buffersize=100;
476
477         printf("Testing AccountSync\n");
478
479         /* w2k3 returns "NOT IMPLEMENTED" for this call */
480         status = dcerpc_netr_AccountSync(p, mem_ctx, &r);
481         if (!NT_STATUS_EQUAL(status, NT_STATUS_NOT_IMPLEMENTED)) {
482                 printf("AccountSync - %s\n", nt_errstr(status));
483                 ret = False;
484         }
485
486         return ret;
487 }
488
489 /*
490   try a netlogon GetDcName
491 */
492 static BOOL test_GetDcName(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
493 {
494         NTSTATUS status;
495         struct netr_GetDcName r;
496
497         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
498         r.in.domainname = lp_workgroup();
499
500         printf("Testing GetDcName\n");
501
502         status = dcerpc_netr_GetDcName(p, mem_ctx, &r);
503         if (!NT_STATUS_IS_OK(status)) {
504                 printf("GetDcName - %s\n", nt_errstr(status));
505                 return False;
506         }
507
508         printf("\tDC is at '%s'\n", r.out.dcname);
509
510         return True;
511 }
512
513 /*
514   try a netlogon LogonControl 
515 */
516 static BOOL test_LogonControl(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
517 {
518         NTSTATUS status;
519         struct netr_LogonControl r;
520         BOOL ret = True;
521         int i;
522
523         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
524         r.in.function_code = 1;
525
526         for (i=1;i<4;i++) {
527                 r.in.level = i;
528
529                 printf("Testing LogonControl level %d\n", i);
530
531                 status = dcerpc_netr_LogonControl(p, mem_ctx, &r);
532                 if (!NT_STATUS_IS_OK(status)) {
533                         printf("LogonControl - %s\n", nt_errstr(status));
534                         ret = False;
535                 }
536         }
537
538         return ret;
539 }
540
541
542 /*
543   try a netlogon GetAnyDCName
544 */
545 static BOOL test_GetAnyDCName(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
546 {
547         NTSTATUS status;
548         struct netr_GetAnyDCName r;
549
550         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
551         r.in.domainname = lp_workgroup();
552
553         printf("Testing GetAnyDCName\n");
554
555         status = dcerpc_netr_GetAnyDCName(p, mem_ctx, &r);
556         if (!NT_STATUS_IS_OK(status)) {
557                 printf("GetAnyDCName - %s\n", nt_errstr(status));
558                 return False;
559         }
560
561         if (r.out.dcname) {
562                 printf("\tDC is at '%s'\n", r.out.dcname);
563         }
564
565         return True;
566 }
567
568
569 /*
570   try a netlogon LogonControl2
571 */
572 static BOOL test_LogonControl2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
573 {
574         NTSTATUS status;
575         struct netr_LogonControl2 r;
576         BOOL ret = True;
577         int i;
578
579         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
580
581         r.in.function_code = NETLOGON_CONTROL_REDISCOVER;
582         r.in.data.domain = lp_workgroup();
583
584         for (i=1;i<4;i++) {
585                 r.in.level = i;
586
587                 printf("Testing LogonControl2 level %d function %d\n", 
588                        i, r.in.function_code);
589
590                 status = dcerpc_netr_LogonControl2(p, mem_ctx, &r);
591                 if (!NT_STATUS_IS_OK(status)) {
592                         printf("LogonControl - %s\n", nt_errstr(status));
593                         ret = False;
594                 }
595         }
596
597         r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
598         r.in.data.domain = lp_workgroup();
599
600         for (i=1;i<4;i++) {
601                 r.in.level = i;
602
603                 printf("Testing LogonControl2 level %d function %d\n", 
604                        i, r.in.function_code);
605
606                 status = dcerpc_netr_LogonControl2(p, mem_ctx, &r);
607                 if (!NT_STATUS_IS_OK(status)) {
608                         printf("LogonControl - %s\n", nt_errstr(status));
609                         ret = False;
610                 }
611         }
612
613         r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
614         r.in.data.domain = lp_workgroup();
615
616         for (i=1;i<4;i++) {
617                 r.in.level = i;
618
619                 printf("Testing LogonControl2 level %d function %d\n", 
620                        i, r.in.function_code);
621
622                 status = dcerpc_netr_LogonControl2(p, mem_ctx, &r);
623                 if (!NT_STATUS_IS_OK(status)) {
624                         printf("LogonControl - %s\n", nt_errstr(status));
625                         ret = False;
626                 }
627         }
628
629         r.in.function_code = NETLOGON_CONTROL_SET_DBFLAG;
630         r.in.data.debug_level = ~0;
631
632         for (i=1;i<4;i++) {
633                 r.in.level = i;
634
635                 printf("Testing LogonControl2 level %d function %d\n", 
636                        i, r.in.function_code);
637
638                 status = dcerpc_netr_LogonControl2(p, mem_ctx, &r);
639                 if (!NT_STATUS_IS_OK(status)) {
640                         printf("LogonControl - %s\n", nt_errstr(status));
641                         ret = False;
642                 }
643         }
644
645         return ret;
646 }
647
648 /*
649   try a netlogon DatabaseSync2
650 */
651 static BOOL test_DatabaseSync2(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
652 {
653         NTSTATUS status;
654         struct netr_DatabaseSync2 r;
655         struct netr_CredentialState creds;
656         const uint32 database_ids[] = {0, 1, 2}; 
657         int i;
658         BOOL ret = True;
659
660         if (!test_SetupCredentials2(p, mem_ctx, &creds)) {
661                 return False;
662         }
663
664         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
665         r.in.computername = lp_netbios_name();
666         r.in.preferredmaximumlength = (uint32)-1;
667         ZERO_STRUCT(r.in.return_authenticator);
668
669         for (i=0;i<ARRAY_SIZE(database_ids);i++) {
670                 r.in.sync_context = 0;
671                 r.in.database_id = database_ids[i];
672                 r.in.restart_state = 0;
673
674                 printf("Testing DatabaseSync2 of id %d\n", r.in.database_id);
675
676                 do {
677                         creds_client_authenticator(&creds, &r.in.credential);
678
679                         status = dcerpc_netr_DatabaseSync2(p, mem_ctx, &r);
680                         if (!NT_STATUS_IS_OK(status) &&
681                             !NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES)) {
682                                 printf("DatabaseSync2 - %s\n", nt_errstr(status));
683                                 ret = False;
684                                 break;
685                         }
686
687                         if (!creds_client_check(&creds, &r.out.return_authenticator.cred)) {
688                                 printf("Credential chaining failed\n");
689                         }
690
691                         r.in.sync_context = r.out.sync_context;
692                 } while (NT_STATUS_EQUAL(status, STATUS_MORE_ENTRIES));
693         }
694
695         return ret;
696 }
697
698
699 /*
700   try a netlogon LogonControl2Ex
701 */
702 static BOOL test_LogonControl2Ex(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
703 {
704         NTSTATUS status;
705         struct netr_LogonControl2Ex r;
706         BOOL ret = True;
707         int i;
708
709         r.in.logon_server = talloc_asprintf(mem_ctx, "\\\\%s", dcerpc_server_name(p));
710
711         r.in.function_code = NETLOGON_CONTROL_REDISCOVER;
712         r.in.data.domain = lp_workgroup();
713
714         for (i=1;i<4;i++) {
715                 r.in.level = i;
716
717                 printf("Testing LogonControl2Ex level %d function %d\n", 
718                        i, r.in.function_code);
719
720                 status = dcerpc_netr_LogonControl2Ex(p, mem_ctx, &r);
721                 if (!NT_STATUS_IS_OK(status)) {
722                         printf("LogonControl - %s\n", nt_errstr(status));
723                         ret = False;
724                 }
725         }
726
727         r.in.function_code = NETLOGON_CONTROL_TC_QUERY;
728         r.in.data.domain = lp_workgroup();
729
730         for (i=1;i<4;i++) {
731                 r.in.level = i;
732
733                 printf("Testing LogonControl2Ex level %d function %d\n", 
734                        i, r.in.function_code);
735
736                 status = dcerpc_netr_LogonControl2Ex(p, mem_ctx, &r);
737                 if (!NT_STATUS_IS_OK(status)) {
738                         printf("LogonControl - %s\n", nt_errstr(status));
739                         ret = False;
740                 }
741         }
742
743         r.in.function_code = NETLOGON_CONTROL_TRANSPORT_NOTIFY;
744         r.in.data.domain = lp_workgroup();
745
746         for (i=1;i<4;i++) {
747                 r.in.level = i;
748
749                 printf("Testing LogonControl2Ex level %d function %d\n", 
750                        i, r.in.function_code);
751
752                 status = dcerpc_netr_LogonControl2Ex(p, mem_ctx, &r);
753                 if (!NT_STATUS_IS_OK(status)) {
754                         printf("LogonControl - %s\n", nt_errstr(status));
755                         ret = False;
756                 }
757         }
758
759         r.in.function_code = NETLOGON_CONTROL_SET_DBFLAG;
760         r.in.data.debug_level = ~0;
761
762         for (i=1;i<4;i++) {
763                 r.in.level = i;
764
765                 printf("Testing LogonControl2Ex level %d function %d\n", 
766                        i, r.in.function_code);
767
768                 status = dcerpc_netr_LogonControl2Ex(p, mem_ctx, &r);
769                 if (!NT_STATUS_IS_OK(status)) {
770                         printf("LogonControl - %s\n", nt_errstr(status));
771                         ret = False;
772                 }
773         }
774
775         return ret;
776 }
777
778
779
780 BOOL torture_rpc_netlogon(int dummy)
781 {
782         NTSTATUS status;
783         struct dcerpc_pipe *p;
784         TALLOC_CTX *mem_ctx;
785         BOOL ret = True;
786
787         mem_ctx = talloc_init("torture_rpc_netlogon");
788
789         status = torture_rpc_connection(&p, 
790                                         DCERPC_NETLOGON_NAME,
791                                         DCERPC_NETLOGON_UUID,
792                                         DCERPC_NETLOGON_VERSION);
793         if (!NT_STATUS_IS_OK(status)) {
794                 return False;
795         }
796
797         if (!test_LogonUasLogon(p, mem_ctx)) {
798                 ret = False;
799         }
800
801         if (!test_LogonUasLogoff(p, mem_ctx)) {
802                 ret = False;
803         }
804
805         if (!test_SetPassword(p, mem_ctx)) {
806                 ret = False;
807         }
808
809         if (!test_SamLogon(p, mem_ctx)) {
810                 ret = False;
811         }
812
813         if (!test_DatabaseSync(p, mem_ctx)) {
814                 ret = False;
815         }
816
817         if (!test_DatabaseDeltas(p, mem_ctx)) {
818                 ret = False;
819         }
820
821         if (!test_AccountDeltas(p, mem_ctx)) {
822                 ret = False;
823         }
824
825         if (!test_AccountSync(p, mem_ctx)) {
826                 ret = False;
827         }
828
829         if (!test_GetDcName(p, mem_ctx)) {
830                 ret = False;
831         }
832
833         if (!test_LogonControl(p, mem_ctx)) {
834                 ret = False;
835         }
836
837         if (!test_GetAnyDCName(p, mem_ctx)) {
838                 ret = False;
839         }
840
841         if (!test_LogonControl2(p, mem_ctx)) {
842                 ret = False;
843         }
844
845         if (!test_DatabaseSync2(p, mem_ctx)) {
846                 ret = False;
847         }
848
849         if (!test_LogonControl2Ex(p, mem_ctx)) {
850                 ret = False;
851         }
852
853         torture_rpc_close(p);
854
855         return ret;
856 }