r19392: Use torture_setting_* rather than lp_parm_* where possible.
[sfrench/samba-autobuild/.git] / source4 / torture / rpc / winreg.c
1 /* 
2    Unix SMB/CIFS implementation.
3    test suite for winreg rpc operations
4
5    Copyright (C) Tim Potter 2003
6    Copyright (C) Jelmer Vernooij 2004
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 #include "torture/torture.h"
25 #include "librpc/gen_ndr/ndr_winreg_c.h"
26 #include "librpc/gen_ndr/ndr_security.h"
27 #include "libcli/security/security.h"
28 #include "torture/rpc/rpc.h"
29
30 #define TEST_KEY_BASE "smbtorture test"
31 #define TEST_KEY1 TEST_KEY_BASE "\\spottyfoot"
32 #define TEST_KEY2 TEST_KEY_BASE "\\with a SD (#1)"
33
34 static void init_initshutdown_String(TALLOC_CTX *mem_ctx, struct initshutdown_String *name, const char *s)
35 {
36         name->name = talloc(mem_ctx, struct initshutdown_String_sub);
37         name->name->name = s;
38 }
39
40 static void init_winreg_String(struct winreg_String *name, const char *s)
41 {
42         name->name = s;
43         if (s) {
44                 name->name_len = 2 * (strlen_m(s) + 1);
45                 name->name_size = name->name_len;
46         } else {
47                 name->name_len = 0;
48                 name->name_size = 0;
49         }
50 }
51
52 static BOOL test_GetVersion(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
53                             struct policy_handle *handle)
54 {
55         NTSTATUS status;
56         struct winreg_GetVersion r;
57         uint32_t v;
58         printf("\ntesting GetVersion\n");
59
60         ZERO_STRUCT(r);
61         r.in.handle = handle;
62         r.out.version = &v;
63
64         status = dcerpc_winreg_GetVersion(p, mem_ctx, &r);
65
66         if (!NT_STATUS_IS_OK(status)) {
67                 printf("GetVersion failed - %s\n", nt_errstr(status));
68                 return False;
69         }
70
71         if (!W_ERROR_IS_OK(r.out.result)) {
72                 printf("GetVersion failed - %s\n", win_errstr(r.out.result));
73                 return False;
74         }
75
76         return True;
77 }
78
79 static BOOL test_NotifyChangeKeyValue(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
80                                                                           struct policy_handle *handle)
81 {
82         struct winreg_NotifyChangeKeyValue r;
83         NTSTATUS status;
84
85         printf("\ntesting NotifyChangeKeyValue\n");
86
87         r.in.handle = handle;
88         r.in.watch_subtree = 1;
89         r.in.notify_filter = 0;
90         r.in.unknown = r.in.unknown2 = 0;
91         init_winreg_String(&r.in.string1, NULL);
92         init_winreg_String(&r.in.string2, NULL);
93
94         status = dcerpc_winreg_NotifyChangeKeyValue(p, mem_ctx, &r);
95         
96         if (!NT_STATUS_IS_OK(status)) {
97                 printf("NotifyChangeKeyValue failed - %s\n", nt_errstr(status));
98                 return False;
99         }
100
101         if (!W_ERROR_IS_OK(r.out.result)) {
102                 printf("NotifyChangeKeyValue failed - %s - not considering\n", win_errstr(r.out.result));
103                 return True;
104         }
105
106         return True;
107 }
108
109 static BOOL test_CreateKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
110                           struct policy_handle *handle, const char *name, 
111                            const char *class)
112 {
113         struct winreg_CreateKey r;
114         struct policy_handle newhandle;
115         NTSTATUS status;
116         enum winreg_CreateAction action_taken = 0;
117
118         printf("\ntesting CreateKey\n");
119
120         r.in.handle = handle;
121         r.out.new_handle = &newhandle;
122         init_winreg_String(&r.in.name, name);   
123         init_winreg_String(&r.in.keyclass, class);
124         r.in.options = 0x0;
125         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
126         r.in.action_taken = r.out.action_taken = &action_taken;
127         r.in.secdesc = NULL;
128
129         status = dcerpc_winreg_CreateKey(p, mem_ctx, &r);
130
131         if (!NT_STATUS_IS_OK(status)) {
132                 printf("CreateKey failed - %s\n", nt_errstr(status));
133                 return False;
134         }
135
136         if (!W_ERROR_IS_OK(r.out.result)) {
137                 printf("CreateKey failed - %s\n", win_errstr(r.out.result));
138                 return False;
139         }
140
141         return True;
142 }
143
144
145 /*
146   createkey testing with a SD
147 */
148 static BOOL test_CreateKey_sd(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
149                               struct policy_handle *handle, const char *name, 
150                               const char *class, struct policy_handle *newhandle)
151 {
152         struct winreg_CreateKey r;
153         NTSTATUS status;
154         enum winreg_CreateAction action_taken = 0;
155         struct security_descriptor *sd;
156         DATA_BLOB sdblob;
157         struct winreg_SecBuf secbuf;
158
159         sd = security_descriptor_create(mem_ctx,
160                                         NULL, NULL,
161                                         SID_NT_AUTHENTICATED_USERS,
162                                         SEC_ACE_TYPE_ACCESS_ALLOWED,
163                                         SEC_GENERIC_ALL,
164                                         SEC_ACE_FLAG_OBJECT_INHERIT,
165                                         NULL);
166
167         status = ndr_push_struct_blob(&sdblob, mem_ctx, sd, 
168                                       (ndr_push_flags_fn_t)ndr_push_security_descriptor);
169         if (!NT_STATUS_IS_OK(status)) {
170                 printf("Failed to push security_descriptor ?!\n");
171                 return False;
172         }
173
174         secbuf.sd.data = sdblob.data;
175         secbuf.sd.len = sdblob.length;
176         secbuf.sd.size = sdblob.length;
177         secbuf.length = sdblob.length-10;
178         secbuf.inherit = 0;
179
180         printf("\ntesting CreateKey with sd\n");
181
182         r.in.handle = handle;
183         r.out.new_handle = newhandle;
184         init_winreg_String(&r.in.name, name);   
185         init_winreg_String(&r.in.keyclass, class);
186         r.in.options = 0x0;
187         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
188         r.in.action_taken = r.out.action_taken = &action_taken;
189         r.in.secdesc = &secbuf;
190
191         status = dcerpc_winreg_CreateKey(p, mem_ctx, &r);
192
193         if (!NT_STATUS_IS_OK(status)) {
194                 printf("CreateKey with sd failed - %s\n", nt_errstr(status));
195                 return False;
196         }
197
198         if (!W_ERROR_IS_OK(r.out.result)) {
199                 printf("CreateKey with sd failed - %s\n", win_errstr(r.out.result));
200                 return False;
201         }
202
203         return True;
204 }
205
206 static BOOL test_GetKeySecurity(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
207                           struct policy_handle *handle)
208 {
209         NTSTATUS status;
210         struct winreg_GetKeySecurity r;
211         struct security_descriptor sd;
212         DATA_BLOB sdblob;
213
214         printf("\ntesting GetKeySecurity\n");
215
216         ZERO_STRUCT(r);
217
218         r.in.handle = handle;
219         r.in.sd = r.out.sd = talloc_zero(mem_ctx, struct KeySecurityData);
220         r.in.sd->size = 0x1000;
221         r.in.sec_info = SECINFO_OWNER | SECINFO_GROUP | SECINFO_DACL;
222
223         status = dcerpc_winreg_GetKeySecurity(p, mem_ctx, &r);
224
225         if (!NT_STATUS_IS_OK(status)) {
226                 printf("GetKeySecurity failed - %s\n", nt_errstr(status));
227                 return False;
228         }
229
230         if (!W_ERROR_IS_OK(r.out.result)) {
231                 printf("GetKeySecurity failed - %s\n", win_errstr(r.out.result));
232                 return False;
233         }
234
235         sdblob.data = r.out.sd->data;
236         sdblob.length = r.out.sd->len;
237
238         status = ndr_pull_struct_blob(&sdblob, mem_ctx, &sd, 
239                                       (ndr_pull_flags_fn_t)ndr_pull_security_descriptor);
240         if (!NT_STATUS_IS_OK(status)) {
241                 printf("pull_security_descriptor failed - %s\n", nt_errstr(status));
242                 return False;
243         }
244         if (p->conn->flags & DCERPC_DEBUG_PRINT_OUT) {
245                 NDR_PRINT_DEBUG(security_descriptor, &sd);
246         }
247
248         return True;
249 }
250
251 static BOOL test_CloseKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
252                           struct policy_handle *handle)
253 {
254         NTSTATUS status;
255         struct winreg_CloseKey r;
256
257         printf("\ntesting CloseKey\n");
258
259         r.in.handle = r.out.handle = handle;
260
261         status = dcerpc_winreg_CloseKey(p, mem_ctx, &r);
262
263         if (!NT_STATUS_IS_OK(status)) {
264                 printf("CloseKey failed - %s\n", nt_errstr(status));
265                 return False;
266         }
267
268         if (!W_ERROR_IS_OK(r.out.result)) {
269                 printf("CloseKey failed - %s\n", win_errstr(r.out.result));
270                 return False;
271         }
272
273         return True;
274 }
275
276 static BOOL test_FlushKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
277                           struct policy_handle *handle)
278 {
279         NTSTATUS status;
280         struct winreg_FlushKey r;
281
282         printf("\ntesting FlushKey\n");
283
284         r.in.handle = handle;
285
286         status = dcerpc_winreg_FlushKey(p, mem_ctx, &r);
287
288         if (!NT_STATUS_IS_OK(status)) {
289                 printf("FlushKey failed - %s\n", nt_errstr(status));
290                 return False;
291         }
292
293         if (!W_ERROR_IS_OK(r.out.result)) {
294                 printf("FlushKey failed - %s\n", win_errstr(r.out.result));
295                 return False;
296         }
297
298         return True;
299 }
300
301 static BOOL test_OpenKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
302                          struct policy_handle *hive_handle,
303                          const char *keyname, struct policy_handle *key_handle)
304 {
305         NTSTATUS status;
306         struct winreg_OpenKey r;
307
308         printf("\ntesting OpenKey\n");
309
310         r.in.parent_handle = hive_handle;
311         init_winreg_String(&r.in.keyname, keyname);
312         r.in.unknown = 0x00000000;
313         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
314         r.out.handle = key_handle;
315
316         status = dcerpc_winreg_OpenKey(p, mem_ctx, &r);
317
318         if (!NT_STATUS_IS_OK(status)) {
319                 printf("OpenKey failed - %s\n", nt_errstr(status));
320                 return False;
321         }
322
323         if (!W_ERROR_IS_OK(r.out.result)) {
324                 printf("OpenKey failed - %s\n", win_errstr(r.out.result));
325
326                 return False;
327         }
328
329         return True;
330 }
331
332 static BOOL test_Cleanup(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
333                          struct policy_handle *handle, const char *key)
334 {
335         struct winreg_DeleteKey r;
336
337         r.in.handle = handle;
338
339         init_winreg_String(&r.in.key, key);
340         dcerpc_winreg_DeleteKey(p, mem_ctx, &r);
341
342         return True;
343 }
344
345
346 static BOOL test_DeleteKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
347                            struct policy_handle *handle, const char *key)
348 {
349         NTSTATUS status;
350         struct winreg_DeleteKey r;
351
352         printf("\ntesting DeleteKey\n");
353
354         r.in.handle = handle;
355         init_winreg_String(&r.in.key, key);     
356
357         status = dcerpc_winreg_DeleteKey(p, mem_ctx, &r);
358
359         if (!NT_STATUS_IS_OK(status)) {
360                 printf("DeleteKey failed - %s\n", nt_errstr(status));
361                 return False;
362         }
363
364         if (!W_ERROR_IS_OK(r.out.result)) {
365                 printf("DeleteKey failed - %s\n", win_errstr(r.out.result));
366                 return False;
367         }
368
369         return True;
370 }
371
372 static BOOL test_QueryInfoKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
373                               struct policy_handle *handle, char *class)
374 {
375         NTSTATUS status;
376         struct winreg_QueryInfoKey r;
377         uint32_t num_subkeys, max_subkeylen, max_subkeysize,
378                 num_values, max_valnamelen, max_valbufsize,
379                 secdescsize;
380         NTTIME last_changed_time;
381
382         printf("\ntesting QueryInfoKey\n");
383
384         ZERO_STRUCT(r);
385         r.in.handle = handle;
386         r.out.num_subkeys = &num_subkeys;
387         r.out.max_subkeylen = &max_subkeylen;
388         r.out.max_subkeysize = &max_subkeysize;
389         r.out.num_values = &num_values;
390         r.out.max_valnamelen = &max_valnamelen;
391         r.out.max_valbufsize = &max_valbufsize;
392         r.out.secdescsize = &secdescsize;
393         r.out.last_changed_time = &last_changed_time;
394         
395         init_winreg_String(&r.in.class_in, class);
396         
397         status = dcerpc_winreg_QueryInfoKey(p, mem_ctx, &r);
398
399         if (!NT_STATUS_IS_OK(status)) {
400                 printf("QueryInfoKey failed - %s\n", nt_errstr(status));
401                 return False;
402         }
403
404         if (!W_ERROR_IS_OK(r.out.result)) {
405                 printf("QueryInfoKey failed - %s\n", win_errstr(r.out.result));
406                 return False;
407         }
408
409         return True;
410 }
411
412 static BOOL test_key(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
413                      struct policy_handle *handle, int depth);
414
415 static BOOL test_EnumKey(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
416                          struct policy_handle *handle, int depth)
417 {
418         struct winreg_EnumKey r;
419         struct winreg_StringBuf class, name;
420         NTSTATUS status;
421         NTTIME t = 0;
422
423         printf("Testing EnumKey\n\n");
424
425         class.name   = "";
426         class.size   = 1024;
427
428         r.in.handle = handle;
429         r.in.enum_index = 0;
430         r.in.name = &name;
431         r.in.keyclass = &class;
432         r.out.name = &name;
433         r.in.last_changed_time = &t;
434
435         do {
436                 name.name   = NULL;
437                 name.size   = 1024;
438
439                 status = dcerpc_winreg_EnumKey(p, mem_ctx, &r);
440
441                 if (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result)) {
442                         struct policy_handle key_handle;
443
444                         printf("EnumKey: %d: %s\n", r.in.enum_index, r.out.name->name);
445
446                         if (!test_OpenKey(
447                                     p, mem_ctx, handle, r.out.name->name,
448                                     &key_handle)) {
449                         } else {
450                                 test_key(p, mem_ctx, &key_handle, depth + 1);
451                         }
452                 }
453
454                 r.in.enum_index++;
455
456         } while (NT_STATUS_IS_OK(status) && W_ERROR_IS_OK(r.out.result));
457
458         if (!NT_STATUS_IS_OK(status)) {
459                 printf("EnumKey failed - %s\n", nt_errstr(status));
460                 return False;
461         }
462
463         if (!W_ERROR_IS_OK(r.out.result) && !W_ERROR_EQUAL(r.out.result, WERR_NO_MORE_ITEMS)) {
464                 printf("EnumKey failed - %s\n", win_errstr(r.out.result));
465                 return False;
466         }
467
468
469
470         return True;
471 }
472
473 static BOOL test_QueryMultipleValues(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *handle, const char *valuename)
474 {
475         struct winreg_QueryMultipleValues r;
476         NTSTATUS status;
477         uint32_t bufsize=0;
478
479         printf("Testing QueryMultipleValues\n");
480
481         r.in.key_handle = handle;
482         r.in.values = r.out.values = talloc_array(mem_ctx, struct QueryMultipleValue, 1);
483         r.in.values[0].name = talloc(mem_ctx, struct winreg_String);
484         r.in.values[0].name->name = valuename;
485         r.in.values[0].offset = 0;
486         r.in.values[0].length = 0;
487         r.in.values[0].type = 0;
488
489         r.in.num_values = 1;
490         r.in.buffer_size = r.out.buffer_size = talloc(mem_ctx, uint32_t);
491         *r.in.buffer_size = bufsize;
492         do { 
493                 *r.in.buffer_size = bufsize;
494                 r.in.buffer = r.out.buffer = talloc_zero_array(mem_ctx, uint8_t, 
495                                                                *r.in.buffer_size);
496
497                 status = dcerpc_winreg_QueryMultipleValues(p, mem_ctx, &r);
498         
499                 if(NT_STATUS_IS_ERR(status)) {
500                         printf("QueryMultipleValues failed - %s\n", nt_errstr(status));
501                         return False;
502                 }
503                 talloc_free(r.in.buffer);
504                 bufsize += 0x20;
505         } while (W_ERROR_EQUAL(r.out.result, WERR_MORE_DATA));
506
507         if (!W_ERROR_IS_OK(r.out.result)) {
508                 printf("QueryMultipleValues failed - %s\n", win_errstr(r.out.result));
509                 return False;
510         }
511
512         return True;
513 }
514
515 static BOOL test_QueryValue(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, struct policy_handle *handle, const char *valuename)
516 {
517         struct winreg_QueryValue r;
518         NTSTATUS status;
519         enum winreg_Type zero_type = 0;
520         uint32_t offered = 0xfff;
521         uint32_t zero = 0;
522
523         printf("Testing QueryValue\n");
524
525         r.in.handle = handle;
526         r.in.data = NULL;
527         r.in.value_name.name = valuename;
528         r.in.type = &zero_type;
529         r.in.size = &offered;
530         r.in.length = &zero;
531
532         status = dcerpc_winreg_QueryValue(p, mem_ctx, &r);
533         if(NT_STATUS_IS_ERR(status)) {
534                 printf("QueryValue failed - %s\n", nt_errstr(status));
535                 return False;
536         }
537
538         if (!W_ERROR_IS_OK(r.out.result)) {
539                 printf("QueryValue failed - %s\n", win_errstr(r.out.result));
540                 return False;
541         }
542
543         return True;
544 }
545
546 static BOOL test_EnumValue(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
547                            struct policy_handle *handle, int max_valnamelen, int max_valbufsize)
548 {
549         struct winreg_EnumValue r;
550         enum winreg_Type type = 0;
551         uint32_t size = max_valbufsize, zero = 0;
552         BOOL ret = True;
553         uint8_t buf8;
554         struct winreg_StringBuf name;
555
556         printf("testing EnumValue\n");
557
558         name.name   = "";
559         name.size   = 1024;
560
561         r.in.handle = handle;
562         r.in.enum_index = 0;
563         r.in.name = &name;
564         r.out.name = &name;
565         r.in.type = &type;
566         r.in.value = &buf8;
567         r.in.length = &zero;
568         r.in.size = &size;
569         
570         do {
571                 NTSTATUS status = dcerpc_winreg_EnumValue(p, mem_ctx, &r);
572                 if(NT_STATUS_IS_ERR(status)) {
573                         printf("EnumValue failed - %s\n", nt_errstr(status));
574                         return False;
575                 }
576
577                 if (W_ERROR_IS_OK(r.out.result)) {
578                         ret &= test_QueryValue(p, mem_ctx, handle, r.out.name->name);
579                         ret &= test_QueryMultipleValues(p, mem_ctx, handle, r.out.name->name);
580                 }
581
582                 r.in.enum_index++;
583         } while (W_ERROR_IS_OK(r.out.result));
584
585         if(!W_ERROR_EQUAL(r.out.result, WERR_NO_MORE_ITEMS)) {
586                 printf("EnumValue failed - %s\n", win_errstr(r.out.result));
587                 return False;
588         }
589
590         return ret;
591 }
592
593 static BOOL test_InitiateSystemShutdown(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
594                         const char *msg, uint32_t timeout)
595 {
596         struct winreg_InitiateSystemShutdown r;
597         NTSTATUS status;
598         uint16_t hostname = 0x0;
599         
600         r.in.hostname = &hostname;
601         r.in.message = talloc(mem_ctx, struct initshutdown_String);
602         init_initshutdown_String(mem_ctx, r.in.message, msg);
603         r.in.force_apps = 1;
604         r.in.timeout = timeout;
605         r.in.reboot = 1;
606
607         status = dcerpc_winreg_InitiateSystemShutdown(p, mem_ctx, &r);
608
609         if (!NT_STATUS_IS_OK(status)) {
610                 printf("InitiateSystemShutdown failed - %s\n", nt_errstr(status));
611                 return False;
612         }
613
614         if (!W_ERROR_IS_OK(r.out.result)) {
615                 printf("InitiateSystemShutdown failed - %s\n", win_errstr(r.out.result));
616                 return False;
617         }
618
619         return True;
620 }
621
622 static BOOL test_InitiateSystemShutdownEx(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx,
623                         const char *msg, uint32_t timeout)
624 {
625         struct winreg_InitiateSystemShutdownEx r;
626         NTSTATUS status;
627         uint16_t hostname = 0x0;
628         
629         r.in.hostname = &hostname;
630         r.in.message = talloc(mem_ctx, struct initshutdown_String);
631         init_initshutdown_String(mem_ctx, r.in.message, msg);
632         r.in.force_apps = 1;
633         r.in.timeout = timeout;
634         r.in.reboot = 1;
635         r.in.reason = 0;
636
637         status = dcerpc_winreg_InitiateSystemShutdownEx(p, mem_ctx, &r);
638
639         if (!NT_STATUS_IS_OK(status)) {
640                 printf("InitiateSystemShutdownEx failed - %s\n", nt_errstr(status));
641                 return False;
642         }
643
644         if (!W_ERROR_IS_OK(r.out.result)) {
645                 printf("InitiateSystemShutdownEx failed - %s\n", win_errstr(r.out.result));
646                 return False;
647         }
648
649         return True;
650 }
651
652 static BOOL test_AbortSystemShutdown(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx)
653 {
654         struct winreg_AbortSystemShutdown r;
655         NTSTATUS status;
656         uint16_t server = 0x0;
657
658         r.in.server = &server;
659         
660         status = dcerpc_winreg_AbortSystemShutdown(p, mem_ctx, &r);
661
662         if (!NT_STATUS_IS_OK(status)) {
663                 printf("AbortSystemShutdown failed - %s\n", nt_errstr(status));
664                 return False;
665         }
666
667         if (!W_ERROR_IS_OK(r.out.result)) {
668                 printf("AbortSystemShutdown failed - %s\n", win_errstr(r.out.result));
669                 return False;
670         }
671
672         return True;
673 }
674
675 #define MAX_DEPTH 2             /* Only go this far down the tree */
676
677 static BOOL test_key(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
678                      struct policy_handle *handle, int depth)
679 {
680         if (depth == MAX_DEPTH)
681                 return True;
682
683         if (!test_QueryInfoKey(p, mem_ctx, handle, NULL)) {
684         }
685
686
687         if (!test_NotifyChangeKeyValue(p, mem_ctx, handle)) {
688         }
689         
690         if (!test_GetKeySecurity(p, mem_ctx, handle)) {
691         }
692
693         if (!test_EnumKey(p, mem_ctx, handle, depth)) {
694         }
695
696         if (!test_EnumValue(p, mem_ctx, handle, 0xFF, 0xFFFF)) {
697         }
698
699
700         test_CloseKey(p, mem_ctx, handle);
701
702         return True;
703 }
704
705 typedef NTSTATUS (*winreg_open_fn)(struct dcerpc_pipe *, TALLOC_CTX *, void *);
706
707 static BOOL test_Open(struct dcerpc_pipe *p, TALLOC_CTX *mem_ctx, 
708                       const char *name, winreg_open_fn open_fn)
709 {
710         struct policy_handle handle, newhandle;
711         BOOL ret = True, created = False, created2 = False, deleted = False;
712         struct winreg_OpenHKLM r;
713         NTSTATUS status;
714
715         printf("Testing %s\n", name);
716
717         r.in.system_name = 0;
718         r.in.access_mask = SEC_FLAG_MAXIMUM_ALLOWED;
719         r.out.handle = &handle;
720         
721         status = open_fn(p, mem_ctx, &r);
722         if (!NT_STATUS_IS_OK(status)) {
723                 return False;
724         }
725
726         test_Cleanup(p, mem_ctx, &handle, TEST_KEY1);
727         test_Cleanup(p, mem_ctx, &handle, TEST_KEY2);
728         test_Cleanup(p, mem_ctx, &handle, TEST_KEY_BASE);
729
730         if (!test_CreateKey(p, mem_ctx, &handle, TEST_KEY1, NULL)) {
731                 printf("CreateKey failed - not considering a failure\n");
732         } else {
733                 created = True;
734         }
735
736         if (created && !test_FlushKey(p, mem_ctx, &handle)) {
737                 printf("FlushKey failed\n");
738                 ret = False;
739         }
740
741         if (created && !test_OpenKey(p, mem_ctx, &handle, TEST_KEY1, &newhandle)) {
742                 printf("CreateKey failed (OpenKey after Create didn't work)\n");
743                 ret = False;
744         }
745
746         if (created && !test_DeleteKey(p, mem_ctx, &handle, TEST_KEY1)) {
747                 printf("DeleteKey failed\n");
748                 ret = False;
749         } else {
750                 deleted = True;
751         }
752
753         if (created && !test_FlushKey(p, mem_ctx, &handle)) {
754                 printf("FlushKey failed\n");
755                 ret = False;
756         }
757
758         if (created && deleted && 
759             test_OpenKey(p, mem_ctx, &handle, TEST_KEY1, &newhandle)) {
760                 printf("DeleteKey failed (OpenKey after Delete didn't work)\n");
761                 ret = False;
762         }
763
764         if (!test_GetVersion(p, mem_ctx, &handle)) {
765                 printf("GetVersion failed\n");
766                 ret = False;
767         }
768
769         if (created && test_CreateKey_sd(p, mem_ctx, &handle, TEST_KEY2, 
770                                           NULL, &newhandle)) {
771                 created2 = True;
772         }
773
774         if (created2 && !test_GetKeySecurity(p, mem_ctx, &newhandle)) {
775                 printf("GetKeySecurity failed\n");
776                 ret = False;
777         }
778
779         if (created2 && !test_CloseKey(p, mem_ctx, &newhandle)) {
780                 printf("CloseKey failed\n");
781                 ret = False;
782         }
783
784         if (created && !test_DeleteKey(p, mem_ctx, &handle, TEST_KEY2)) {
785                 printf("DeleteKey failed\n");
786                 ret = False;
787         }
788
789         /* The HKCR hive has a very large fanout */
790
791         if (open_fn == (void *)dcerpc_winreg_OpenHKCR) {
792                 if(!test_key(p, mem_ctx, &handle, MAX_DEPTH - 1)) {
793                         ret = False;
794                 }
795         }
796
797         if(!test_key(p, mem_ctx, &handle, 0)) {
798                 ret = False;
799         }
800
801         test_Cleanup(p, mem_ctx, &handle, TEST_KEY_BASE);
802
803         return ret;
804 }
805
806 BOOL torture_rpc_winreg(struct torture_context *torture)
807 {
808         NTSTATUS status;
809         struct dcerpc_pipe *p;
810         TALLOC_CTX *mem_ctx;
811         BOOL ret = True;
812         struct {
813                 const char *name;
814                 winreg_open_fn fn;
815         } open_fns[] = {{"OpenHKLM", (winreg_open_fn)dcerpc_winreg_OpenHKLM },
816                         {"OpenHKU",  (winreg_open_fn)dcerpc_winreg_OpenHKU },
817                         {"OpenHKCR", (winreg_open_fn)dcerpc_winreg_OpenHKCR },
818                         {"OpenHKCU", (winreg_open_fn)dcerpc_winreg_OpenHKCU }};
819         int i;
820         mem_ctx = talloc_init("torture_rpc_winreg");
821
822         status = torture_rpc_connection(mem_ctx, &p, &dcerpc_table_winreg);
823
824         if (!NT_STATUS_IS_OK(status)) {
825                 talloc_free(mem_ctx);
826                 return False;
827         }
828
829         if (!torture_setting_bool(torture, "dangerous", False)) {
830                 printf("winreg_InitiateShutdown disabled - enable dangerous tests to use\n");
831         } else {
832                 ret &= test_InitiateSystemShutdown(p, mem_ctx, "spottyfood", 30);
833                 ret &= test_AbortSystemShutdown(p, mem_ctx);
834                 ret &= test_InitiateSystemShutdownEx(p, mem_ctx, "spottyfood", 30);
835                 ret &= test_AbortSystemShutdown(p, mem_ctx);
836         }
837
838         for (i = 0; i < ARRAY_SIZE(open_fns); i++) {
839                 if (!test_Open(p, mem_ctx, open_fns[i].name, open_fns[i].fn))
840                         ret = False;
841         }
842
843         talloc_free(mem_ctx);
844
845         return ret;
846 }