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