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