← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/cli_winreg.c

  • Committer: Chuck Short
  • Date: 2010-09-28 20:38:39 UTC
  • Revision ID: zulcss@ubuntu.com-20100928203839-pgjulytsi9ue63x1
Initial version

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/cli_winreg.c
 
1
/*
 
2
 * Unix SMB/CIFS implementation.
 
3
 * client auto-generated by pidl. DO NOT MODIFY!
 
4
 */
 
5
 
 
6
#include "includes.h"
 
7
#include "../librpc/gen_ndr/cli_winreg.h"
 
8
 
 
9
NTSTATUS rpccli_winreg_OpenHKCR(struct rpc_pipe_client *cli,
 
10
                                TALLOC_CTX *mem_ctx,
 
11
                                uint16_t *system_name /* [in] [unique] */,
 
12
                                uint32_t access_mask /* [in]  */,
 
13
                                struct policy_handle *handle /* [out] [ref] */,
 
14
                                WERROR *werror)
 
15
{
 
16
        struct winreg_OpenHKCR r;
 
17
        NTSTATUS status;
 
18
 
 
19
        /* In parameters */
 
20
        r.in.system_name = system_name;
 
21
        r.in.access_mask = access_mask;
 
22
 
 
23
        if (DEBUGLEVEL >= 10) {
 
24
                NDR_PRINT_IN_DEBUG(winreg_OpenHKCR, &r);
 
25
        }
 
26
 
 
27
        status = cli->dispatch(cli,
 
28
                                mem_ctx,
 
29
                                &ndr_table_winreg,
 
30
                                NDR_WINREG_OPENHKCR,
 
31
                                &r);
 
32
 
 
33
        if (!NT_STATUS_IS_OK(status)) {
 
34
                return status;
 
35
        }
 
36
 
 
37
        if (DEBUGLEVEL >= 10) {
 
38
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKCR, &r);
 
39
        }
 
40
 
 
41
        if (NT_STATUS_IS_ERR(status)) {
 
42
                return status;
 
43
        }
 
44
 
 
45
        /* Return variables */
 
46
        *handle = *r.out.handle;
 
47
 
 
48
        /* Return result */
 
49
        if (werror) {
 
50
                *werror = r.out.result;
 
51
        }
 
52
 
 
53
        return werror_to_ntstatus(r.out.result);
 
54
}
 
55
 
 
56
NTSTATUS rpccli_winreg_OpenHKCU(struct rpc_pipe_client *cli,
 
57
                                TALLOC_CTX *mem_ctx,
 
58
                                uint16_t *system_name /* [in] [unique] */,
 
59
                                uint32_t access_mask /* [in]  */,
 
60
                                struct policy_handle *handle /* [out] [ref] */,
 
61
                                WERROR *werror)
 
62
{
 
63
        struct winreg_OpenHKCU r;
 
64
        NTSTATUS status;
 
65
 
 
66
        /* In parameters */
 
67
        r.in.system_name = system_name;
 
68
        r.in.access_mask = access_mask;
 
69
 
 
70
        if (DEBUGLEVEL >= 10) {
 
71
                NDR_PRINT_IN_DEBUG(winreg_OpenHKCU, &r);
 
72
        }
 
73
 
 
74
        status = cli->dispatch(cli,
 
75
                                mem_ctx,
 
76
                                &ndr_table_winreg,
 
77
                                NDR_WINREG_OPENHKCU,
 
78
                                &r);
 
79
 
 
80
        if (!NT_STATUS_IS_OK(status)) {
 
81
                return status;
 
82
        }
 
83
 
 
84
        if (DEBUGLEVEL >= 10) {
 
85
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKCU, &r);
 
86
        }
 
87
 
 
88
        if (NT_STATUS_IS_ERR(status)) {
 
89
                return status;
 
90
        }
 
91
 
 
92
        /* Return variables */
 
93
        *handle = *r.out.handle;
 
94
 
 
95
        /* Return result */
 
96
        if (werror) {
 
97
                *werror = r.out.result;
 
98
        }
 
99
 
 
100
        return werror_to_ntstatus(r.out.result);
 
101
}
 
102
 
 
103
NTSTATUS rpccli_winreg_OpenHKLM(struct rpc_pipe_client *cli,
 
104
                                TALLOC_CTX *mem_ctx,
 
105
                                uint16_t *system_name /* [in] [unique] */,
 
106
                                uint32_t access_mask /* [in]  */,
 
107
                                struct policy_handle *handle /* [out] [ref] */,
 
108
                                WERROR *werror)
 
109
{
 
110
        struct winreg_OpenHKLM r;
 
111
        NTSTATUS status;
 
112
 
 
113
        /* In parameters */
 
114
        r.in.system_name = system_name;
 
115
        r.in.access_mask = access_mask;
 
116
 
 
117
        if (DEBUGLEVEL >= 10) {
 
118
                NDR_PRINT_IN_DEBUG(winreg_OpenHKLM, &r);
 
119
        }
 
120
 
 
121
        status = cli->dispatch(cli,
 
122
                                mem_ctx,
 
123
                                &ndr_table_winreg,
 
124
                                NDR_WINREG_OPENHKLM,
 
125
                                &r);
 
126
 
 
127
        if (!NT_STATUS_IS_OK(status)) {
 
128
                return status;
 
129
        }
 
130
 
 
131
        if (DEBUGLEVEL >= 10) {
 
132
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKLM, &r);
 
133
        }
 
134
 
 
135
        if (NT_STATUS_IS_ERR(status)) {
 
136
                return status;
 
137
        }
 
138
 
 
139
        /* Return variables */
 
140
        *handle = *r.out.handle;
 
141
 
 
142
        /* Return result */
 
143
        if (werror) {
 
144
                *werror = r.out.result;
 
145
        }
 
146
 
 
147
        return werror_to_ntstatus(r.out.result);
 
148
}
 
149
 
 
150
NTSTATUS rpccli_winreg_OpenHKPD(struct rpc_pipe_client *cli,
 
151
                                TALLOC_CTX *mem_ctx,
 
152
                                uint16_t *system_name /* [in] [unique] */,
 
153
                                uint32_t access_mask /* [in]  */,
 
154
                                struct policy_handle *handle /* [out] [ref] */,
 
155
                                WERROR *werror)
 
156
{
 
157
        struct winreg_OpenHKPD r;
 
158
        NTSTATUS status;
 
159
 
 
160
        /* In parameters */
 
161
        r.in.system_name = system_name;
 
162
        r.in.access_mask = access_mask;
 
163
 
 
164
        if (DEBUGLEVEL >= 10) {
 
165
                NDR_PRINT_IN_DEBUG(winreg_OpenHKPD, &r);
 
166
        }
 
167
 
 
168
        status = cli->dispatch(cli,
 
169
                                mem_ctx,
 
170
                                &ndr_table_winreg,
 
171
                                NDR_WINREG_OPENHKPD,
 
172
                                &r);
 
173
 
 
174
        if (!NT_STATUS_IS_OK(status)) {
 
175
                return status;
 
176
        }
 
177
 
 
178
        if (DEBUGLEVEL >= 10) {
 
179
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKPD, &r);
 
180
        }
 
181
 
 
182
        if (NT_STATUS_IS_ERR(status)) {
 
183
                return status;
 
184
        }
 
185
 
 
186
        /* Return variables */
 
187
        *handle = *r.out.handle;
 
188
 
 
189
        /* Return result */
 
190
        if (werror) {
 
191
                *werror = r.out.result;
 
192
        }
 
193
 
 
194
        return werror_to_ntstatus(r.out.result);
 
195
}
 
196
 
 
197
NTSTATUS rpccli_winreg_OpenHKU(struct rpc_pipe_client *cli,
 
198
                               TALLOC_CTX *mem_ctx,
 
199
                               uint16_t *system_name /* [in] [unique] */,
 
200
                               uint32_t access_mask /* [in]  */,
 
201
                               struct policy_handle *handle /* [out] [ref] */,
 
202
                               WERROR *werror)
 
203
{
 
204
        struct winreg_OpenHKU r;
 
205
        NTSTATUS status;
 
206
 
 
207
        /* In parameters */
 
208
        r.in.system_name = system_name;
 
209
        r.in.access_mask = access_mask;
 
210
 
 
211
        if (DEBUGLEVEL >= 10) {
 
212
                NDR_PRINT_IN_DEBUG(winreg_OpenHKU, &r);
 
213
        }
 
214
 
 
215
        status = cli->dispatch(cli,
 
216
                                mem_ctx,
 
217
                                &ndr_table_winreg,
 
218
                                NDR_WINREG_OPENHKU,
 
219
                                &r);
 
220
 
 
221
        if (!NT_STATUS_IS_OK(status)) {
 
222
                return status;
 
223
        }
 
224
 
 
225
        if (DEBUGLEVEL >= 10) {
 
226
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKU, &r);
 
227
        }
 
228
 
 
229
        if (NT_STATUS_IS_ERR(status)) {
 
230
                return status;
 
231
        }
 
232
 
 
233
        /* Return variables */
 
234
        *handle = *r.out.handle;
 
235
 
 
236
        /* Return result */
 
237
        if (werror) {
 
238
                *werror = r.out.result;
 
239
        }
 
240
 
 
241
        return werror_to_ntstatus(r.out.result);
 
242
}
 
243
 
 
244
NTSTATUS rpccli_winreg_CloseKey(struct rpc_pipe_client *cli,
 
245
                                TALLOC_CTX *mem_ctx,
 
246
                                struct policy_handle *handle /* [in,out] [ref] */,
 
247
                                WERROR *werror)
 
248
{
 
249
        struct winreg_CloseKey r;
 
250
        NTSTATUS status;
 
251
 
 
252
        /* In parameters */
 
253
        r.in.handle = handle;
 
254
 
 
255
        if (DEBUGLEVEL >= 10) {
 
256
                NDR_PRINT_IN_DEBUG(winreg_CloseKey, &r);
 
257
        }
 
258
 
 
259
        status = cli->dispatch(cli,
 
260
                                mem_ctx,
 
261
                                &ndr_table_winreg,
 
262
                                NDR_WINREG_CLOSEKEY,
 
263
                                &r);
 
264
 
 
265
        if (!NT_STATUS_IS_OK(status)) {
 
266
                return status;
 
267
        }
 
268
 
 
269
        if (DEBUGLEVEL >= 10) {
 
270
                NDR_PRINT_OUT_DEBUG(winreg_CloseKey, &r);
 
271
        }
 
272
 
 
273
        if (NT_STATUS_IS_ERR(status)) {
 
274
                return status;
 
275
        }
 
276
 
 
277
        /* Return variables */
 
278
        *handle = *r.out.handle;
 
279
 
 
280
        /* Return result */
 
281
        if (werror) {
 
282
                *werror = r.out.result;
 
283
        }
 
284
 
 
285
        return werror_to_ntstatus(r.out.result);
 
286
}
 
287
 
 
288
NTSTATUS rpccli_winreg_CreateKey(struct rpc_pipe_client *cli,
 
289
                                 TALLOC_CTX *mem_ctx,
 
290
                                 struct policy_handle *handle /* [in] [ref] */,
 
291
                                 struct winreg_String name /* [in]  */,
 
292
                                 struct winreg_String keyclass /* [in]  */,
 
293
                                 uint32_t options /* [in]  */,
 
294
                                 uint32_t access_mask /* [in]  */,
 
295
                                 struct winreg_SecBuf *secdesc /* [in] [unique] */,
 
296
                                 struct policy_handle *new_handle /* [out] [ref] */,
 
297
                                 enum winreg_CreateAction *action_taken /* [in,out] [unique] */,
 
298
                                 WERROR *werror)
 
299
{
 
300
        struct winreg_CreateKey r;
 
301
        NTSTATUS status;
 
302
 
 
303
        /* In parameters */
 
304
        r.in.handle = handle;
 
305
        r.in.name = name;
 
306
        r.in.keyclass = keyclass;
 
307
        r.in.options = options;
 
308
        r.in.access_mask = access_mask;
 
309
        r.in.secdesc = secdesc;
 
310
        r.in.action_taken = action_taken;
 
311
 
 
312
        if (DEBUGLEVEL >= 10) {
 
313
                NDR_PRINT_IN_DEBUG(winreg_CreateKey, &r);
 
314
        }
 
315
 
 
316
        status = cli->dispatch(cli,
 
317
                                mem_ctx,
 
318
                                &ndr_table_winreg,
 
319
                                NDR_WINREG_CREATEKEY,
 
320
                                &r);
 
321
 
 
322
        if (!NT_STATUS_IS_OK(status)) {
 
323
                return status;
 
324
        }
 
325
 
 
326
        if (DEBUGLEVEL >= 10) {
 
327
                NDR_PRINT_OUT_DEBUG(winreg_CreateKey, &r);
 
328
        }
 
329
 
 
330
        if (NT_STATUS_IS_ERR(status)) {
 
331
                return status;
 
332
        }
 
333
 
 
334
        /* Return variables */
 
335
        *new_handle = *r.out.new_handle;
 
336
        if (action_taken && r.out.action_taken) {
 
337
                *action_taken = *r.out.action_taken;
 
338
        }
 
339
 
 
340
        /* Return result */
 
341
        if (werror) {
 
342
                *werror = r.out.result;
 
343
        }
 
344
 
 
345
        return werror_to_ntstatus(r.out.result);
 
346
}
 
347
 
 
348
NTSTATUS rpccli_winreg_DeleteKey(struct rpc_pipe_client *cli,
 
349
                                 TALLOC_CTX *mem_ctx,
 
350
                                 struct policy_handle *handle /* [in] [ref] */,
 
351
                                 struct winreg_String key /* [in]  */,
 
352
                                 WERROR *werror)
 
353
{
 
354
        struct winreg_DeleteKey r;
 
355
        NTSTATUS status;
 
356
 
 
357
        /* In parameters */
 
358
        r.in.handle = handle;
 
359
        r.in.key = key;
 
360
 
 
361
        if (DEBUGLEVEL >= 10) {
 
362
                NDR_PRINT_IN_DEBUG(winreg_DeleteKey, &r);
 
363
        }
 
364
 
 
365
        status = cli->dispatch(cli,
 
366
                                mem_ctx,
 
367
                                &ndr_table_winreg,
 
368
                                NDR_WINREG_DELETEKEY,
 
369
                                &r);
 
370
 
 
371
        if (!NT_STATUS_IS_OK(status)) {
 
372
                return status;
 
373
        }
 
374
 
 
375
        if (DEBUGLEVEL >= 10) {
 
376
                NDR_PRINT_OUT_DEBUG(winreg_DeleteKey, &r);
 
377
        }
 
378
 
 
379
        if (NT_STATUS_IS_ERR(status)) {
 
380
                return status;
 
381
        }
 
382
 
 
383
        /* Return variables */
 
384
 
 
385
        /* Return result */
 
386
        if (werror) {
 
387
                *werror = r.out.result;
 
388
        }
 
389
 
 
390
        return werror_to_ntstatus(r.out.result);
 
391
}
 
392
 
 
393
NTSTATUS rpccli_winreg_DeleteValue(struct rpc_pipe_client *cli,
 
394
                                   TALLOC_CTX *mem_ctx,
 
395
                                   struct policy_handle *handle /* [in] [ref] */,
 
396
                                   struct winreg_String value /* [in]  */,
 
397
                                   WERROR *werror)
 
398
{
 
399
        struct winreg_DeleteValue r;
 
400
        NTSTATUS status;
 
401
 
 
402
        /* In parameters */
 
403
        r.in.handle = handle;
 
404
        r.in.value = value;
 
405
 
 
406
        if (DEBUGLEVEL >= 10) {
 
407
                NDR_PRINT_IN_DEBUG(winreg_DeleteValue, &r);
 
408
        }
 
409
 
 
410
        status = cli->dispatch(cli,
 
411
                                mem_ctx,
 
412
                                &ndr_table_winreg,
 
413
                                NDR_WINREG_DELETEVALUE,
 
414
                                &r);
 
415
 
 
416
        if (!NT_STATUS_IS_OK(status)) {
 
417
                return status;
 
418
        }
 
419
 
 
420
        if (DEBUGLEVEL >= 10) {
 
421
                NDR_PRINT_OUT_DEBUG(winreg_DeleteValue, &r);
 
422
        }
 
423
 
 
424
        if (NT_STATUS_IS_ERR(status)) {
 
425
                return status;
 
426
        }
 
427
 
 
428
        /* Return variables */
 
429
 
 
430
        /* Return result */
 
431
        if (werror) {
 
432
                *werror = r.out.result;
 
433
        }
 
434
 
 
435
        return werror_to_ntstatus(r.out.result);
 
436
}
 
437
 
 
438
NTSTATUS rpccli_winreg_EnumKey(struct rpc_pipe_client *cli,
 
439
                               TALLOC_CTX *mem_ctx,
 
440
                               struct policy_handle *handle /* [in] [ref] */,
 
441
                               uint32_t enum_index /* [in]  */,
 
442
                               struct winreg_StringBuf *name /* [in,out] [ref] */,
 
443
                               struct winreg_StringBuf *keyclass /* [in,out] [unique] */,
 
444
                               NTTIME *last_changed_time /* [in,out] [unique] */,
 
445
                               WERROR *werror)
 
446
{
 
447
        struct winreg_EnumKey r;
 
448
        NTSTATUS status;
 
449
 
 
450
        /* In parameters */
 
451
        r.in.handle = handle;
 
452
        r.in.enum_index = enum_index;
 
453
        r.in.name = name;
 
454
        r.in.keyclass = keyclass;
 
455
        r.in.last_changed_time = last_changed_time;
 
456
 
 
457
        if (DEBUGLEVEL >= 10) {
 
458
                NDR_PRINT_IN_DEBUG(winreg_EnumKey, &r);
 
459
        }
 
460
 
 
461
        status = cli->dispatch(cli,
 
462
                                mem_ctx,
 
463
                                &ndr_table_winreg,
 
464
                                NDR_WINREG_ENUMKEY,
 
465
                                &r);
 
466
 
 
467
        if (!NT_STATUS_IS_OK(status)) {
 
468
                return status;
 
469
        }
 
470
 
 
471
        if (DEBUGLEVEL >= 10) {
 
472
                NDR_PRINT_OUT_DEBUG(winreg_EnumKey, &r);
 
473
        }
 
474
 
 
475
        if (NT_STATUS_IS_ERR(status)) {
 
476
                return status;
 
477
        }
 
478
 
 
479
        /* Return variables */
 
480
        *name = *r.out.name;
 
481
        if (keyclass && r.out.keyclass) {
 
482
                *keyclass = *r.out.keyclass;
 
483
        }
 
484
        if (last_changed_time && r.out.last_changed_time) {
 
485
                *last_changed_time = *r.out.last_changed_time;
 
486
        }
 
487
 
 
488
        /* Return result */
 
489
        if (werror) {
 
490
                *werror = r.out.result;
 
491
        }
 
492
 
 
493
        return werror_to_ntstatus(r.out.result);
 
494
}
 
495
 
 
496
NTSTATUS rpccli_winreg_EnumValue(struct rpc_pipe_client *cli,
 
497
                                 TALLOC_CTX *mem_ctx,
 
498
                                 struct policy_handle *handle /* [in] [ref] */,
 
499
                                 uint32_t enum_index /* [in]  */,
 
500
                                 struct winreg_ValNameBuf *name /* [in,out] [ref] */,
 
501
                                 enum winreg_Type *type /* [in,out] [unique] */,
 
502
                                 uint8_t *value /* [in,out] [unique,length_is(*length),size_is(*size)] */,
 
503
                                 uint32_t *size /* [in,out] [unique] */,
 
504
                                 uint32_t *length /* [in,out] [unique] */,
 
505
                                 WERROR *werror)
 
506
{
 
507
        struct winreg_EnumValue r;
 
508
        NTSTATUS status;
 
509
 
 
510
        /* In parameters */
 
511
        r.in.handle = handle;
 
512
        r.in.enum_index = enum_index;
 
513
        r.in.name = name;
 
514
        r.in.type = type;
 
515
        r.in.value = value;
 
516
        r.in.size = size;
 
517
        r.in.length = length;
 
518
 
 
519
        if (DEBUGLEVEL >= 10) {
 
520
                NDR_PRINT_IN_DEBUG(winreg_EnumValue, &r);
 
521
        }
 
522
 
 
523
        status = cli->dispatch(cli,
 
524
                                mem_ctx,
 
525
                                &ndr_table_winreg,
 
526
                                NDR_WINREG_ENUMVALUE,
 
527
                                &r);
 
528
 
 
529
        if (!NT_STATUS_IS_OK(status)) {
 
530
                return status;
 
531
        }
 
532
 
 
533
        if (DEBUGLEVEL >= 10) {
 
534
                NDR_PRINT_OUT_DEBUG(winreg_EnumValue, &r);
 
535
        }
 
536
 
 
537
        if (NT_STATUS_IS_ERR(status)) {
 
538
                return status;
 
539
        }
 
540
 
 
541
        /* Return variables */
 
542
        *name = *r.out.name;
 
543
        if (type && r.out.type) {
 
544
                *type = *r.out.type;
 
545
        }
 
546
        if (value && r.out.value) {
 
547
                memcpy(value, r.out.value, (*r.in.size) * sizeof(*value));
 
548
        }
 
549
        if (size && r.out.size) {
 
550
                *size = *r.out.size;
 
551
        }
 
552
        if (length && r.out.length) {
 
553
                *length = *r.out.length;
 
554
        }
 
555
 
 
556
        /* Return result */
 
557
        if (werror) {
 
558
                *werror = r.out.result;
 
559
        }
 
560
 
 
561
        return werror_to_ntstatus(r.out.result);
 
562
}
 
563
 
 
564
NTSTATUS rpccli_winreg_FlushKey(struct rpc_pipe_client *cli,
 
565
                                TALLOC_CTX *mem_ctx,
 
566
                                struct policy_handle *handle /* [in] [ref] */,
 
567
                                WERROR *werror)
 
568
{
 
569
        struct winreg_FlushKey r;
 
570
        NTSTATUS status;
 
571
 
 
572
        /* In parameters */
 
573
        r.in.handle = handle;
 
574
 
 
575
        if (DEBUGLEVEL >= 10) {
 
576
                NDR_PRINT_IN_DEBUG(winreg_FlushKey, &r);
 
577
        }
 
578
 
 
579
        status = cli->dispatch(cli,
 
580
                                mem_ctx,
 
581
                                &ndr_table_winreg,
 
582
                                NDR_WINREG_FLUSHKEY,
 
583
                                &r);
 
584
 
 
585
        if (!NT_STATUS_IS_OK(status)) {
 
586
                return status;
 
587
        }
 
588
 
 
589
        if (DEBUGLEVEL >= 10) {
 
590
                NDR_PRINT_OUT_DEBUG(winreg_FlushKey, &r);
 
591
        }
 
592
 
 
593
        if (NT_STATUS_IS_ERR(status)) {
 
594
                return status;
 
595
        }
 
596
 
 
597
        /* Return variables */
 
598
 
 
599
        /* Return result */
 
600
        if (werror) {
 
601
                *werror = r.out.result;
 
602
        }
 
603
 
 
604
        return werror_to_ntstatus(r.out.result);
 
605
}
 
606
 
 
607
NTSTATUS rpccli_winreg_GetKeySecurity(struct rpc_pipe_client *cli,
 
608
                                      TALLOC_CTX *mem_ctx,
 
609
                                      struct policy_handle *handle /* [in] [ref] */,
 
610
                                      uint32_t sec_info /* [in]  */,
 
611
                                      struct KeySecurityData *sd /* [in,out] [ref] */,
 
612
                                      WERROR *werror)
 
613
{
 
614
        struct winreg_GetKeySecurity r;
 
615
        NTSTATUS status;
 
616
 
 
617
        /* In parameters */
 
618
        r.in.handle = handle;
 
619
        r.in.sec_info = sec_info;
 
620
        r.in.sd = sd;
 
621
 
 
622
        if (DEBUGLEVEL >= 10) {
 
623
                NDR_PRINT_IN_DEBUG(winreg_GetKeySecurity, &r);
 
624
        }
 
625
 
 
626
        status = cli->dispatch(cli,
 
627
                                mem_ctx,
 
628
                                &ndr_table_winreg,
 
629
                                NDR_WINREG_GETKEYSECURITY,
 
630
                                &r);
 
631
 
 
632
        if (!NT_STATUS_IS_OK(status)) {
 
633
                return status;
 
634
        }
 
635
 
 
636
        if (DEBUGLEVEL >= 10) {
 
637
                NDR_PRINT_OUT_DEBUG(winreg_GetKeySecurity, &r);
 
638
        }
 
639
 
 
640
        if (NT_STATUS_IS_ERR(status)) {
 
641
                return status;
 
642
        }
 
643
 
 
644
        /* Return variables */
 
645
        *sd = *r.out.sd;
 
646
 
 
647
        /* Return result */
 
648
        if (werror) {
 
649
                *werror = r.out.result;
 
650
        }
 
651
 
 
652
        return werror_to_ntstatus(r.out.result);
 
653
}
 
654
 
 
655
NTSTATUS rpccli_winreg_LoadKey(struct rpc_pipe_client *cli,
 
656
                               TALLOC_CTX *mem_ctx,
 
657
                               struct policy_handle *handle /* [in] [ref] */,
 
658
                               struct winreg_String *keyname /* [in] [unique] */,
 
659
                               struct winreg_String *filename /* [in] [unique] */,
 
660
                               WERROR *werror)
 
661
{
 
662
        struct winreg_LoadKey r;
 
663
        NTSTATUS status;
 
664
 
 
665
        /* In parameters */
 
666
        r.in.handle = handle;
 
667
        r.in.keyname = keyname;
 
668
        r.in.filename = filename;
 
669
 
 
670
        if (DEBUGLEVEL >= 10) {
 
671
                NDR_PRINT_IN_DEBUG(winreg_LoadKey, &r);
 
672
        }
 
673
 
 
674
        status = cli->dispatch(cli,
 
675
                                mem_ctx,
 
676
                                &ndr_table_winreg,
 
677
                                NDR_WINREG_LOADKEY,
 
678
                                &r);
 
679
 
 
680
        if (!NT_STATUS_IS_OK(status)) {
 
681
                return status;
 
682
        }
 
683
 
 
684
        if (DEBUGLEVEL >= 10) {
 
685
                NDR_PRINT_OUT_DEBUG(winreg_LoadKey, &r);
 
686
        }
 
687
 
 
688
        if (NT_STATUS_IS_ERR(status)) {
 
689
                return status;
 
690
        }
 
691
 
 
692
        /* Return variables */
 
693
 
 
694
        /* Return result */
 
695
        if (werror) {
 
696
                *werror = r.out.result;
 
697
        }
 
698
 
 
699
        return werror_to_ntstatus(r.out.result);
 
700
}
 
701
 
 
702
NTSTATUS rpccli_winreg_NotifyChangeKeyValue(struct rpc_pipe_client *cli,
 
703
                                            TALLOC_CTX *mem_ctx,
 
704
                                            struct policy_handle *handle /* [in] [ref] */,
 
705
                                            uint8_t watch_subtree /* [in]  */,
 
706
                                            uint32_t notify_filter /* [in]  */,
 
707
                                            uint32_t unknown /* [in]  */,
 
708
                                            struct winreg_String string1 /* [in]  */,
 
709
                                            struct winreg_String string2 /* [in]  */,
 
710
                                            uint32_t unknown2 /* [in]  */,
 
711
                                            WERROR *werror)
 
712
{
 
713
        struct winreg_NotifyChangeKeyValue r;
 
714
        NTSTATUS status;
 
715
 
 
716
        /* In parameters */
 
717
        r.in.handle = handle;
 
718
        r.in.watch_subtree = watch_subtree;
 
719
        r.in.notify_filter = notify_filter;
 
720
        r.in.unknown = unknown;
 
721
        r.in.string1 = string1;
 
722
        r.in.string2 = string2;
 
723
        r.in.unknown2 = unknown2;
 
724
 
 
725
        if (DEBUGLEVEL >= 10) {
 
726
                NDR_PRINT_IN_DEBUG(winreg_NotifyChangeKeyValue, &r);
 
727
        }
 
728
 
 
729
        status = cli->dispatch(cli,
 
730
                                mem_ctx,
 
731
                                &ndr_table_winreg,
 
732
                                NDR_WINREG_NOTIFYCHANGEKEYVALUE,
 
733
                                &r);
 
734
 
 
735
        if (!NT_STATUS_IS_OK(status)) {
 
736
                return status;
 
737
        }
 
738
 
 
739
        if (DEBUGLEVEL >= 10) {
 
740
                NDR_PRINT_OUT_DEBUG(winreg_NotifyChangeKeyValue, &r);
 
741
        }
 
742
 
 
743
        if (NT_STATUS_IS_ERR(status)) {
 
744
                return status;
 
745
        }
 
746
 
 
747
        /* Return variables */
 
748
 
 
749
        /* Return result */
 
750
        if (werror) {
 
751
                *werror = r.out.result;
 
752
        }
 
753
 
 
754
        return werror_to_ntstatus(r.out.result);
 
755
}
 
756
 
 
757
NTSTATUS rpccli_winreg_OpenKey(struct rpc_pipe_client *cli,
 
758
                               TALLOC_CTX *mem_ctx,
 
759
                               struct policy_handle *parent_handle /* [in] [ref] */,
 
760
                               struct winreg_String keyname /* [in]  */,
 
761
                               uint32_t unknown /* [in]  */,
 
762
                               uint32_t access_mask /* [in]  */,
 
763
                               struct policy_handle *handle /* [out] [ref] */,
 
764
                               WERROR *werror)
 
765
{
 
766
        struct winreg_OpenKey r;
 
767
        NTSTATUS status;
 
768
 
 
769
        /* In parameters */
 
770
        r.in.parent_handle = parent_handle;
 
771
        r.in.keyname = keyname;
 
772
        r.in.unknown = unknown;
 
773
        r.in.access_mask = access_mask;
 
774
 
 
775
        if (DEBUGLEVEL >= 10) {
 
776
                NDR_PRINT_IN_DEBUG(winreg_OpenKey, &r);
 
777
        }
 
778
 
 
779
        status = cli->dispatch(cli,
 
780
                                mem_ctx,
 
781
                                &ndr_table_winreg,
 
782
                                NDR_WINREG_OPENKEY,
 
783
                                &r);
 
784
 
 
785
        if (!NT_STATUS_IS_OK(status)) {
 
786
                return status;
 
787
        }
 
788
 
 
789
        if (DEBUGLEVEL >= 10) {
 
790
                NDR_PRINT_OUT_DEBUG(winreg_OpenKey, &r);
 
791
        }
 
792
 
 
793
        if (NT_STATUS_IS_ERR(status)) {
 
794
                return status;
 
795
        }
 
796
 
 
797
        /* Return variables */
 
798
        *handle = *r.out.handle;
 
799
 
 
800
        /* Return result */
 
801
        if (werror) {
 
802
                *werror = r.out.result;
 
803
        }
 
804
 
 
805
        return werror_to_ntstatus(r.out.result);
 
806
}
 
807
 
 
808
NTSTATUS rpccli_winreg_QueryInfoKey(struct rpc_pipe_client *cli,
 
809
                                    TALLOC_CTX *mem_ctx,
 
810
                                    struct policy_handle *handle /* [in] [ref] */,
 
811
                                    struct winreg_String *classname /* [in,out] [ref] */,
 
812
                                    uint32_t *num_subkeys /* [out] [ref] */,
 
813
                                    uint32_t *max_subkeylen /* [out] [ref] */,
 
814
                                    uint32_t *max_classlen /* [out] [ref] */,
 
815
                                    uint32_t *num_values /* [out] [ref] */,
 
816
                                    uint32_t *max_valnamelen /* [out] [ref] */,
 
817
                                    uint32_t *max_valbufsize /* [out] [ref] */,
 
818
                                    uint32_t *secdescsize /* [out] [ref] */,
 
819
                                    NTTIME *last_changed_time /* [out] [ref] */,
 
820
                                    WERROR *werror)
 
821
{
 
822
        struct winreg_QueryInfoKey r;
 
823
        NTSTATUS status;
 
824
 
 
825
        /* In parameters */
 
826
        r.in.handle = handle;
 
827
        r.in.classname = classname;
 
828
 
 
829
        if (DEBUGLEVEL >= 10) {
 
830
                NDR_PRINT_IN_DEBUG(winreg_QueryInfoKey, &r);
 
831
        }
 
832
 
 
833
        status = cli->dispatch(cli,
 
834
                                mem_ctx,
 
835
                                &ndr_table_winreg,
 
836
                                NDR_WINREG_QUERYINFOKEY,
 
837
                                &r);
 
838
 
 
839
        if (!NT_STATUS_IS_OK(status)) {
 
840
                return status;
 
841
        }
 
842
 
 
843
        if (DEBUGLEVEL >= 10) {
 
844
                NDR_PRINT_OUT_DEBUG(winreg_QueryInfoKey, &r);
 
845
        }
 
846
 
 
847
        if (NT_STATUS_IS_ERR(status)) {
 
848
                return status;
 
849
        }
 
850
 
 
851
        /* Return variables */
 
852
        *classname = *r.out.classname;
 
853
        *num_subkeys = *r.out.num_subkeys;
 
854
        *max_subkeylen = *r.out.max_subkeylen;
 
855
        *max_classlen = *r.out.max_classlen;
 
856
        *num_values = *r.out.num_values;
 
857
        *max_valnamelen = *r.out.max_valnamelen;
 
858
        *max_valbufsize = *r.out.max_valbufsize;
 
859
        *secdescsize = *r.out.secdescsize;
 
860
        *last_changed_time = *r.out.last_changed_time;
 
861
 
 
862
        /* Return result */
 
863
        if (werror) {
 
864
                *werror = r.out.result;
 
865
        }
 
866
 
 
867
        return werror_to_ntstatus(r.out.result);
 
868
}
 
869
 
 
870
NTSTATUS rpccli_winreg_QueryValue(struct rpc_pipe_client *cli,
 
871
                                  TALLOC_CTX *mem_ctx,
 
872
                                  struct policy_handle *handle /* [in] [ref] */,
 
873
                                  struct winreg_String *value_name /* [in] [ref] */,
 
874
                                  enum winreg_Type *type /* [in,out] [unique] */,
 
875
                                  uint8_t *data /* [in,out] [unique,length_is(*data_length),size_is(*data_size)] */,
 
876
                                  uint32_t *data_size /* [in,out] [unique] */,
 
877
                                  uint32_t *data_length /* [in,out] [unique] */,
 
878
                                  WERROR *werror)
 
879
{
 
880
        struct winreg_QueryValue r;
 
881
        NTSTATUS status;
 
882
 
 
883
        /* In parameters */
 
884
        r.in.handle = handle;
 
885
        r.in.value_name = value_name;
 
886
        r.in.type = type;
 
887
        r.in.data = data;
 
888
        r.in.data_size = data_size;
 
889
        r.in.data_length = data_length;
 
890
 
 
891
        if (DEBUGLEVEL >= 10) {
 
892
                NDR_PRINT_IN_DEBUG(winreg_QueryValue, &r);
 
893
        }
 
894
 
 
895
        status = cli->dispatch(cli,
 
896
                                mem_ctx,
 
897
                                &ndr_table_winreg,
 
898
                                NDR_WINREG_QUERYVALUE,
 
899
                                &r);
 
900
 
 
901
        if (!NT_STATUS_IS_OK(status)) {
 
902
                return status;
 
903
        }
 
904
 
 
905
        if (DEBUGLEVEL >= 10) {
 
906
                NDR_PRINT_OUT_DEBUG(winreg_QueryValue, &r);
 
907
        }
 
908
 
 
909
        if (NT_STATUS_IS_ERR(status)) {
 
910
                return status;
 
911
        }
 
912
 
 
913
        /* Return variables */
 
914
        if (type && r.out.type) {
 
915
                *type = *r.out.type;
 
916
        }
 
917
        if (data && r.out.data) {
 
918
                memcpy(data, r.out.data, (*r.in.data_size) * sizeof(*data));
 
919
        }
 
920
        if (data_size && r.out.data_size) {
 
921
                *data_size = *r.out.data_size;
 
922
        }
 
923
        if (data_length && r.out.data_length) {
 
924
                *data_length = *r.out.data_length;
 
925
        }
 
926
 
 
927
        /* Return result */
 
928
        if (werror) {
 
929
                *werror = r.out.result;
 
930
        }
 
931
 
 
932
        return werror_to_ntstatus(r.out.result);
 
933
}
 
934
 
 
935
NTSTATUS rpccli_winreg_ReplaceKey(struct rpc_pipe_client *cli,
 
936
                                  TALLOC_CTX *mem_ctx,
 
937
                                  WERROR *werror)
 
938
{
 
939
        struct winreg_ReplaceKey r;
 
940
        NTSTATUS status;
 
941
 
 
942
        /* In parameters */
 
943
 
 
944
        if (DEBUGLEVEL >= 10) {
 
945
                NDR_PRINT_IN_DEBUG(winreg_ReplaceKey, &r);
 
946
        }
 
947
 
 
948
        status = cli->dispatch(cli,
 
949
                                mem_ctx,
 
950
                                &ndr_table_winreg,
 
951
                                NDR_WINREG_REPLACEKEY,
 
952
                                &r);
 
953
 
 
954
        if (!NT_STATUS_IS_OK(status)) {
 
955
                return status;
 
956
        }
 
957
 
 
958
        if (DEBUGLEVEL >= 10) {
 
959
                NDR_PRINT_OUT_DEBUG(winreg_ReplaceKey, &r);
 
960
        }
 
961
 
 
962
        if (NT_STATUS_IS_ERR(status)) {
 
963
                return status;
 
964
        }
 
965
 
 
966
        /* Return variables */
 
967
 
 
968
        /* Return result */
 
969
        if (werror) {
 
970
                *werror = r.out.result;
 
971
        }
 
972
 
 
973
        return werror_to_ntstatus(r.out.result);
 
974
}
 
975
 
 
976
NTSTATUS rpccli_winreg_RestoreKey(struct rpc_pipe_client *cli,
 
977
                                  TALLOC_CTX *mem_ctx,
 
978
                                  struct policy_handle *handle /* [in] [ref] */,
 
979
                                  struct winreg_String *filename /* [in] [ref] */,
 
980
                                  uint32_t flags /* [in]  */,
 
981
                                  WERROR *werror)
 
982
{
 
983
        struct winreg_RestoreKey r;
 
984
        NTSTATUS status;
 
985
 
 
986
        /* In parameters */
 
987
        r.in.handle = handle;
 
988
        r.in.filename = filename;
 
989
        r.in.flags = flags;
 
990
 
 
991
        if (DEBUGLEVEL >= 10) {
 
992
                NDR_PRINT_IN_DEBUG(winreg_RestoreKey, &r);
 
993
        }
 
994
 
 
995
        status = cli->dispatch(cli,
 
996
                                mem_ctx,
 
997
                                &ndr_table_winreg,
 
998
                                NDR_WINREG_RESTOREKEY,
 
999
                                &r);
 
1000
 
 
1001
        if (!NT_STATUS_IS_OK(status)) {
 
1002
                return status;
 
1003
        }
 
1004
 
 
1005
        if (DEBUGLEVEL >= 10) {
 
1006
                NDR_PRINT_OUT_DEBUG(winreg_RestoreKey, &r);
 
1007
        }
 
1008
 
 
1009
        if (NT_STATUS_IS_ERR(status)) {
 
1010
                return status;
 
1011
        }
 
1012
 
 
1013
        /* Return variables */
 
1014
 
 
1015
        /* Return result */
 
1016
        if (werror) {
 
1017
                *werror = r.out.result;
 
1018
        }
 
1019
 
 
1020
        return werror_to_ntstatus(r.out.result);
 
1021
}
 
1022
 
 
1023
NTSTATUS rpccli_winreg_SaveKey(struct rpc_pipe_client *cli,
 
1024
                               TALLOC_CTX *mem_ctx,
 
1025
                               struct policy_handle *handle /* [in] [ref] */,
 
1026
                               struct winreg_String *filename /* [in] [ref] */,
 
1027
                               struct KeySecurityAttribute *sec_attrib /* [in] [unique] */,
 
1028
                               WERROR *werror)
 
1029
{
 
1030
        struct winreg_SaveKey r;
 
1031
        NTSTATUS status;
 
1032
 
 
1033
        /* In parameters */
 
1034
        r.in.handle = handle;
 
1035
        r.in.filename = filename;
 
1036
        r.in.sec_attrib = sec_attrib;
 
1037
 
 
1038
        if (DEBUGLEVEL >= 10) {
 
1039
                NDR_PRINT_IN_DEBUG(winreg_SaveKey, &r);
 
1040
        }
 
1041
 
 
1042
        status = cli->dispatch(cli,
 
1043
                                mem_ctx,
 
1044
                                &ndr_table_winreg,
 
1045
                                NDR_WINREG_SAVEKEY,
 
1046
                                &r);
 
1047
 
 
1048
        if (!NT_STATUS_IS_OK(status)) {
 
1049
                return status;
 
1050
        }
 
1051
 
 
1052
        if (DEBUGLEVEL >= 10) {
 
1053
                NDR_PRINT_OUT_DEBUG(winreg_SaveKey, &r);
 
1054
        }
 
1055
 
 
1056
        if (NT_STATUS_IS_ERR(status)) {
 
1057
                return status;
 
1058
        }
 
1059
 
 
1060
        /* Return variables */
 
1061
 
 
1062
        /* Return result */
 
1063
        if (werror) {
 
1064
                *werror = r.out.result;
 
1065
        }
 
1066
 
 
1067
        return werror_to_ntstatus(r.out.result);
 
1068
}
 
1069
 
 
1070
NTSTATUS rpccli_winreg_SetKeySecurity(struct rpc_pipe_client *cli,
 
1071
                                      TALLOC_CTX *mem_ctx,
 
1072
                                      struct policy_handle *handle /* [in] [ref] */,
 
1073
                                      uint32_t sec_info /* [in]  */,
 
1074
                                      struct KeySecurityData *sd /* [in] [ref] */,
 
1075
                                      WERROR *werror)
 
1076
{
 
1077
        struct winreg_SetKeySecurity r;
 
1078
        NTSTATUS status;
 
1079
 
 
1080
        /* In parameters */
 
1081
        r.in.handle = handle;
 
1082
        r.in.sec_info = sec_info;
 
1083
        r.in.sd = sd;
 
1084
 
 
1085
        if (DEBUGLEVEL >= 10) {
 
1086
                NDR_PRINT_IN_DEBUG(winreg_SetKeySecurity, &r);
 
1087
        }
 
1088
 
 
1089
        status = cli->dispatch(cli,
 
1090
                                mem_ctx,
 
1091
                                &ndr_table_winreg,
 
1092
                                NDR_WINREG_SETKEYSECURITY,
 
1093
                                &r);
 
1094
 
 
1095
        if (!NT_STATUS_IS_OK(status)) {
 
1096
                return status;
 
1097
        }
 
1098
 
 
1099
        if (DEBUGLEVEL >= 10) {
 
1100
                NDR_PRINT_OUT_DEBUG(winreg_SetKeySecurity, &r);
 
1101
        }
 
1102
 
 
1103
        if (NT_STATUS_IS_ERR(status)) {
 
1104
                return status;
 
1105
        }
 
1106
 
 
1107
        /* Return variables */
 
1108
 
 
1109
        /* Return result */
 
1110
        if (werror) {
 
1111
                *werror = r.out.result;
 
1112
        }
 
1113
 
 
1114
        return werror_to_ntstatus(r.out.result);
 
1115
}
 
1116
 
 
1117
NTSTATUS rpccli_winreg_SetValue(struct rpc_pipe_client *cli,
 
1118
                                TALLOC_CTX *mem_ctx,
 
1119
                                struct policy_handle *handle /* [in] [ref] */,
 
1120
                                struct winreg_String name /* [in]  */,
 
1121
                                enum winreg_Type type /* [in]  */,
 
1122
                                uint8_t *data /* [in] [ref,size_is(size)] */,
 
1123
                                uint32_t size /* [in]  */,
 
1124
                                WERROR *werror)
 
1125
{
 
1126
        struct winreg_SetValue r;
 
1127
        NTSTATUS status;
 
1128
 
 
1129
        /* In parameters */
 
1130
        r.in.handle = handle;
 
1131
        r.in.name = name;
 
1132
        r.in.type = type;
 
1133
        r.in.data = data;
 
1134
        r.in.size = size;
 
1135
 
 
1136
        if (DEBUGLEVEL >= 10) {
 
1137
                NDR_PRINT_IN_DEBUG(winreg_SetValue, &r);
 
1138
        }
 
1139
 
 
1140
        status = cli->dispatch(cli,
 
1141
                                mem_ctx,
 
1142
                                &ndr_table_winreg,
 
1143
                                NDR_WINREG_SETVALUE,
 
1144
                                &r);
 
1145
 
 
1146
        if (!NT_STATUS_IS_OK(status)) {
 
1147
                return status;
 
1148
        }
 
1149
 
 
1150
        if (DEBUGLEVEL >= 10) {
 
1151
                NDR_PRINT_OUT_DEBUG(winreg_SetValue, &r);
 
1152
        }
 
1153
 
 
1154
        if (NT_STATUS_IS_ERR(status)) {
 
1155
                return status;
 
1156
        }
 
1157
 
 
1158
        /* Return variables */
 
1159
 
 
1160
        /* Return result */
 
1161
        if (werror) {
 
1162
                *werror = r.out.result;
 
1163
        }
 
1164
 
 
1165
        return werror_to_ntstatus(r.out.result);
 
1166
}
 
1167
 
 
1168
NTSTATUS rpccli_winreg_UnLoadKey(struct rpc_pipe_client *cli,
 
1169
                                 TALLOC_CTX *mem_ctx,
 
1170
                                 WERROR *werror)
 
1171
{
 
1172
        struct winreg_UnLoadKey r;
 
1173
        NTSTATUS status;
 
1174
 
 
1175
        /* In parameters */
 
1176
 
 
1177
        if (DEBUGLEVEL >= 10) {
 
1178
                NDR_PRINT_IN_DEBUG(winreg_UnLoadKey, &r);
 
1179
        }
 
1180
 
 
1181
        status = cli->dispatch(cli,
 
1182
                                mem_ctx,
 
1183
                                &ndr_table_winreg,
 
1184
                                NDR_WINREG_UNLOADKEY,
 
1185
                                &r);
 
1186
 
 
1187
        if (!NT_STATUS_IS_OK(status)) {
 
1188
                return status;
 
1189
        }
 
1190
 
 
1191
        if (DEBUGLEVEL >= 10) {
 
1192
                NDR_PRINT_OUT_DEBUG(winreg_UnLoadKey, &r);
 
1193
        }
 
1194
 
 
1195
        if (NT_STATUS_IS_ERR(status)) {
 
1196
                return status;
 
1197
        }
 
1198
 
 
1199
        /* Return variables */
 
1200
 
 
1201
        /* Return result */
 
1202
        if (werror) {
 
1203
                *werror = r.out.result;
 
1204
        }
 
1205
 
 
1206
        return werror_to_ntstatus(r.out.result);
 
1207
}
 
1208
 
 
1209
NTSTATUS rpccli_winreg_InitiateSystemShutdown(struct rpc_pipe_client *cli,
 
1210
                                              TALLOC_CTX *mem_ctx,
 
1211
                                              uint16_t *hostname /* [in] [unique] */,
 
1212
                                              struct lsa_StringLarge *message /* [in] [unique] */,
 
1213
                                              uint32_t timeout /* [in]  */,
 
1214
                                              uint8_t force_apps /* [in]  */,
 
1215
                                              uint8_t do_reboot /* [in]  */,
 
1216
                                              WERROR *werror)
 
1217
{
 
1218
        struct winreg_InitiateSystemShutdown r;
 
1219
        NTSTATUS status;
 
1220
 
 
1221
        /* In parameters */
 
1222
        r.in.hostname = hostname;
 
1223
        r.in.message = message;
 
1224
        r.in.timeout = timeout;
 
1225
        r.in.force_apps = force_apps;
 
1226
        r.in.do_reboot = do_reboot;
 
1227
 
 
1228
        if (DEBUGLEVEL >= 10) {
 
1229
                NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdown, &r);
 
1230
        }
 
1231
 
 
1232
        status = cli->dispatch(cli,
 
1233
                                mem_ctx,
 
1234
                                &ndr_table_winreg,
 
1235
                                NDR_WINREG_INITIATESYSTEMSHUTDOWN,
 
1236
                                &r);
 
1237
 
 
1238
        if (!NT_STATUS_IS_OK(status)) {
 
1239
                return status;
 
1240
        }
 
1241
 
 
1242
        if (DEBUGLEVEL >= 10) {
 
1243
                NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdown, &r);
 
1244
        }
 
1245
 
 
1246
        if (NT_STATUS_IS_ERR(status)) {
 
1247
                return status;
 
1248
        }
 
1249
 
 
1250
        /* Return variables */
 
1251
 
 
1252
        /* Return result */
 
1253
        if (werror) {
 
1254
                *werror = r.out.result;
 
1255
        }
 
1256
 
 
1257
        return werror_to_ntstatus(r.out.result);
 
1258
}
 
1259
 
 
1260
NTSTATUS rpccli_winreg_AbortSystemShutdown(struct rpc_pipe_client *cli,
 
1261
                                           TALLOC_CTX *mem_ctx,
 
1262
                                           uint16_t *server /* [in] [unique] */,
 
1263
                                           WERROR *werror)
 
1264
{
 
1265
        struct winreg_AbortSystemShutdown r;
 
1266
        NTSTATUS status;
 
1267
 
 
1268
        /* In parameters */
 
1269
        r.in.server = server;
 
1270
 
 
1271
        if (DEBUGLEVEL >= 10) {
 
1272
                NDR_PRINT_IN_DEBUG(winreg_AbortSystemShutdown, &r);
 
1273
        }
 
1274
 
 
1275
        status = cli->dispatch(cli,
 
1276
                                mem_ctx,
 
1277
                                &ndr_table_winreg,
 
1278
                                NDR_WINREG_ABORTSYSTEMSHUTDOWN,
 
1279
                                &r);
 
1280
 
 
1281
        if (!NT_STATUS_IS_OK(status)) {
 
1282
                return status;
 
1283
        }
 
1284
 
 
1285
        if (DEBUGLEVEL >= 10) {
 
1286
                NDR_PRINT_OUT_DEBUG(winreg_AbortSystemShutdown, &r);
 
1287
        }
 
1288
 
 
1289
        if (NT_STATUS_IS_ERR(status)) {
 
1290
                return status;
 
1291
        }
 
1292
 
 
1293
        /* Return variables */
 
1294
 
 
1295
        /* Return result */
 
1296
        if (werror) {
 
1297
                *werror = r.out.result;
 
1298
        }
 
1299
 
 
1300
        return werror_to_ntstatus(r.out.result);
 
1301
}
 
1302
 
 
1303
NTSTATUS rpccli_winreg_GetVersion(struct rpc_pipe_client *cli,
 
1304
                                  TALLOC_CTX *mem_ctx,
 
1305
                                  struct policy_handle *handle /* [in] [ref] */,
 
1306
                                  uint32_t *version /* [out] [ref] */,
 
1307
                                  WERROR *werror)
 
1308
{
 
1309
        struct winreg_GetVersion r;
 
1310
        NTSTATUS status;
 
1311
 
 
1312
        /* In parameters */
 
1313
        r.in.handle = handle;
 
1314
 
 
1315
        if (DEBUGLEVEL >= 10) {
 
1316
                NDR_PRINT_IN_DEBUG(winreg_GetVersion, &r);
 
1317
        }
 
1318
 
 
1319
        status = cli->dispatch(cli,
 
1320
                                mem_ctx,
 
1321
                                &ndr_table_winreg,
 
1322
                                NDR_WINREG_GETVERSION,
 
1323
                                &r);
 
1324
 
 
1325
        if (!NT_STATUS_IS_OK(status)) {
 
1326
                return status;
 
1327
        }
 
1328
 
 
1329
        if (DEBUGLEVEL >= 10) {
 
1330
                NDR_PRINT_OUT_DEBUG(winreg_GetVersion, &r);
 
1331
        }
 
1332
 
 
1333
        if (NT_STATUS_IS_ERR(status)) {
 
1334
                return status;
 
1335
        }
 
1336
 
 
1337
        /* Return variables */
 
1338
        *version = *r.out.version;
 
1339
 
 
1340
        /* Return result */
 
1341
        if (werror) {
 
1342
                *werror = r.out.result;
 
1343
        }
 
1344
 
 
1345
        return werror_to_ntstatus(r.out.result);
 
1346
}
 
1347
 
 
1348
NTSTATUS rpccli_winreg_OpenHKCC(struct rpc_pipe_client *cli,
 
1349
                                TALLOC_CTX *mem_ctx,
 
1350
                                uint16_t *system_name /* [in] [unique] */,
 
1351
                                uint32_t access_mask /* [in]  */,
 
1352
                                struct policy_handle *handle /* [out] [ref] */,
 
1353
                                WERROR *werror)
 
1354
{
 
1355
        struct winreg_OpenHKCC r;
 
1356
        NTSTATUS status;
 
1357
 
 
1358
        /* In parameters */
 
1359
        r.in.system_name = system_name;
 
1360
        r.in.access_mask = access_mask;
 
1361
 
 
1362
        if (DEBUGLEVEL >= 10) {
 
1363
                NDR_PRINT_IN_DEBUG(winreg_OpenHKCC, &r);
 
1364
        }
 
1365
 
 
1366
        status = cli->dispatch(cli,
 
1367
                                mem_ctx,
 
1368
                                &ndr_table_winreg,
 
1369
                                NDR_WINREG_OPENHKCC,
 
1370
                                &r);
 
1371
 
 
1372
        if (!NT_STATUS_IS_OK(status)) {
 
1373
                return status;
 
1374
        }
 
1375
 
 
1376
        if (DEBUGLEVEL >= 10) {
 
1377
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKCC, &r);
 
1378
        }
 
1379
 
 
1380
        if (NT_STATUS_IS_ERR(status)) {
 
1381
                return status;
 
1382
        }
 
1383
 
 
1384
        /* Return variables */
 
1385
        *handle = *r.out.handle;
 
1386
 
 
1387
        /* Return result */
 
1388
        if (werror) {
 
1389
                *werror = r.out.result;
 
1390
        }
 
1391
 
 
1392
        return werror_to_ntstatus(r.out.result);
 
1393
}
 
1394
 
 
1395
NTSTATUS rpccli_winreg_OpenHKDD(struct rpc_pipe_client *cli,
 
1396
                                TALLOC_CTX *mem_ctx,
 
1397
                                uint16_t *system_name /* [in] [unique] */,
 
1398
                                uint32_t access_mask /* [in]  */,
 
1399
                                struct policy_handle *handle /* [out] [ref] */,
 
1400
                                WERROR *werror)
 
1401
{
 
1402
        struct winreg_OpenHKDD r;
 
1403
        NTSTATUS status;
 
1404
 
 
1405
        /* In parameters */
 
1406
        r.in.system_name = system_name;
 
1407
        r.in.access_mask = access_mask;
 
1408
 
 
1409
        if (DEBUGLEVEL >= 10) {
 
1410
                NDR_PRINT_IN_DEBUG(winreg_OpenHKDD, &r);
 
1411
        }
 
1412
 
 
1413
        status = cli->dispatch(cli,
 
1414
                                mem_ctx,
 
1415
                                &ndr_table_winreg,
 
1416
                                NDR_WINREG_OPENHKDD,
 
1417
                                &r);
 
1418
 
 
1419
        if (!NT_STATUS_IS_OK(status)) {
 
1420
                return status;
 
1421
        }
 
1422
 
 
1423
        if (DEBUGLEVEL >= 10) {
 
1424
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKDD, &r);
 
1425
        }
 
1426
 
 
1427
        if (NT_STATUS_IS_ERR(status)) {
 
1428
                return status;
 
1429
        }
 
1430
 
 
1431
        /* Return variables */
 
1432
        *handle = *r.out.handle;
 
1433
 
 
1434
        /* Return result */
 
1435
        if (werror) {
 
1436
                *werror = r.out.result;
 
1437
        }
 
1438
 
 
1439
        return werror_to_ntstatus(r.out.result);
 
1440
}
 
1441
 
 
1442
NTSTATUS rpccli_winreg_QueryMultipleValues(struct rpc_pipe_client *cli,
 
1443
                                           TALLOC_CTX *mem_ctx,
 
1444
                                           struct policy_handle *key_handle /* [in] [ref] */,
 
1445
                                           struct QueryMultipleValue *values /* [in,out] [ref,length_is(num_values),size_is(num_values)] */,
 
1446
                                           uint32_t num_values /* [in]  */,
 
1447
                                           uint8_t *buffer /* [in,out] [unique,length_is(*buffer_size),size_is(*buffer_size)] */,
 
1448
                                           uint32_t *buffer_size /* [in,out] [ref] */,
 
1449
                                           WERROR *werror)
 
1450
{
 
1451
        struct winreg_QueryMultipleValues r;
 
1452
        NTSTATUS status;
 
1453
 
 
1454
        /* In parameters */
 
1455
        r.in.key_handle = key_handle;
 
1456
        r.in.values = values;
 
1457
        r.in.num_values = num_values;
 
1458
        r.in.buffer = buffer;
 
1459
        r.in.buffer_size = buffer_size;
 
1460
 
 
1461
        if (DEBUGLEVEL >= 10) {
 
1462
                NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues, &r);
 
1463
        }
 
1464
 
 
1465
        status = cli->dispatch(cli,
 
1466
                                mem_ctx,
 
1467
                                &ndr_table_winreg,
 
1468
                                NDR_WINREG_QUERYMULTIPLEVALUES,
 
1469
                                &r);
 
1470
 
 
1471
        if (!NT_STATUS_IS_OK(status)) {
 
1472
                return status;
 
1473
        }
 
1474
 
 
1475
        if (DEBUGLEVEL >= 10) {
 
1476
                NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues, &r);
 
1477
        }
 
1478
 
 
1479
        if (NT_STATUS_IS_ERR(status)) {
 
1480
                return status;
 
1481
        }
 
1482
 
 
1483
        /* Return variables */
 
1484
        memcpy(values, r.out.values, (r.in.num_values) * sizeof(*values));
 
1485
        if (buffer && r.out.buffer) {
 
1486
                memcpy(buffer, r.out.buffer, (*r.in.buffer_size) * sizeof(*buffer));
 
1487
        }
 
1488
        *buffer_size = *r.out.buffer_size;
 
1489
 
 
1490
        /* Return result */
 
1491
        if (werror) {
 
1492
                *werror = r.out.result;
 
1493
        }
 
1494
 
 
1495
        return werror_to_ntstatus(r.out.result);
 
1496
}
 
1497
 
 
1498
NTSTATUS rpccli_winreg_InitiateSystemShutdownEx(struct rpc_pipe_client *cli,
 
1499
                                                TALLOC_CTX *mem_ctx,
 
1500
                                                uint16_t *hostname /* [in] [unique] */,
 
1501
                                                struct lsa_StringLarge *message /* [in] [unique] */,
 
1502
                                                uint32_t timeout /* [in]  */,
 
1503
                                                uint8_t force_apps /* [in]  */,
 
1504
                                                uint8_t do_reboot /* [in]  */,
 
1505
                                                uint32_t reason /* [in]  */,
 
1506
                                                WERROR *werror)
 
1507
{
 
1508
        struct winreg_InitiateSystemShutdownEx r;
 
1509
        NTSTATUS status;
 
1510
 
 
1511
        /* In parameters */
 
1512
        r.in.hostname = hostname;
 
1513
        r.in.message = message;
 
1514
        r.in.timeout = timeout;
 
1515
        r.in.force_apps = force_apps;
 
1516
        r.in.do_reboot = do_reboot;
 
1517
        r.in.reason = reason;
 
1518
 
 
1519
        if (DEBUGLEVEL >= 10) {
 
1520
                NDR_PRINT_IN_DEBUG(winreg_InitiateSystemShutdownEx, &r);
 
1521
        }
 
1522
 
 
1523
        status = cli->dispatch(cli,
 
1524
                                mem_ctx,
 
1525
                                &ndr_table_winreg,
 
1526
                                NDR_WINREG_INITIATESYSTEMSHUTDOWNEX,
 
1527
                                &r);
 
1528
 
 
1529
        if (!NT_STATUS_IS_OK(status)) {
 
1530
                return status;
 
1531
        }
 
1532
 
 
1533
        if (DEBUGLEVEL >= 10) {
 
1534
                NDR_PRINT_OUT_DEBUG(winreg_InitiateSystemShutdownEx, &r);
 
1535
        }
 
1536
 
 
1537
        if (NT_STATUS_IS_ERR(status)) {
 
1538
                return status;
 
1539
        }
 
1540
 
 
1541
        /* Return variables */
 
1542
 
 
1543
        /* Return result */
 
1544
        if (werror) {
 
1545
                *werror = r.out.result;
 
1546
        }
 
1547
 
 
1548
        return werror_to_ntstatus(r.out.result);
 
1549
}
 
1550
 
 
1551
NTSTATUS rpccli_winreg_SaveKeyEx(struct rpc_pipe_client *cli,
 
1552
                                 TALLOC_CTX *mem_ctx,
 
1553
                                 WERROR *werror)
 
1554
{
 
1555
        struct winreg_SaveKeyEx r;
 
1556
        NTSTATUS status;
 
1557
 
 
1558
        /* In parameters */
 
1559
 
 
1560
        if (DEBUGLEVEL >= 10) {
 
1561
                NDR_PRINT_IN_DEBUG(winreg_SaveKeyEx, &r);
 
1562
        }
 
1563
 
 
1564
        status = cli->dispatch(cli,
 
1565
                                mem_ctx,
 
1566
                                &ndr_table_winreg,
 
1567
                                NDR_WINREG_SAVEKEYEX,
 
1568
                                &r);
 
1569
 
 
1570
        if (!NT_STATUS_IS_OK(status)) {
 
1571
                return status;
 
1572
        }
 
1573
 
 
1574
        if (DEBUGLEVEL >= 10) {
 
1575
                NDR_PRINT_OUT_DEBUG(winreg_SaveKeyEx, &r);
 
1576
        }
 
1577
 
 
1578
        if (NT_STATUS_IS_ERR(status)) {
 
1579
                return status;
 
1580
        }
 
1581
 
 
1582
        /* Return variables */
 
1583
 
 
1584
        /* Return result */
 
1585
        if (werror) {
 
1586
                *werror = r.out.result;
 
1587
        }
 
1588
 
 
1589
        return werror_to_ntstatus(r.out.result);
 
1590
}
 
1591
 
 
1592
NTSTATUS rpccli_winreg_OpenHKPT(struct rpc_pipe_client *cli,
 
1593
                                TALLOC_CTX *mem_ctx,
 
1594
                                uint16_t *system_name /* [in] [unique] */,
 
1595
                                uint32_t access_mask /* [in]  */,
 
1596
                                struct policy_handle *handle /* [out] [ref] */,
 
1597
                                WERROR *werror)
 
1598
{
 
1599
        struct winreg_OpenHKPT r;
 
1600
        NTSTATUS status;
 
1601
 
 
1602
        /* In parameters */
 
1603
        r.in.system_name = system_name;
 
1604
        r.in.access_mask = access_mask;
 
1605
 
 
1606
        if (DEBUGLEVEL >= 10) {
 
1607
                NDR_PRINT_IN_DEBUG(winreg_OpenHKPT, &r);
 
1608
        }
 
1609
 
 
1610
        status = cli->dispatch(cli,
 
1611
                                mem_ctx,
 
1612
                                &ndr_table_winreg,
 
1613
                                NDR_WINREG_OPENHKPT,
 
1614
                                &r);
 
1615
 
 
1616
        if (!NT_STATUS_IS_OK(status)) {
 
1617
                return status;
 
1618
        }
 
1619
 
 
1620
        if (DEBUGLEVEL >= 10) {
 
1621
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKPT, &r);
 
1622
        }
 
1623
 
 
1624
        if (NT_STATUS_IS_ERR(status)) {
 
1625
                return status;
 
1626
        }
 
1627
 
 
1628
        /* Return variables */
 
1629
        *handle = *r.out.handle;
 
1630
 
 
1631
        /* Return result */
 
1632
        if (werror) {
 
1633
                *werror = r.out.result;
 
1634
        }
 
1635
 
 
1636
        return werror_to_ntstatus(r.out.result);
 
1637
}
 
1638
 
 
1639
NTSTATUS rpccli_winreg_OpenHKPN(struct rpc_pipe_client *cli,
 
1640
                                TALLOC_CTX *mem_ctx,
 
1641
                                uint16_t *system_name /* [in] [unique] */,
 
1642
                                uint32_t access_mask /* [in]  */,
 
1643
                                struct policy_handle *handle /* [out] [ref] */,
 
1644
                                WERROR *werror)
 
1645
{
 
1646
        struct winreg_OpenHKPN r;
 
1647
        NTSTATUS status;
 
1648
 
 
1649
        /* In parameters */
 
1650
        r.in.system_name = system_name;
 
1651
        r.in.access_mask = access_mask;
 
1652
 
 
1653
        if (DEBUGLEVEL >= 10) {
 
1654
                NDR_PRINT_IN_DEBUG(winreg_OpenHKPN, &r);
 
1655
        }
 
1656
 
 
1657
        status = cli->dispatch(cli,
 
1658
                                mem_ctx,
 
1659
                                &ndr_table_winreg,
 
1660
                                NDR_WINREG_OPENHKPN,
 
1661
                                &r);
 
1662
 
 
1663
        if (!NT_STATUS_IS_OK(status)) {
 
1664
                return status;
 
1665
        }
 
1666
 
 
1667
        if (DEBUGLEVEL >= 10) {
 
1668
                NDR_PRINT_OUT_DEBUG(winreg_OpenHKPN, &r);
 
1669
        }
 
1670
 
 
1671
        if (NT_STATUS_IS_ERR(status)) {
 
1672
                return status;
 
1673
        }
 
1674
 
 
1675
        /* Return variables */
 
1676
        *handle = *r.out.handle;
 
1677
 
 
1678
        /* Return result */
 
1679
        if (werror) {
 
1680
                *werror = r.out.result;
 
1681
        }
 
1682
 
 
1683
        return werror_to_ntstatus(r.out.result);
 
1684
}
 
1685
 
 
1686
NTSTATUS rpccli_winreg_QueryMultipleValues2(struct rpc_pipe_client *cli,
 
1687
                                            TALLOC_CTX *mem_ctx,
 
1688
                                            WERROR *werror)
 
1689
{
 
1690
        struct winreg_QueryMultipleValues2 r;
 
1691
        NTSTATUS status;
 
1692
 
 
1693
        /* In parameters */
 
1694
 
 
1695
        if (DEBUGLEVEL >= 10) {
 
1696
                NDR_PRINT_IN_DEBUG(winreg_QueryMultipleValues2, &r);
 
1697
        }
 
1698
 
 
1699
        status = cli->dispatch(cli,
 
1700
                                mem_ctx,
 
1701
                                &ndr_table_winreg,
 
1702
                                NDR_WINREG_QUERYMULTIPLEVALUES2,
 
1703
                                &r);
 
1704
 
 
1705
        if (!NT_STATUS_IS_OK(status)) {
 
1706
                return status;
 
1707
        }
 
1708
 
 
1709
        if (DEBUGLEVEL >= 10) {
 
1710
                NDR_PRINT_OUT_DEBUG(winreg_QueryMultipleValues2, &r);
 
1711
        }
 
1712
 
 
1713
        if (NT_STATUS_IS_ERR(status)) {
 
1714
                return status;
 
1715
        }
 
1716
 
 
1717
        /* Return variables */
 
1718
 
 
1719
        /* Return result */
 
1720
        if (werror) {
 
1721
                *werror = r.out.result;
 
1722
        }
 
1723
 
 
1724
        return werror_to_ntstatus(r.out.result);
 
1725
}
 
1726