← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/cli_dfs.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_dfs.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_dfs.h"
 
8
 
 
9
NTSTATUS rpccli_dfs_GetManagerVersion(struct rpc_pipe_client *cli,
 
10
                                      TALLOC_CTX *mem_ctx,
 
11
                                      enum dfs_ManagerVersion *version /* [out] [ref] */)
 
12
{
 
13
        struct dfs_GetManagerVersion r;
 
14
        NTSTATUS status;
 
15
 
 
16
        /* In parameters */
 
17
 
 
18
        if (DEBUGLEVEL >= 10) {
 
19
                NDR_PRINT_IN_DEBUG(dfs_GetManagerVersion, &r);
 
20
        }
 
21
 
 
22
        status = cli->dispatch(cli,
 
23
                                mem_ctx,
 
24
                                &ndr_table_netdfs,
 
25
                                NDR_DFS_GETMANAGERVERSION,
 
26
                                &r);
 
27
 
 
28
        if (!NT_STATUS_IS_OK(status)) {
 
29
                return status;
 
30
        }
 
31
 
 
32
        if (DEBUGLEVEL >= 10) {
 
33
                NDR_PRINT_OUT_DEBUG(dfs_GetManagerVersion, &r);
 
34
        }
 
35
 
 
36
        if (NT_STATUS_IS_ERR(status)) {
 
37
                return status;
 
38
        }
 
39
 
 
40
        /* Return variables */
 
41
        *version = *r.out.version;
 
42
 
 
43
        /* Return result */
 
44
        return NT_STATUS_OK;
 
45
}
 
46
 
 
47
NTSTATUS rpccli_dfs_Add(struct rpc_pipe_client *cli,
 
48
                        TALLOC_CTX *mem_ctx,
 
49
                        const char *path /* [in] [ref,charset(UTF16)] */,
 
50
                        const char *server /* [in] [ref,charset(UTF16)] */,
 
51
                        const char *share /* [in] [unique,charset(UTF16)] */,
 
52
                        const char *comment /* [in] [unique,charset(UTF16)] */,
 
53
                        uint32_t flags /* [in]  */,
 
54
                        WERROR *werror)
 
55
{
 
56
        struct dfs_Add r;
 
57
        NTSTATUS status;
 
58
 
 
59
        /* In parameters */
 
60
        r.in.path = path;
 
61
        r.in.server = server;
 
62
        r.in.share = share;
 
63
        r.in.comment = comment;
 
64
        r.in.flags = flags;
 
65
 
 
66
        if (DEBUGLEVEL >= 10) {
 
67
                NDR_PRINT_IN_DEBUG(dfs_Add, &r);
 
68
        }
 
69
 
 
70
        status = cli->dispatch(cli,
 
71
                                mem_ctx,
 
72
                                &ndr_table_netdfs,
 
73
                                NDR_DFS_ADD,
 
74
                                &r);
 
75
 
 
76
        if (!NT_STATUS_IS_OK(status)) {
 
77
                return status;
 
78
        }
 
79
 
 
80
        if (DEBUGLEVEL >= 10) {
 
81
                NDR_PRINT_OUT_DEBUG(dfs_Add, &r);
 
82
        }
 
83
 
 
84
        if (NT_STATUS_IS_ERR(status)) {
 
85
                return status;
 
86
        }
 
87
 
 
88
        /* Return variables */
 
89
 
 
90
        /* Return result */
 
91
        if (werror) {
 
92
                *werror = r.out.result;
 
93
        }
 
94
 
 
95
        return werror_to_ntstatus(r.out.result);
 
96
}
 
97
 
 
98
NTSTATUS rpccli_dfs_Remove(struct rpc_pipe_client *cli,
 
99
                           TALLOC_CTX *mem_ctx,
 
100
                           const char *dfs_entry_path /* [in] [ref,charset(UTF16)] */,
 
101
                           const char *servername /* [in] [unique,charset(UTF16)] */,
 
102
                           const char *sharename /* [in] [unique,charset(UTF16)] */,
 
103
                           WERROR *werror)
 
104
{
 
105
        struct dfs_Remove r;
 
106
        NTSTATUS status;
 
107
 
 
108
        /* In parameters */
 
109
        r.in.dfs_entry_path = dfs_entry_path;
 
110
        r.in.servername = servername;
 
111
        r.in.sharename = sharename;
 
112
 
 
113
        if (DEBUGLEVEL >= 10) {
 
114
                NDR_PRINT_IN_DEBUG(dfs_Remove, &r);
 
115
        }
 
116
 
 
117
        status = cli->dispatch(cli,
 
118
                                mem_ctx,
 
119
                                &ndr_table_netdfs,
 
120
                                NDR_DFS_REMOVE,
 
121
                                &r);
 
122
 
 
123
        if (!NT_STATUS_IS_OK(status)) {
 
124
                return status;
 
125
        }
 
126
 
 
127
        if (DEBUGLEVEL >= 10) {
 
128
                NDR_PRINT_OUT_DEBUG(dfs_Remove, &r);
 
129
        }
 
130
 
 
131
        if (NT_STATUS_IS_ERR(status)) {
 
132
                return status;
 
133
        }
 
134
 
 
135
        /* Return variables */
 
136
 
 
137
        /* Return result */
 
138
        if (werror) {
 
139
                *werror = r.out.result;
 
140
        }
 
141
 
 
142
        return werror_to_ntstatus(r.out.result);
 
143
}
 
144
 
 
145
NTSTATUS rpccli_dfs_SetInfo(struct rpc_pipe_client *cli,
 
146
                            TALLOC_CTX *mem_ctx,
 
147
                            const char *dfs_entry_path /* [in] [charset(UTF16)] */,
 
148
                            const char *servername /* [in] [unique,charset(UTF16)] */,
 
149
                            const char *sharename /* [in] [unique,charset(UTF16)] */,
 
150
                            uint32_t level /* [in]  */,
 
151
                            union dfs_Info *info /* [in] [ref,switch_is(level)] */,
 
152
                            WERROR *werror)
 
153
{
 
154
        struct dfs_SetInfo r;
 
155
        NTSTATUS status;
 
156
 
 
157
        /* In parameters */
 
158
        r.in.dfs_entry_path = dfs_entry_path;
 
159
        r.in.servername = servername;
 
160
        r.in.sharename = sharename;
 
161
        r.in.level = level;
 
162
        r.in.info = info;
 
163
 
 
164
        if (DEBUGLEVEL >= 10) {
 
165
                NDR_PRINT_IN_DEBUG(dfs_SetInfo, &r);
 
166
        }
 
167
 
 
168
        status = cli->dispatch(cli,
 
169
                                mem_ctx,
 
170
                                &ndr_table_netdfs,
 
171
                                NDR_DFS_SETINFO,
 
172
                                &r);
 
173
 
 
174
        if (!NT_STATUS_IS_OK(status)) {
 
175
                return status;
 
176
        }
 
177
 
 
178
        if (DEBUGLEVEL >= 10) {
 
179
                NDR_PRINT_OUT_DEBUG(dfs_SetInfo, &r);
 
180
        }
 
181
 
 
182
        if (NT_STATUS_IS_ERR(status)) {
 
183
                return status;
 
184
        }
 
185
 
 
186
        /* Return variables */
 
187
 
 
188
        /* Return result */
 
189
        if (werror) {
 
190
                *werror = r.out.result;
 
191
        }
 
192
 
 
193
        return werror_to_ntstatus(r.out.result);
 
194
}
 
195
 
 
196
NTSTATUS rpccli_dfs_GetInfo(struct rpc_pipe_client *cli,
 
197
                            TALLOC_CTX *mem_ctx,
 
198
                            const char *dfs_entry_path /* [in] [charset(UTF16)] */,
 
199
                            const char *servername /* [in] [unique,charset(UTF16)] */,
 
200
                            const char *sharename /* [in] [unique,charset(UTF16)] */,
 
201
                            uint32_t level /* [in]  */,
 
202
                            union dfs_Info *info /* [out] [ref,switch_is(level)] */,
 
203
                            WERROR *werror)
 
204
{
 
205
        struct dfs_GetInfo r;
 
206
        NTSTATUS status;
 
207
 
 
208
        /* In parameters */
 
209
        r.in.dfs_entry_path = dfs_entry_path;
 
210
        r.in.servername = servername;
 
211
        r.in.sharename = sharename;
 
212
        r.in.level = level;
 
213
 
 
214
        if (DEBUGLEVEL >= 10) {
 
215
                NDR_PRINT_IN_DEBUG(dfs_GetInfo, &r);
 
216
        }
 
217
 
 
218
        status = cli->dispatch(cli,
 
219
                                mem_ctx,
 
220
                                &ndr_table_netdfs,
 
221
                                NDR_DFS_GETINFO,
 
222
                                &r);
 
223
 
 
224
        if (!NT_STATUS_IS_OK(status)) {
 
225
                return status;
 
226
        }
 
227
 
 
228
        if (DEBUGLEVEL >= 10) {
 
229
                NDR_PRINT_OUT_DEBUG(dfs_GetInfo, &r);
 
230
        }
 
231
 
 
232
        if (NT_STATUS_IS_ERR(status)) {
 
233
                return status;
 
234
        }
 
235
 
 
236
        /* Return variables */
 
237
        *info = *r.out.info;
 
238
 
 
239
        /* Return result */
 
240
        if (werror) {
 
241
                *werror = r.out.result;
 
242
        }
 
243
 
 
244
        return werror_to_ntstatus(r.out.result);
 
245
}
 
246
 
 
247
NTSTATUS rpccli_dfs_Enum(struct rpc_pipe_client *cli,
 
248
                         TALLOC_CTX *mem_ctx,
 
249
                         uint32_t level /* [in]  */,
 
250
                         uint32_t bufsize /* [in]  */,
 
251
                         struct dfs_EnumStruct *info /* [in,out] [unique] */,
 
252
                         uint32_t *total /* [in,out] [unique] */,
 
253
                         WERROR *werror)
 
254
{
 
255
        struct dfs_Enum r;
 
256
        NTSTATUS status;
 
257
 
 
258
        /* In parameters */
 
259
        r.in.level = level;
 
260
        r.in.bufsize = bufsize;
 
261
        r.in.info = info;
 
262
        r.in.total = total;
 
263
 
 
264
        if (DEBUGLEVEL >= 10) {
 
265
                NDR_PRINT_IN_DEBUG(dfs_Enum, &r);
 
266
        }
 
267
 
 
268
        status = cli->dispatch(cli,
 
269
                                mem_ctx,
 
270
                                &ndr_table_netdfs,
 
271
                                NDR_DFS_ENUM,
 
272
                                &r);
 
273
 
 
274
        if (!NT_STATUS_IS_OK(status)) {
 
275
                return status;
 
276
        }
 
277
 
 
278
        if (DEBUGLEVEL >= 10) {
 
279
                NDR_PRINT_OUT_DEBUG(dfs_Enum, &r);
 
280
        }
 
281
 
 
282
        if (NT_STATUS_IS_ERR(status)) {
 
283
                return status;
 
284
        }
 
285
 
 
286
        /* Return variables */
 
287
        if (info && r.out.info) {
 
288
                *info = *r.out.info;
 
289
        }
 
290
        if (total && r.out.total) {
 
291
                *total = *r.out.total;
 
292
        }
 
293
 
 
294
        /* Return result */
 
295
        if (werror) {
 
296
                *werror = r.out.result;
 
297
        }
 
298
 
 
299
        return werror_to_ntstatus(r.out.result);
 
300
}
 
301
 
 
302
NTSTATUS rpccli_dfs_Rename(struct rpc_pipe_client *cli,
 
303
                           TALLOC_CTX *mem_ctx,
 
304
                           WERROR *werror)
 
305
{
 
306
        struct dfs_Rename r;
 
307
        NTSTATUS status;
 
308
 
 
309
        /* In parameters */
 
310
 
 
311
        if (DEBUGLEVEL >= 10) {
 
312
                NDR_PRINT_IN_DEBUG(dfs_Rename, &r);
 
313
        }
 
314
 
 
315
        status = cli->dispatch(cli,
 
316
                                mem_ctx,
 
317
                                &ndr_table_netdfs,
 
318
                                NDR_DFS_RENAME,
 
319
                                &r);
 
320
 
 
321
        if (!NT_STATUS_IS_OK(status)) {
 
322
                return status;
 
323
        }
 
324
 
 
325
        if (DEBUGLEVEL >= 10) {
 
326
                NDR_PRINT_OUT_DEBUG(dfs_Rename, &r);
 
327
        }
 
328
 
 
329
        if (NT_STATUS_IS_ERR(status)) {
 
330
                return status;
 
331
        }
 
332
 
 
333
        /* Return variables */
 
334
 
 
335
        /* Return result */
 
336
        if (werror) {
 
337
                *werror = r.out.result;
 
338
        }
 
339
 
 
340
        return werror_to_ntstatus(r.out.result);
 
341
}
 
342
 
 
343
NTSTATUS rpccli_dfs_Move(struct rpc_pipe_client *cli,
 
344
                         TALLOC_CTX *mem_ctx,
 
345
                         WERROR *werror)
 
346
{
 
347
        struct dfs_Move r;
 
348
        NTSTATUS status;
 
349
 
 
350
        /* In parameters */
 
351
 
 
352
        if (DEBUGLEVEL >= 10) {
 
353
                NDR_PRINT_IN_DEBUG(dfs_Move, &r);
 
354
        }
 
355
 
 
356
        status = cli->dispatch(cli,
 
357
                                mem_ctx,
 
358
                                &ndr_table_netdfs,
 
359
                                NDR_DFS_MOVE,
 
360
                                &r);
 
361
 
 
362
        if (!NT_STATUS_IS_OK(status)) {
 
363
                return status;
 
364
        }
 
365
 
 
366
        if (DEBUGLEVEL >= 10) {
 
367
                NDR_PRINT_OUT_DEBUG(dfs_Move, &r);
 
368
        }
 
369
 
 
370
        if (NT_STATUS_IS_ERR(status)) {
 
371
                return status;
 
372
        }
 
373
 
 
374
        /* Return variables */
 
375
 
 
376
        /* Return result */
 
377
        if (werror) {
 
378
                *werror = r.out.result;
 
379
        }
 
380
 
 
381
        return werror_to_ntstatus(r.out.result);
 
382
}
 
383
 
 
384
NTSTATUS rpccli_dfs_ManagerGetConfigInfo(struct rpc_pipe_client *cli,
 
385
                                         TALLOC_CTX *mem_ctx,
 
386
                                         WERROR *werror)
 
387
{
 
388
        struct dfs_ManagerGetConfigInfo r;
 
389
        NTSTATUS status;
 
390
 
 
391
        /* In parameters */
 
392
 
 
393
        if (DEBUGLEVEL >= 10) {
 
394
                NDR_PRINT_IN_DEBUG(dfs_ManagerGetConfigInfo, &r);
 
395
        }
 
396
 
 
397
        status = cli->dispatch(cli,
 
398
                                mem_ctx,
 
399
                                &ndr_table_netdfs,
 
400
                                NDR_DFS_MANAGERGETCONFIGINFO,
 
401
                                &r);
 
402
 
 
403
        if (!NT_STATUS_IS_OK(status)) {
 
404
                return status;
 
405
        }
 
406
 
 
407
        if (DEBUGLEVEL >= 10) {
 
408
                NDR_PRINT_OUT_DEBUG(dfs_ManagerGetConfigInfo, &r);
 
409
        }
 
410
 
 
411
        if (NT_STATUS_IS_ERR(status)) {
 
412
                return status;
 
413
        }
 
414
 
 
415
        /* Return variables */
 
416
 
 
417
        /* Return result */
 
418
        if (werror) {
 
419
                *werror = r.out.result;
 
420
        }
 
421
 
 
422
        return werror_to_ntstatus(r.out.result);
 
423
}
 
424
 
 
425
NTSTATUS rpccli_dfs_ManagerSendSiteInfo(struct rpc_pipe_client *cli,
 
426
                                        TALLOC_CTX *mem_ctx,
 
427
                                        WERROR *werror)
 
428
{
 
429
        struct dfs_ManagerSendSiteInfo r;
 
430
        NTSTATUS status;
 
431
 
 
432
        /* In parameters */
 
433
 
 
434
        if (DEBUGLEVEL >= 10) {
 
435
                NDR_PRINT_IN_DEBUG(dfs_ManagerSendSiteInfo, &r);
 
436
        }
 
437
 
 
438
        status = cli->dispatch(cli,
 
439
                                mem_ctx,
 
440
                                &ndr_table_netdfs,
 
441
                                NDR_DFS_MANAGERSENDSITEINFO,
 
442
                                &r);
 
443
 
 
444
        if (!NT_STATUS_IS_OK(status)) {
 
445
                return status;
 
446
        }
 
447
 
 
448
        if (DEBUGLEVEL >= 10) {
 
449
                NDR_PRINT_OUT_DEBUG(dfs_ManagerSendSiteInfo, &r);
 
450
        }
 
451
 
 
452
        if (NT_STATUS_IS_ERR(status)) {
 
453
                return status;
 
454
        }
 
455
 
 
456
        /* Return variables */
 
457
 
 
458
        /* Return result */
 
459
        if (werror) {
 
460
                *werror = r.out.result;
 
461
        }
 
462
 
 
463
        return werror_to_ntstatus(r.out.result);
 
464
}
 
465
 
 
466
NTSTATUS rpccli_dfs_AddFtRoot(struct rpc_pipe_client *cli,
 
467
                              TALLOC_CTX *mem_ctx,
 
468
                              const char *servername /* [in] [charset(UTF16)] */,
 
469
                              const char *dns_servername /* [in] [charset(UTF16)] */,
 
470
                              const char *dfsname /* [in] [charset(UTF16)] */,
 
471
                              const char *rootshare /* [in] [charset(UTF16)] */,
 
472
                              const char *comment /* [in] [charset(UTF16)] */,
 
473
                              const char *dfs_config_dn /* [in] [charset(UTF16)] */,
 
474
                              uint8_t unknown1 /* [in]  */,
 
475
                              uint32_t flags /* [in]  */,
 
476
                              struct dfs_UnknownStruct **unknown2 /* [in,out] [unique] */,
 
477
                              WERROR *werror)
 
478
{
 
479
        struct dfs_AddFtRoot r;
 
480
        NTSTATUS status;
 
481
 
 
482
        /* In parameters */
 
483
        r.in.servername = servername;
 
484
        r.in.dns_servername = dns_servername;
 
485
        r.in.dfsname = dfsname;
 
486
        r.in.rootshare = rootshare;
 
487
        r.in.comment = comment;
 
488
        r.in.dfs_config_dn = dfs_config_dn;
 
489
        r.in.unknown1 = unknown1;
 
490
        r.in.flags = flags;
 
491
        r.in.unknown2 = unknown2;
 
492
 
 
493
        if (DEBUGLEVEL >= 10) {
 
494
                NDR_PRINT_IN_DEBUG(dfs_AddFtRoot, &r);
 
495
        }
 
496
 
 
497
        status = cli->dispatch(cli,
 
498
                                mem_ctx,
 
499
                                &ndr_table_netdfs,
 
500
                                NDR_DFS_ADDFTROOT,
 
501
                                &r);
 
502
 
 
503
        if (!NT_STATUS_IS_OK(status)) {
 
504
                return status;
 
505
        }
 
506
 
 
507
        if (DEBUGLEVEL >= 10) {
 
508
                NDR_PRINT_OUT_DEBUG(dfs_AddFtRoot, &r);
 
509
        }
 
510
 
 
511
        if (NT_STATUS_IS_ERR(status)) {
 
512
                return status;
 
513
        }
 
514
 
 
515
        /* Return variables */
 
516
        if (unknown2 && r.out.unknown2) {
 
517
                *unknown2 = *r.out.unknown2;
 
518
        }
 
519
 
 
520
        /* Return result */
 
521
        if (werror) {
 
522
                *werror = r.out.result;
 
523
        }
 
524
 
 
525
        return werror_to_ntstatus(r.out.result);
 
526
}
 
527
 
 
528
NTSTATUS rpccli_dfs_RemoveFtRoot(struct rpc_pipe_client *cli,
 
529
                                 TALLOC_CTX *mem_ctx,
 
530
                                 const char *servername /* [in] [charset(UTF16)] */,
 
531
                                 const char *dns_servername /* [in] [charset(UTF16)] */,
 
532
                                 const char *dfsname /* [in] [charset(UTF16)] */,
 
533
                                 const char *rootshare /* [in] [charset(UTF16)] */,
 
534
                                 uint32_t flags /* [in]  */,
 
535
                                 struct dfs_UnknownStruct **unknown /* [in,out] [unique] */,
 
536
                                 WERROR *werror)
 
537
{
 
538
        struct dfs_RemoveFtRoot r;
 
539
        NTSTATUS status;
 
540
 
 
541
        /* In parameters */
 
542
        r.in.servername = servername;
 
543
        r.in.dns_servername = dns_servername;
 
544
        r.in.dfsname = dfsname;
 
545
        r.in.rootshare = rootshare;
 
546
        r.in.flags = flags;
 
547
        r.in.unknown = unknown;
 
548
 
 
549
        if (DEBUGLEVEL >= 10) {
 
550
                NDR_PRINT_IN_DEBUG(dfs_RemoveFtRoot, &r);
 
551
        }
 
552
 
 
553
        status = cli->dispatch(cli,
 
554
                                mem_ctx,
 
555
                                &ndr_table_netdfs,
 
556
                                NDR_DFS_REMOVEFTROOT,
 
557
                                &r);
 
558
 
 
559
        if (!NT_STATUS_IS_OK(status)) {
 
560
                return status;
 
561
        }
 
562
 
 
563
        if (DEBUGLEVEL >= 10) {
 
564
                NDR_PRINT_OUT_DEBUG(dfs_RemoveFtRoot, &r);
 
565
        }
 
566
 
 
567
        if (NT_STATUS_IS_ERR(status)) {
 
568
                return status;
 
569
        }
 
570
 
 
571
        /* Return variables */
 
572
        if (unknown && r.out.unknown) {
 
573
                *unknown = *r.out.unknown;
 
574
        }
 
575
 
 
576
        /* Return result */
 
577
        if (werror) {
 
578
                *werror = r.out.result;
 
579
        }
 
580
 
 
581
        return werror_to_ntstatus(r.out.result);
 
582
}
 
583
 
 
584
NTSTATUS rpccli_dfs_AddStdRoot(struct rpc_pipe_client *cli,
 
585
                               TALLOC_CTX *mem_ctx,
 
586
                               const char *servername /* [in] [charset(UTF16)] */,
 
587
                               const char *rootshare /* [in] [charset(UTF16)] */,
 
588
                               const char *comment /* [in] [charset(UTF16)] */,
 
589
                               uint32_t flags /* [in]  */,
 
590
                               WERROR *werror)
 
591
{
 
592
        struct dfs_AddStdRoot r;
 
593
        NTSTATUS status;
 
594
 
 
595
        /* In parameters */
 
596
        r.in.servername = servername;
 
597
        r.in.rootshare = rootshare;
 
598
        r.in.comment = comment;
 
599
        r.in.flags = flags;
 
600
 
 
601
        if (DEBUGLEVEL >= 10) {
 
602
                NDR_PRINT_IN_DEBUG(dfs_AddStdRoot, &r);
 
603
        }
 
604
 
 
605
        status = cli->dispatch(cli,
 
606
                                mem_ctx,
 
607
                                &ndr_table_netdfs,
 
608
                                NDR_DFS_ADDSTDROOT,
 
609
                                &r);
 
610
 
 
611
        if (!NT_STATUS_IS_OK(status)) {
 
612
                return status;
 
613
        }
 
614
 
 
615
        if (DEBUGLEVEL >= 10) {
 
616
                NDR_PRINT_OUT_DEBUG(dfs_AddStdRoot, &r);
 
617
        }
 
618
 
 
619
        if (NT_STATUS_IS_ERR(status)) {
 
620
                return status;
 
621
        }
 
622
 
 
623
        /* Return variables */
 
624
 
 
625
        /* Return result */
 
626
        if (werror) {
 
627
                *werror = r.out.result;
 
628
        }
 
629
 
 
630
        return werror_to_ntstatus(r.out.result);
 
631
}
 
632
 
 
633
NTSTATUS rpccli_dfs_RemoveStdRoot(struct rpc_pipe_client *cli,
 
634
                                  TALLOC_CTX *mem_ctx,
 
635
                                  const char *servername /* [in] [charset(UTF16)] */,
 
636
                                  const char *rootshare /* [in] [charset(UTF16)] */,
 
637
                                  uint32_t flags /* [in]  */,
 
638
                                  WERROR *werror)
 
639
{
 
640
        struct dfs_RemoveStdRoot r;
 
641
        NTSTATUS status;
 
642
 
 
643
        /* In parameters */
 
644
        r.in.servername = servername;
 
645
        r.in.rootshare = rootshare;
 
646
        r.in.flags = flags;
 
647
 
 
648
        if (DEBUGLEVEL >= 10) {
 
649
                NDR_PRINT_IN_DEBUG(dfs_RemoveStdRoot, &r);
 
650
        }
 
651
 
 
652
        status = cli->dispatch(cli,
 
653
                                mem_ctx,
 
654
                                &ndr_table_netdfs,
 
655
                                NDR_DFS_REMOVESTDROOT,
 
656
                                &r);
 
657
 
 
658
        if (!NT_STATUS_IS_OK(status)) {
 
659
                return status;
 
660
        }
 
661
 
 
662
        if (DEBUGLEVEL >= 10) {
 
663
                NDR_PRINT_OUT_DEBUG(dfs_RemoveStdRoot, &r);
 
664
        }
 
665
 
 
666
        if (NT_STATUS_IS_ERR(status)) {
 
667
                return status;
 
668
        }
 
669
 
 
670
        /* Return variables */
 
671
 
 
672
        /* Return result */
 
673
        if (werror) {
 
674
                *werror = r.out.result;
 
675
        }
 
676
 
 
677
        return werror_to_ntstatus(r.out.result);
 
678
}
 
679
 
 
680
NTSTATUS rpccli_dfs_ManagerInitialize(struct rpc_pipe_client *cli,
 
681
                                      TALLOC_CTX *mem_ctx,
 
682
                                      const char *servername /* [in] [ref,charset(UTF16)] */,
 
683
                                      uint32_t flags /* [in]  */,
 
684
                                      WERROR *werror)
 
685
{
 
686
        struct dfs_ManagerInitialize r;
 
687
        NTSTATUS status;
 
688
 
 
689
        /* In parameters */
 
690
        r.in.servername = servername;
 
691
        r.in.flags = flags;
 
692
 
 
693
        if (DEBUGLEVEL >= 10) {
 
694
                NDR_PRINT_IN_DEBUG(dfs_ManagerInitialize, &r);
 
695
        }
 
696
 
 
697
        status = cli->dispatch(cli,
 
698
                                mem_ctx,
 
699
                                &ndr_table_netdfs,
 
700
                                NDR_DFS_MANAGERINITIALIZE,
 
701
                                &r);
 
702
 
 
703
        if (!NT_STATUS_IS_OK(status)) {
 
704
                return status;
 
705
        }
 
706
 
 
707
        if (DEBUGLEVEL >= 10) {
 
708
                NDR_PRINT_OUT_DEBUG(dfs_ManagerInitialize, &r);
 
709
        }
 
710
 
 
711
        if (NT_STATUS_IS_ERR(status)) {
 
712
                return status;
 
713
        }
 
714
 
 
715
        /* Return variables */
 
716
 
 
717
        /* Return result */
 
718
        if (werror) {
 
719
                *werror = r.out.result;
 
720
        }
 
721
 
 
722
        return werror_to_ntstatus(r.out.result);
 
723
}
 
724
 
 
725
NTSTATUS rpccli_dfs_AddStdRootForced(struct rpc_pipe_client *cli,
 
726
                                     TALLOC_CTX *mem_ctx,
 
727
                                     const char *servername /* [in] [charset(UTF16)] */,
 
728
                                     const char *rootshare /* [in] [charset(UTF16)] */,
 
729
                                     const char *comment /* [in] [charset(UTF16)] */,
 
730
                                     const char *store /* [in] [charset(UTF16)] */,
 
731
                                     WERROR *werror)
 
732
{
 
733
        struct dfs_AddStdRootForced r;
 
734
        NTSTATUS status;
 
735
 
 
736
        /* In parameters */
 
737
        r.in.servername = servername;
 
738
        r.in.rootshare = rootshare;
 
739
        r.in.comment = comment;
 
740
        r.in.store = store;
 
741
 
 
742
        if (DEBUGLEVEL >= 10) {
 
743
                NDR_PRINT_IN_DEBUG(dfs_AddStdRootForced, &r);
 
744
        }
 
745
 
 
746
        status = cli->dispatch(cli,
 
747
                                mem_ctx,
 
748
                                &ndr_table_netdfs,
 
749
                                NDR_DFS_ADDSTDROOTFORCED,
 
750
                                &r);
 
751
 
 
752
        if (!NT_STATUS_IS_OK(status)) {
 
753
                return status;
 
754
        }
 
755
 
 
756
        if (DEBUGLEVEL >= 10) {
 
757
                NDR_PRINT_OUT_DEBUG(dfs_AddStdRootForced, &r);
 
758
        }
 
759
 
 
760
        if (NT_STATUS_IS_ERR(status)) {
 
761
                return status;
 
762
        }
 
763
 
 
764
        /* Return variables */
 
765
 
 
766
        /* Return result */
 
767
        if (werror) {
 
768
                *werror = r.out.result;
 
769
        }
 
770
 
 
771
        return werror_to_ntstatus(r.out.result);
 
772
}
 
773
 
 
774
NTSTATUS rpccli_dfs_GetDcAddress(struct rpc_pipe_client *cli,
 
775
                                 TALLOC_CTX *mem_ctx,
 
776
                                 const char *servername /* [in] [charset(UTF16)] */,
 
777
                                 const char **server_fullname /* [in,out] [ref,charset(UTF16)] */,
 
778
                                 uint8_t *is_root /* [in,out] [ref] */,
 
779
                                 uint32_t *ttl /* [in,out] [ref] */,
 
780
                                 WERROR *werror)
 
781
{
 
782
        struct dfs_GetDcAddress r;
 
783
        NTSTATUS status;
 
784
 
 
785
        /* In parameters */
 
786
        r.in.servername = servername;
 
787
        r.in.server_fullname = server_fullname;
 
788
        r.in.is_root = is_root;
 
789
        r.in.ttl = ttl;
 
790
 
 
791
        if (DEBUGLEVEL >= 10) {
 
792
                NDR_PRINT_IN_DEBUG(dfs_GetDcAddress, &r);
 
793
        }
 
794
 
 
795
        status = cli->dispatch(cli,
 
796
                                mem_ctx,
 
797
                                &ndr_table_netdfs,
 
798
                                NDR_DFS_GETDCADDRESS,
 
799
                                &r);
 
800
 
 
801
        if (!NT_STATUS_IS_OK(status)) {
 
802
                return status;
 
803
        }
 
804
 
 
805
        if (DEBUGLEVEL >= 10) {
 
806
                NDR_PRINT_OUT_DEBUG(dfs_GetDcAddress, &r);
 
807
        }
 
808
 
 
809
        if (NT_STATUS_IS_ERR(status)) {
 
810
                return status;
 
811
        }
 
812
 
 
813
        /* Return variables */
 
814
        *server_fullname = *r.out.server_fullname;
 
815
        *is_root = *r.out.is_root;
 
816
        *ttl = *r.out.ttl;
 
817
 
 
818
        /* Return result */
 
819
        if (werror) {
 
820
                *werror = r.out.result;
 
821
        }
 
822
 
 
823
        return werror_to_ntstatus(r.out.result);
 
824
}
 
825
 
 
826
NTSTATUS rpccli_dfs_SetDcAddress(struct rpc_pipe_client *cli,
 
827
                                 TALLOC_CTX *mem_ctx,
 
828
                                 const char *servername /* [in] [charset(UTF16)] */,
 
829
                                 const char *server_fullname /* [in] [charset(UTF16)] */,
 
830
                                 uint32_t flags /* [in]  */,
 
831
                                 uint32_t ttl /* [in]  */,
 
832
                                 WERROR *werror)
 
833
{
 
834
        struct dfs_SetDcAddress r;
 
835
        NTSTATUS status;
 
836
 
 
837
        /* In parameters */
 
838
        r.in.servername = servername;
 
839
        r.in.server_fullname = server_fullname;
 
840
        r.in.flags = flags;
 
841
        r.in.ttl = ttl;
 
842
 
 
843
        if (DEBUGLEVEL >= 10) {
 
844
                NDR_PRINT_IN_DEBUG(dfs_SetDcAddress, &r);
 
845
        }
 
846
 
 
847
        status = cli->dispatch(cli,
 
848
                                mem_ctx,
 
849
                                &ndr_table_netdfs,
 
850
                                NDR_DFS_SETDCADDRESS,
 
851
                                &r);
 
852
 
 
853
        if (!NT_STATUS_IS_OK(status)) {
 
854
                return status;
 
855
        }
 
856
 
 
857
        if (DEBUGLEVEL >= 10) {
 
858
                NDR_PRINT_OUT_DEBUG(dfs_SetDcAddress, &r);
 
859
        }
 
860
 
 
861
        if (NT_STATUS_IS_ERR(status)) {
 
862
                return status;
 
863
        }
 
864
 
 
865
        /* Return variables */
 
866
 
 
867
        /* Return result */
 
868
        if (werror) {
 
869
                *werror = r.out.result;
 
870
        }
 
871
 
 
872
        return werror_to_ntstatus(r.out.result);
 
873
}
 
874
 
 
875
NTSTATUS rpccli_dfs_FlushFtTable(struct rpc_pipe_client *cli,
 
876
                                 TALLOC_CTX *mem_ctx,
 
877
                                 const char *servername /* [in] [charset(UTF16)] */,
 
878
                                 const char *rootshare /* [in] [charset(UTF16)] */,
 
879
                                 WERROR *werror)
 
880
{
 
881
        struct dfs_FlushFtTable r;
 
882
        NTSTATUS status;
 
883
 
 
884
        /* In parameters */
 
885
        r.in.servername = servername;
 
886
        r.in.rootshare = rootshare;
 
887
 
 
888
        if (DEBUGLEVEL >= 10) {
 
889
                NDR_PRINT_IN_DEBUG(dfs_FlushFtTable, &r);
 
890
        }
 
891
 
 
892
        status = cli->dispatch(cli,
 
893
                                mem_ctx,
 
894
                                &ndr_table_netdfs,
 
895
                                NDR_DFS_FLUSHFTTABLE,
 
896
                                &r);
 
897
 
 
898
        if (!NT_STATUS_IS_OK(status)) {
 
899
                return status;
 
900
        }
 
901
 
 
902
        if (DEBUGLEVEL >= 10) {
 
903
                NDR_PRINT_OUT_DEBUG(dfs_FlushFtTable, &r);
 
904
        }
 
905
 
 
906
        if (NT_STATUS_IS_ERR(status)) {
 
907
                return status;
 
908
        }
 
909
 
 
910
        /* Return variables */
 
911
 
 
912
        /* Return result */
 
913
        if (werror) {
 
914
                *werror = r.out.result;
 
915
        }
 
916
 
 
917
        return werror_to_ntstatus(r.out.result);
 
918
}
 
919
 
 
920
NTSTATUS rpccli_dfs_Add2(struct rpc_pipe_client *cli,
 
921
                         TALLOC_CTX *mem_ctx,
 
922
                         WERROR *werror)
 
923
{
 
924
        struct dfs_Add2 r;
 
925
        NTSTATUS status;
 
926
 
 
927
        /* In parameters */
 
928
 
 
929
        if (DEBUGLEVEL >= 10) {
 
930
                NDR_PRINT_IN_DEBUG(dfs_Add2, &r);
 
931
        }
 
932
 
 
933
        status = cli->dispatch(cli,
 
934
                                mem_ctx,
 
935
                                &ndr_table_netdfs,
 
936
                                NDR_DFS_ADD2,
 
937
                                &r);
 
938
 
 
939
        if (!NT_STATUS_IS_OK(status)) {
 
940
                return status;
 
941
        }
 
942
 
 
943
        if (DEBUGLEVEL >= 10) {
 
944
                NDR_PRINT_OUT_DEBUG(dfs_Add2, &r);
 
945
        }
 
946
 
 
947
        if (NT_STATUS_IS_ERR(status)) {
 
948
                return status;
 
949
        }
 
950
 
 
951
        /* Return variables */
 
952
 
 
953
        /* Return result */
 
954
        if (werror) {
 
955
                *werror = r.out.result;
 
956
        }
 
957
 
 
958
        return werror_to_ntstatus(r.out.result);
 
959
}
 
960
 
 
961
NTSTATUS rpccli_dfs_Remove2(struct rpc_pipe_client *cli,
 
962
                            TALLOC_CTX *mem_ctx,
 
963
                            WERROR *werror)
 
964
{
 
965
        struct dfs_Remove2 r;
 
966
        NTSTATUS status;
 
967
 
 
968
        /* In parameters */
 
969
 
 
970
        if (DEBUGLEVEL >= 10) {
 
971
                NDR_PRINT_IN_DEBUG(dfs_Remove2, &r);
 
972
        }
 
973
 
 
974
        status = cli->dispatch(cli,
 
975
                                mem_ctx,
 
976
                                &ndr_table_netdfs,
 
977
                                NDR_DFS_REMOVE2,
 
978
                                &r);
 
979
 
 
980
        if (!NT_STATUS_IS_OK(status)) {
 
981
                return status;
 
982
        }
 
983
 
 
984
        if (DEBUGLEVEL >= 10) {
 
985
                NDR_PRINT_OUT_DEBUG(dfs_Remove2, &r);
 
986
        }
 
987
 
 
988
        if (NT_STATUS_IS_ERR(status)) {
 
989
                return status;
 
990
        }
 
991
 
 
992
        /* Return variables */
 
993
 
 
994
        /* Return result */
 
995
        if (werror) {
 
996
                *werror = r.out.result;
 
997
        }
 
998
 
 
999
        return werror_to_ntstatus(r.out.result);
 
1000
}
 
1001
 
 
1002
NTSTATUS rpccli_dfs_EnumEx(struct rpc_pipe_client *cli,
 
1003
                           TALLOC_CTX *mem_ctx,
 
1004
                           const char *dfs_name /* [in] [charset(UTF16)] */,
 
1005
                           uint32_t level /* [in]  */,
 
1006
                           uint32_t bufsize /* [in]  */,
 
1007
                           struct dfs_EnumStruct *info /* [in,out] [unique] */,
 
1008
                           uint32_t *total /* [in,out] [unique] */,
 
1009
                           WERROR *werror)
 
1010
{
 
1011
        struct dfs_EnumEx r;
 
1012
        NTSTATUS status;
 
1013
 
 
1014
        /* In parameters */
 
1015
        r.in.dfs_name = dfs_name;
 
1016
        r.in.level = level;
 
1017
        r.in.bufsize = bufsize;
 
1018
        r.in.info = info;
 
1019
        r.in.total = total;
 
1020
 
 
1021
        if (DEBUGLEVEL >= 10) {
 
1022
                NDR_PRINT_IN_DEBUG(dfs_EnumEx, &r);
 
1023
        }
 
1024
 
 
1025
        status = cli->dispatch(cli,
 
1026
                                mem_ctx,
 
1027
                                &ndr_table_netdfs,
 
1028
                                NDR_DFS_ENUMEX,
 
1029
                                &r);
 
1030
 
 
1031
        if (!NT_STATUS_IS_OK(status)) {
 
1032
                return status;
 
1033
        }
 
1034
 
 
1035
        if (DEBUGLEVEL >= 10) {
 
1036
                NDR_PRINT_OUT_DEBUG(dfs_EnumEx, &r);
 
1037
        }
 
1038
 
 
1039
        if (NT_STATUS_IS_ERR(status)) {
 
1040
                return status;
 
1041
        }
 
1042
 
 
1043
        /* Return variables */
 
1044
        if (info && r.out.info) {
 
1045
                *info = *r.out.info;
 
1046
        }
 
1047
        if (total && r.out.total) {
 
1048
                *total = *r.out.total;
 
1049
        }
 
1050
 
 
1051
        /* Return result */
 
1052
        if (werror) {
 
1053
                *werror = r.out.result;
 
1054
        }
 
1055
 
 
1056
        return werror_to_ntstatus(r.out.result);
 
1057
}
 
1058
 
 
1059
NTSTATUS rpccli_dfs_SetInfo2(struct rpc_pipe_client *cli,
 
1060
                             TALLOC_CTX *mem_ctx,
 
1061
                             WERROR *werror)
 
1062
{
 
1063
        struct dfs_SetInfo2 r;
 
1064
        NTSTATUS status;
 
1065
 
 
1066
        /* In parameters */
 
1067
 
 
1068
        if (DEBUGLEVEL >= 10) {
 
1069
                NDR_PRINT_IN_DEBUG(dfs_SetInfo2, &r);
 
1070
        }
 
1071
 
 
1072
        status = cli->dispatch(cli,
 
1073
                                mem_ctx,
 
1074
                                &ndr_table_netdfs,
 
1075
                                NDR_DFS_SETINFO2,
 
1076
                                &r);
 
1077
 
 
1078
        if (!NT_STATUS_IS_OK(status)) {
 
1079
                return status;
 
1080
        }
 
1081
 
 
1082
        if (DEBUGLEVEL >= 10) {
 
1083
                NDR_PRINT_OUT_DEBUG(dfs_SetInfo2, &r);
 
1084
        }
 
1085
 
 
1086
        if (NT_STATUS_IS_ERR(status)) {
 
1087
                return status;
 
1088
        }
 
1089
 
 
1090
        /* Return variables */
 
1091
 
 
1092
        /* Return result */
 
1093
        if (werror) {
 
1094
                *werror = r.out.result;
 
1095
        }
 
1096
 
 
1097
        return werror_to_ntstatus(r.out.result);
 
1098
}
 
1099