← Back to branch summary

~zulcss/samba/server-dailies-3.4

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/cli_wkssvc.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_wkssvc.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_wkssvc.h"
 
8
 
 
9
NTSTATUS rpccli_wkssvc_NetWkstaGetInfo(struct rpc_pipe_client *cli,
 
10
                                       TALLOC_CTX *mem_ctx,
 
11
                                       const char *server_name /* [in] [unique,charset(UTF16)] */,
 
12
                                       uint32_t level /* [in]  */,
 
13
                                       union wkssvc_NetWkstaInfo *info /* [out] [ref,switch_is(level)] */,
 
14
                                       WERROR *werror)
 
15
{
 
16
        struct wkssvc_NetWkstaGetInfo r;
 
17
        NTSTATUS status;
 
18
 
 
19
        /* In parameters */
 
20
        r.in.server_name = server_name;
 
21
        r.in.level = level;
 
22
 
 
23
        if (DEBUGLEVEL >= 10) {
 
24
                NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaGetInfo, &r);
 
25
        }
 
26
 
 
27
        status = cli->dispatch(cli,
 
28
                                mem_ctx,
 
29
                                &ndr_table_wkssvc,
 
30
                                NDR_WKSSVC_NETWKSTAGETINFO,
 
31
                                &r);
 
32
 
 
33
        if (!NT_STATUS_IS_OK(status)) {
 
34
                return status;
 
35
        }
 
36
 
 
37
        if (DEBUGLEVEL >= 10) {
 
38
                NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaGetInfo, &r);
 
39
        }
 
40
 
 
41
        if (NT_STATUS_IS_ERR(status)) {
 
42
                return status;
 
43
        }
 
44
 
 
45
        /* Return variables */
 
46
        *info = *r.out.info;
 
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_wkssvc_NetWkstaSetInfo(struct rpc_pipe_client *cli,
 
57
                                       TALLOC_CTX *mem_ctx,
 
58
                                       const char *server_name /* [in] [unique,charset(UTF16)] */,
 
59
                                       uint32_t level /* [in]  */,
 
60
                                       union wkssvc_NetWkstaInfo *info /* [in] [ref,switch_is(level)] */,
 
61
                                       uint32_t *parm_error /* [in,out] [ref] */,
 
62
                                       WERROR *werror)
 
63
{
 
64
        struct wkssvc_NetWkstaSetInfo r;
 
65
        NTSTATUS status;
 
66
 
 
67
        /* In parameters */
 
68
        r.in.server_name = server_name;
 
69
        r.in.level = level;
 
70
        r.in.info = info;
 
71
        r.in.parm_error = parm_error;
 
72
 
 
73
        if (DEBUGLEVEL >= 10) {
 
74
                NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaSetInfo, &r);
 
75
        }
 
76
 
 
77
        status = cli->dispatch(cli,
 
78
                                mem_ctx,
 
79
                                &ndr_table_wkssvc,
 
80
                                NDR_WKSSVC_NETWKSTASETINFO,
 
81
                                &r);
 
82
 
 
83
        if (!NT_STATUS_IS_OK(status)) {
 
84
                return status;
 
85
        }
 
86
 
 
87
        if (DEBUGLEVEL >= 10) {
 
88
                NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaSetInfo, &r);
 
89
        }
 
90
 
 
91
        if (NT_STATUS_IS_ERR(status)) {
 
92
                return status;
 
93
        }
 
94
 
 
95
        /* Return variables */
 
96
        *parm_error = *r.out.parm_error;
 
97
 
 
98
        /* Return result */
 
99
        if (werror) {
 
100
                *werror = r.out.result;
 
101
        }
 
102
 
 
103
        return werror_to_ntstatus(r.out.result);
 
104
}
 
105
 
 
106
NTSTATUS rpccli_wkssvc_NetWkstaEnumUsers(struct rpc_pipe_client *cli,
 
107
                                         TALLOC_CTX *mem_ctx,
 
108
                                         const char *server_name /* [in] [unique,charset(UTF16)] */,
 
109
                                         struct wkssvc_NetWkstaEnumUsersInfo *info /* [in,out] [ref] */,
 
110
                                         uint32_t prefmaxlen /* [in]  */,
 
111
                                         uint32_t *entries_read /* [out] [ref] */,
 
112
                                         uint32_t *resume_handle /* [in,out] [unique] */,
 
113
                                         WERROR *werror)
 
114
{
 
115
        struct wkssvc_NetWkstaEnumUsers r;
 
116
        NTSTATUS status;
 
117
 
 
118
        /* In parameters */
 
119
        r.in.server_name = server_name;
 
120
        r.in.info = info;
 
121
        r.in.prefmaxlen = prefmaxlen;
 
122
        r.in.resume_handle = resume_handle;
 
123
 
 
124
        if (DEBUGLEVEL >= 10) {
 
125
                NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaEnumUsers, &r);
 
126
        }
 
127
 
 
128
        status = cli->dispatch(cli,
 
129
                                mem_ctx,
 
130
                                &ndr_table_wkssvc,
 
131
                                NDR_WKSSVC_NETWKSTAENUMUSERS,
 
132
                                &r);
 
133
 
 
134
        if (!NT_STATUS_IS_OK(status)) {
 
135
                return status;
 
136
        }
 
137
 
 
138
        if (DEBUGLEVEL >= 10) {
 
139
                NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaEnumUsers, &r);
 
140
        }
 
141
 
 
142
        if (NT_STATUS_IS_ERR(status)) {
 
143
                return status;
 
144
        }
 
145
 
 
146
        /* Return variables */
 
147
        *info = *r.out.info;
 
148
        *entries_read = *r.out.entries_read;
 
149
        if (resume_handle && r.out.resume_handle) {
 
150
                *resume_handle = *r.out.resume_handle;
 
151
        }
 
152
 
 
153
        /* Return result */
 
154
        if (werror) {
 
155
                *werror = r.out.result;
 
156
        }
 
157
 
 
158
        return werror_to_ntstatus(r.out.result);
 
159
}
 
160
 
 
161
NTSTATUS rpccli_wkssvc_NetrWkstaUserGetInfo(struct rpc_pipe_client *cli,
 
162
                                            TALLOC_CTX *mem_ctx,
 
163
                                            const char *unknown /* [in] [unique,charset(UTF16)] */,
 
164
                                            uint32_t level /* [in]  */,
 
165
                                            union wkssvc_NetrWkstaUserInfo *info /* [out] [ref,switch_is(level)] */,
 
166
                                            WERROR *werror)
 
167
{
 
168
        struct wkssvc_NetrWkstaUserGetInfo r;
 
169
        NTSTATUS status;
 
170
 
 
171
        /* In parameters */
 
172
        r.in.unknown = unknown;
 
173
        r.in.level = level;
 
174
 
 
175
        if (DEBUGLEVEL >= 10) {
 
176
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaUserGetInfo, &r);
 
177
        }
 
178
 
 
179
        status = cli->dispatch(cli,
 
180
                                mem_ctx,
 
181
                                &ndr_table_wkssvc,
 
182
                                NDR_WKSSVC_NETRWKSTAUSERGETINFO,
 
183
                                &r);
 
184
 
 
185
        if (!NT_STATUS_IS_OK(status)) {
 
186
                return status;
 
187
        }
 
188
 
 
189
        if (DEBUGLEVEL >= 10) {
 
190
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaUserGetInfo, &r);
 
191
        }
 
192
 
 
193
        if (NT_STATUS_IS_ERR(status)) {
 
194
                return status;
 
195
        }
 
196
 
 
197
        /* Return variables */
 
198
        *info = *r.out.info;
 
199
 
 
200
        /* Return result */
 
201
        if (werror) {
 
202
                *werror = r.out.result;
 
203
        }
 
204
 
 
205
        return werror_to_ntstatus(r.out.result);
 
206
}
 
207
 
 
208
NTSTATUS rpccli_wkssvc_NetrWkstaUserSetInfo(struct rpc_pipe_client *cli,
 
209
                                            TALLOC_CTX *mem_ctx,
 
210
                                            const char *unknown /* [in] [unique,charset(UTF16)] */,
 
211
                                            uint32_t level /* [in]  */,
 
212
                                            union wkssvc_NetrWkstaUserInfo *info /* [in] [ref,switch_is(level)] */,
 
213
                                            uint32_t *parm_err /* [in,out] [unique] */,
 
214
                                            WERROR *werror)
 
215
{
 
216
        struct wkssvc_NetrWkstaUserSetInfo r;
 
217
        NTSTATUS status;
 
218
 
 
219
        /* In parameters */
 
220
        r.in.unknown = unknown;
 
221
        r.in.level = level;
 
222
        r.in.info = info;
 
223
        r.in.parm_err = parm_err;
 
224
 
 
225
        if (DEBUGLEVEL >= 10) {
 
226
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaUserSetInfo, &r);
 
227
        }
 
228
 
 
229
        status = cli->dispatch(cli,
 
230
                                mem_ctx,
 
231
                                &ndr_table_wkssvc,
 
232
                                NDR_WKSSVC_NETRWKSTAUSERSETINFO,
 
233
                                &r);
 
234
 
 
235
        if (!NT_STATUS_IS_OK(status)) {
 
236
                return status;
 
237
        }
 
238
 
 
239
        if (DEBUGLEVEL >= 10) {
 
240
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaUserSetInfo, &r);
 
241
        }
 
242
 
 
243
        if (NT_STATUS_IS_ERR(status)) {
 
244
                return status;
 
245
        }
 
246
 
 
247
        /* Return variables */
 
248
        if (parm_err && r.out.parm_err) {
 
249
                *parm_err = *r.out.parm_err;
 
250
        }
 
251
 
 
252
        /* Return result */
 
253
        if (werror) {
 
254
                *werror = r.out.result;
 
255
        }
 
256
 
 
257
        return werror_to_ntstatus(r.out.result);
 
258
}
 
259
 
 
260
NTSTATUS rpccli_wkssvc_NetWkstaTransportEnum(struct rpc_pipe_client *cli,
 
261
                                             TALLOC_CTX *mem_ctx,
 
262
                                             const char *server_name /* [in] [unique,charset(UTF16)] */,
 
263
                                             struct wkssvc_NetWkstaTransportInfo *info /* [in,out] [ref] */,
 
264
                                             uint32_t max_buffer /* [in]  */,
 
265
                                             uint32_t *total_entries /* [out] [ref] */,
 
266
                                             uint32_t *resume_handle /* [in,out] [unique] */,
 
267
                                             WERROR *werror)
 
268
{
 
269
        struct wkssvc_NetWkstaTransportEnum r;
 
270
        NTSTATUS status;
 
271
 
 
272
        /* In parameters */
 
273
        r.in.server_name = server_name;
 
274
        r.in.info = info;
 
275
        r.in.max_buffer = max_buffer;
 
276
        r.in.resume_handle = resume_handle;
 
277
 
 
278
        if (DEBUGLEVEL >= 10) {
 
279
                NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaTransportEnum, &r);
 
280
        }
 
281
 
 
282
        status = cli->dispatch(cli,
 
283
                                mem_ctx,
 
284
                                &ndr_table_wkssvc,
 
285
                                NDR_WKSSVC_NETWKSTATRANSPORTENUM,
 
286
                                &r);
 
287
 
 
288
        if (!NT_STATUS_IS_OK(status)) {
 
289
                return status;
 
290
        }
 
291
 
 
292
        if (DEBUGLEVEL >= 10) {
 
293
                NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, &r);
 
294
        }
 
295
 
 
296
        if (NT_STATUS_IS_ERR(status)) {
 
297
                return status;
 
298
        }
 
299
 
 
300
        /* Return variables */
 
301
        *info = *r.out.info;
 
302
        *total_entries = *r.out.total_entries;
 
303
        if (resume_handle && r.out.resume_handle) {
 
304
                *resume_handle = *r.out.resume_handle;
 
305
        }
 
306
 
 
307
        /* Return result */
 
308
        if (werror) {
 
309
                *werror = r.out.result;
 
310
        }
 
311
 
 
312
        return werror_to_ntstatus(r.out.result);
 
313
}
 
314
 
 
315
NTSTATUS rpccli_wkssvc_NetrWkstaTransportAdd(struct rpc_pipe_client *cli,
 
316
                                             TALLOC_CTX *mem_ctx,
 
317
                                             const char *server_name /* [in] [unique,charset(UTF16)] */,
 
318
                                             uint32_t level /* [in]  */,
 
319
                                             struct wkssvc_NetWkstaTransportInfo0 *info0 /* [in] [ref] */,
 
320
                                             uint32_t *parm_err /* [in,out] [unique] */,
 
321
                                             WERROR *werror)
 
322
{
 
323
        struct wkssvc_NetrWkstaTransportAdd r;
 
324
        NTSTATUS status;
 
325
 
 
326
        /* In parameters */
 
327
        r.in.server_name = server_name;
 
328
        r.in.level = level;
 
329
        r.in.info0 = info0;
 
330
        r.in.parm_err = parm_err;
 
331
 
 
332
        if (DEBUGLEVEL >= 10) {
 
333
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaTransportAdd, &r);
 
334
        }
 
335
 
 
336
        status = cli->dispatch(cli,
 
337
                                mem_ctx,
 
338
                                &ndr_table_wkssvc,
 
339
                                NDR_WKSSVC_NETRWKSTATRANSPORTADD,
 
340
                                &r);
 
341
 
 
342
        if (!NT_STATUS_IS_OK(status)) {
 
343
                return status;
 
344
        }
 
345
 
 
346
        if (DEBUGLEVEL >= 10) {
 
347
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaTransportAdd, &r);
 
348
        }
 
349
 
 
350
        if (NT_STATUS_IS_ERR(status)) {
 
351
                return status;
 
352
        }
 
353
 
 
354
        /* Return variables */
 
355
        if (parm_err && r.out.parm_err) {
 
356
                *parm_err = *r.out.parm_err;
 
357
        }
 
358
 
 
359
        /* Return result */
 
360
        if (werror) {
 
361
                *werror = r.out.result;
 
362
        }
 
363
 
 
364
        return werror_to_ntstatus(r.out.result);
 
365
}
 
366
 
 
367
NTSTATUS rpccli_wkssvc_NetrWkstaTransportDel(struct rpc_pipe_client *cli,
 
368
                                             TALLOC_CTX *mem_ctx,
 
369
                                             const char *server_name /* [in] [unique,charset(UTF16)] */,
 
370
                                             const char *transport_name /* [in] [unique,charset(UTF16)] */,
 
371
                                             uint32_t unknown3 /* [in]  */,
 
372
                                             WERROR *werror)
 
373
{
 
374
        struct wkssvc_NetrWkstaTransportDel r;
 
375
        NTSTATUS status;
 
376
 
 
377
        /* In parameters */
 
378
        r.in.server_name = server_name;
 
379
        r.in.transport_name = transport_name;
 
380
        r.in.unknown3 = unknown3;
 
381
 
 
382
        if (DEBUGLEVEL >= 10) {
 
383
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaTransportDel, &r);
 
384
        }
 
385
 
 
386
        status = cli->dispatch(cli,
 
387
                                mem_ctx,
 
388
                                &ndr_table_wkssvc,
 
389
                                NDR_WKSSVC_NETRWKSTATRANSPORTDEL,
 
390
                                &r);
 
391
 
 
392
        if (!NT_STATUS_IS_OK(status)) {
 
393
                return status;
 
394
        }
 
395
 
 
396
        if (DEBUGLEVEL >= 10) {
 
397
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaTransportDel, &r);
 
398
        }
 
399
 
 
400
        if (NT_STATUS_IS_ERR(status)) {
 
401
                return status;
 
402
        }
 
403
 
 
404
        /* Return variables */
 
405
 
 
406
        /* Return result */
 
407
        if (werror) {
 
408
                *werror = r.out.result;
 
409
        }
 
410
 
 
411
        return werror_to_ntstatus(r.out.result);
 
412
}
 
413
 
 
414
NTSTATUS rpccli_wkssvc_NetrUseAdd(struct rpc_pipe_client *cli,
 
415
                                  TALLOC_CTX *mem_ctx,
 
416
                                  const char *server_name /* [in] [unique,charset(UTF16)] */,
 
417
                                  uint32_t level /* [in]  */,
 
418
                                  union wkssvc_NetrUseGetInfoCtr *ctr /* [in] [ref,switch_is(level)] */,
 
419
                                  uint32_t *parm_err /* [in,out] [unique] */,
 
420
                                  WERROR *werror)
 
421
{
 
422
        struct wkssvc_NetrUseAdd r;
 
423
        NTSTATUS status;
 
424
 
 
425
        /* In parameters */
 
426
        r.in.server_name = server_name;
 
427
        r.in.level = level;
 
428
        r.in.ctr = ctr;
 
429
        r.in.parm_err = parm_err;
 
430
 
 
431
        if (DEBUGLEVEL >= 10) {
 
432
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUseAdd, &r);
 
433
        }
 
434
 
 
435
        status = cli->dispatch(cli,
 
436
                                mem_ctx,
 
437
                                &ndr_table_wkssvc,
 
438
                                NDR_WKSSVC_NETRUSEADD,
 
439
                                &r);
 
440
 
 
441
        if (!NT_STATUS_IS_OK(status)) {
 
442
                return status;
 
443
        }
 
444
 
 
445
        if (DEBUGLEVEL >= 10) {
 
446
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseAdd, &r);
 
447
        }
 
448
 
 
449
        if (NT_STATUS_IS_ERR(status)) {
 
450
                return status;
 
451
        }
 
452
 
 
453
        /* Return variables */
 
454
        if (parm_err && r.out.parm_err) {
 
455
                *parm_err = *r.out.parm_err;
 
456
        }
 
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_wkssvc_NetrUseGetInfo(struct rpc_pipe_client *cli,
 
467
                                      TALLOC_CTX *mem_ctx,
 
468
                                      const char *server_name /* [in] [unique,charset(UTF16)] */,
 
469
                                      const char *use_name /* [in] [ref,charset(UTF16)] */,
 
470
                                      uint32_t level /* [in]  */,
 
471
                                      union wkssvc_NetrUseGetInfoCtr *ctr /* [out] [ref,switch_is(level)] */,
 
472
                                      WERROR *werror)
 
473
{
 
474
        struct wkssvc_NetrUseGetInfo r;
 
475
        NTSTATUS status;
 
476
 
 
477
        /* In parameters */
 
478
        r.in.server_name = server_name;
 
479
        r.in.use_name = use_name;
 
480
        r.in.level = level;
 
481
 
 
482
        if (DEBUGLEVEL >= 10) {
 
483
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUseGetInfo, &r);
 
484
        }
 
485
 
 
486
        status = cli->dispatch(cli,
 
487
                                mem_ctx,
 
488
                                &ndr_table_wkssvc,
 
489
                                NDR_WKSSVC_NETRUSEGETINFO,
 
490
                                &r);
 
491
 
 
492
        if (!NT_STATUS_IS_OK(status)) {
 
493
                return status;
 
494
        }
 
495
 
 
496
        if (DEBUGLEVEL >= 10) {
 
497
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseGetInfo, &r);
 
498
        }
 
499
 
 
500
        if (NT_STATUS_IS_ERR(status)) {
 
501
                return status;
 
502
        }
 
503
 
 
504
        /* Return variables */
 
505
        *ctr = *r.out.ctr;
 
506
 
 
507
        /* Return result */
 
508
        if (werror) {
 
509
                *werror = r.out.result;
 
510
        }
 
511
 
 
512
        return werror_to_ntstatus(r.out.result);
 
513
}
 
514
 
 
515
NTSTATUS rpccli_wkssvc_NetrUseDel(struct rpc_pipe_client *cli,
 
516
                                  TALLOC_CTX *mem_ctx,
 
517
                                  const char *server_name /* [in] [unique,charset(UTF16)] */,
 
518
                                  const char *use_name /* [in] [ref,charset(UTF16)] */,
 
519
                                  uint32_t force_cond /* [in]  */,
 
520
                                  WERROR *werror)
 
521
{
 
522
        struct wkssvc_NetrUseDel r;
 
523
        NTSTATUS status;
 
524
 
 
525
        /* In parameters */
 
526
        r.in.server_name = server_name;
 
527
        r.in.use_name = use_name;
 
528
        r.in.force_cond = force_cond;
 
529
 
 
530
        if (DEBUGLEVEL >= 10) {
 
531
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUseDel, &r);
 
532
        }
 
533
 
 
534
        status = cli->dispatch(cli,
 
535
                                mem_ctx,
 
536
                                &ndr_table_wkssvc,
 
537
                                NDR_WKSSVC_NETRUSEDEL,
 
538
                                &r);
 
539
 
 
540
        if (!NT_STATUS_IS_OK(status)) {
 
541
                return status;
 
542
        }
 
543
 
 
544
        if (DEBUGLEVEL >= 10) {
 
545
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseDel, &r);
 
546
        }
 
547
 
 
548
        if (NT_STATUS_IS_ERR(status)) {
 
549
                return status;
 
550
        }
 
551
 
 
552
        /* Return variables */
 
553
 
 
554
        /* Return result */
 
555
        if (werror) {
 
556
                *werror = r.out.result;
 
557
        }
 
558
 
 
559
        return werror_to_ntstatus(r.out.result);
 
560
}
 
561
 
 
562
NTSTATUS rpccli_wkssvc_NetrUseEnum(struct rpc_pipe_client *cli,
 
563
                                   TALLOC_CTX *mem_ctx,
 
564
                                   const char *server_name /* [in] [unique,charset(UTF16)] */,
 
565
                                   struct wkssvc_NetrUseEnumInfo *info /* [in,out] [ref] */,
 
566
                                   uint32_t prefmaxlen /* [in]  */,
 
567
                                   uint32_t *entries_read /* [out] [ref] */,
 
568
                                   uint32_t *resume_handle /* [in,out] [unique] */,
 
569
                                   WERROR *werror)
 
570
{
 
571
        struct wkssvc_NetrUseEnum r;
 
572
        NTSTATUS status;
 
573
 
 
574
        /* In parameters */
 
575
        r.in.server_name = server_name;
 
576
        r.in.info = info;
 
577
        r.in.prefmaxlen = prefmaxlen;
 
578
        r.in.resume_handle = resume_handle;
 
579
 
 
580
        if (DEBUGLEVEL >= 10) {
 
581
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUseEnum, &r);
 
582
        }
 
583
 
 
584
        status = cli->dispatch(cli,
 
585
                                mem_ctx,
 
586
                                &ndr_table_wkssvc,
 
587
                                NDR_WKSSVC_NETRUSEENUM,
 
588
                                &r);
 
589
 
 
590
        if (!NT_STATUS_IS_OK(status)) {
 
591
                return status;
 
592
        }
 
593
 
 
594
        if (DEBUGLEVEL >= 10) {
 
595
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseEnum, &r);
 
596
        }
 
597
 
 
598
        if (NT_STATUS_IS_ERR(status)) {
 
599
                return status;
 
600
        }
 
601
 
 
602
        /* Return variables */
 
603
        *info = *r.out.info;
 
604
        *entries_read = *r.out.entries_read;
 
605
        if (resume_handle && r.out.resume_handle) {
 
606
                *resume_handle = *r.out.resume_handle;
 
607
        }
 
608
 
 
609
        /* Return result */
 
610
        if (werror) {
 
611
                *werror = r.out.result;
 
612
        }
 
613
 
 
614
        return werror_to_ntstatus(r.out.result);
 
615
}
 
616
 
 
617
NTSTATUS rpccli_wkssvc_NetrMessageBufferSend(struct rpc_pipe_client *cli,
 
618
                                             TALLOC_CTX *mem_ctx,
 
619
                                             const char *server_name /* [in] [unique,charset(UTF16)] */,
 
620
                                             const char *message_name /* [in] [ref,charset(UTF16)] */,
 
621
                                             const char *message_sender_name /* [in] [unique,charset(UTF16)] */,
 
622
                                             uint8_t *message_buffer /* [in] [ref,size_is(message_size)] */,
 
623
                                             uint32_t message_size /* [in]  */,
 
624
                                             WERROR *werror)
 
625
{
 
626
        struct wkssvc_NetrMessageBufferSend r;
 
627
        NTSTATUS status;
 
628
 
 
629
        /* In parameters */
 
630
        r.in.server_name = server_name;
 
631
        r.in.message_name = message_name;
 
632
        r.in.message_sender_name = message_sender_name;
 
633
        r.in.message_buffer = message_buffer;
 
634
        r.in.message_size = message_size;
 
635
 
 
636
        if (DEBUGLEVEL >= 10) {
 
637
                NDR_PRINT_IN_DEBUG(wkssvc_NetrMessageBufferSend, &r);
 
638
        }
 
639
 
 
640
        status = cli->dispatch(cli,
 
641
                                mem_ctx,
 
642
                                &ndr_table_wkssvc,
 
643
                                NDR_WKSSVC_NETRMESSAGEBUFFERSEND,
 
644
                                &r);
 
645
 
 
646
        if (!NT_STATUS_IS_OK(status)) {
 
647
                return status;
 
648
        }
 
649
 
 
650
        if (DEBUGLEVEL >= 10) {
 
651
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrMessageBufferSend, &r);
 
652
        }
 
653
 
 
654
        if (NT_STATUS_IS_ERR(status)) {
 
655
                return status;
 
656
        }
 
657
 
 
658
        /* Return variables */
 
659
 
 
660
        /* Return result */
 
661
        if (werror) {
 
662
                *werror = r.out.result;
 
663
        }
 
664
 
 
665
        return werror_to_ntstatus(r.out.result);
 
666
}
 
667
 
 
668
NTSTATUS rpccli_wkssvc_NetrWorkstationStatisticsGet(struct rpc_pipe_client *cli,
 
669
                                                    TALLOC_CTX *mem_ctx,
 
670
                                                    const char *server_name /* [in] [unique,charset(UTF16)] */,
 
671
                                                    const char *unknown2 /* [in] [unique,charset(UTF16)] */,
 
672
                                                    uint32_t unknown3 /* [in]  */,
 
673
                                                    uint32_t unknown4 /* [in]  */,
 
674
                                                    struct wkssvc_NetrWorkstationStatistics **info /* [out] [ref] */,
 
675
                                                    WERROR *werror)
 
676
{
 
677
        struct wkssvc_NetrWorkstationStatisticsGet r;
 
678
        NTSTATUS status;
 
679
 
 
680
        /* In parameters */
 
681
        r.in.server_name = server_name;
 
682
        r.in.unknown2 = unknown2;
 
683
        r.in.unknown3 = unknown3;
 
684
        r.in.unknown4 = unknown4;
 
685
 
 
686
        if (DEBUGLEVEL >= 10) {
 
687
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWorkstationStatisticsGet, &r);
 
688
        }
 
689
 
 
690
        status = cli->dispatch(cli,
 
691
                                mem_ctx,
 
692
                                &ndr_table_wkssvc,
 
693
                                NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET,
 
694
                                &r);
 
695
 
 
696
        if (!NT_STATUS_IS_OK(status)) {
 
697
                return status;
 
698
        }
 
699
 
 
700
        if (DEBUGLEVEL >= 10) {
 
701
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWorkstationStatisticsGet, &r);
 
702
        }
 
703
 
 
704
        if (NT_STATUS_IS_ERR(status)) {
 
705
                return status;
 
706
        }
 
707
 
 
708
        /* Return variables */
 
709
        *info = *r.out.info;
 
710
 
 
711
        /* Return result */
 
712
        if (werror) {
 
713
                *werror = r.out.result;
 
714
        }
 
715
 
 
716
        return werror_to_ntstatus(r.out.result);
 
717
}
 
718
 
 
719
NTSTATUS rpccli_wkssvc_NetrLogonDomainNameAdd(struct rpc_pipe_client *cli,
 
720
                                              TALLOC_CTX *mem_ctx,
 
721
                                              const char *domain_name /* [in] [ref,charset(UTF16)] */,
 
722
                                              WERROR *werror)
 
723
{
 
724
        struct wkssvc_NetrLogonDomainNameAdd r;
 
725
        NTSTATUS status;
 
726
 
 
727
        /* In parameters */
 
728
        r.in.domain_name = domain_name;
 
729
 
 
730
        if (DEBUGLEVEL >= 10) {
 
731
                NDR_PRINT_IN_DEBUG(wkssvc_NetrLogonDomainNameAdd, &r);
 
732
        }
 
733
 
 
734
        status = cli->dispatch(cli,
 
735
                                mem_ctx,
 
736
                                &ndr_table_wkssvc,
 
737
                                NDR_WKSSVC_NETRLOGONDOMAINNAMEADD,
 
738
                                &r);
 
739
 
 
740
        if (!NT_STATUS_IS_OK(status)) {
 
741
                return status;
 
742
        }
 
743
 
 
744
        if (DEBUGLEVEL >= 10) {
 
745
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrLogonDomainNameAdd, &r);
 
746
        }
 
747
 
 
748
        if (NT_STATUS_IS_ERR(status)) {
 
749
                return status;
 
750
        }
 
751
 
 
752
        /* Return variables */
 
753
 
 
754
        /* Return result */
 
755
        if (werror) {
 
756
                *werror = r.out.result;
 
757
        }
 
758
 
 
759
        return werror_to_ntstatus(r.out.result);
 
760
}
 
761
 
 
762
NTSTATUS rpccli_wkssvc_NetrLogonDomainNameDel(struct rpc_pipe_client *cli,
 
763
                                              TALLOC_CTX *mem_ctx,
 
764
                                              const char *domain_name /* [in] [ref,charset(UTF16)] */,
 
765
                                              WERROR *werror)
 
766
{
 
767
        struct wkssvc_NetrLogonDomainNameDel r;
 
768
        NTSTATUS status;
 
769
 
 
770
        /* In parameters */
 
771
        r.in.domain_name = domain_name;
 
772
 
 
773
        if (DEBUGLEVEL >= 10) {
 
774
                NDR_PRINT_IN_DEBUG(wkssvc_NetrLogonDomainNameDel, &r);
 
775
        }
 
776
 
 
777
        status = cli->dispatch(cli,
 
778
                                mem_ctx,
 
779
                                &ndr_table_wkssvc,
 
780
                                NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL,
 
781
                                &r);
 
782
 
 
783
        if (!NT_STATUS_IS_OK(status)) {
 
784
                return status;
 
785
        }
 
786
 
 
787
        if (DEBUGLEVEL >= 10) {
 
788
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrLogonDomainNameDel, &r);
 
789
        }
 
790
 
 
791
        if (NT_STATUS_IS_ERR(status)) {
 
792
                return status;
 
793
        }
 
794
 
 
795
        /* Return variables */
 
796
 
 
797
        /* Return result */
 
798
        if (werror) {
 
799
                *werror = r.out.result;
 
800
        }
 
801
 
 
802
        return werror_to_ntstatus(r.out.result);
 
803
}
 
804
 
 
805
NTSTATUS rpccli_wkssvc_NetrJoinDomain(struct rpc_pipe_client *cli,
 
806
                                      TALLOC_CTX *mem_ctx,
 
807
                                      const char *server_name /* [in] [unique,charset(UTF16)] */,
 
808
                                      const char *domain_name /* [in] [ref,charset(UTF16)] */,
 
809
                                      const char *account_ou /* [in] [unique,charset(UTF16)] */,
 
810
                                      const char *Account /* [in] [unique,charset(UTF16)] */,
 
811
                                      const char *password /* [in] [unique,charset(UTF16)] */,
 
812
                                      uint32_t join_flags /* [in]  */,
 
813
                                      WERROR *werror)
 
814
{
 
815
        struct wkssvc_NetrJoinDomain r;
 
816
        NTSTATUS status;
 
817
 
 
818
        /* In parameters */
 
819
        r.in.server_name = server_name;
 
820
        r.in.domain_name = domain_name;
 
821
        r.in.account_ou = account_ou;
 
822
        r.in.Account = Account;
 
823
        r.in.password = password;
 
824
        r.in.join_flags = join_flags;
 
825
 
 
826
        if (DEBUGLEVEL >= 10) {
 
827
                NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain, &r);
 
828
        }
 
829
 
 
830
        status = cli->dispatch(cli,
 
831
                                mem_ctx,
 
832
                                &ndr_table_wkssvc,
 
833
                                NDR_WKSSVC_NETRJOINDOMAIN,
 
834
                                &r);
 
835
 
 
836
        if (!NT_STATUS_IS_OK(status)) {
 
837
                return status;
 
838
        }
 
839
 
 
840
        if (DEBUGLEVEL >= 10) {
 
841
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain, &r);
 
842
        }
 
843
 
 
844
        if (NT_STATUS_IS_ERR(status)) {
 
845
                return status;
 
846
        }
 
847
 
 
848
        /* Return variables */
 
849
 
 
850
        /* Return result */
 
851
        if (werror) {
 
852
                *werror = r.out.result;
 
853
        }
 
854
 
 
855
        return werror_to_ntstatus(r.out.result);
 
856
}
 
857
 
 
858
NTSTATUS rpccli_wkssvc_NetrUnjoinDomain(struct rpc_pipe_client *cli,
 
859
                                        TALLOC_CTX *mem_ctx,
 
860
                                        const char *server_name /* [in] [unique,charset(UTF16)] */,
 
861
                                        const char *Account /* [in] [unique,charset(UTF16)] */,
 
862
                                        const char *password /* [in] [unique,charset(UTF16)] */,
 
863
                                        uint32_t unjoin_flags /* [in]  */,
 
864
                                        WERROR *werror)
 
865
{
 
866
        struct wkssvc_NetrUnjoinDomain r;
 
867
        NTSTATUS status;
 
868
 
 
869
        /* In parameters */
 
870
        r.in.server_name = server_name;
 
871
        r.in.Account = Account;
 
872
        r.in.password = password;
 
873
        r.in.unjoin_flags = unjoin_flags;
 
874
 
 
875
        if (DEBUGLEVEL >= 10) {
 
876
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain, &r);
 
877
        }
 
878
 
 
879
        status = cli->dispatch(cli,
 
880
                                mem_ctx,
 
881
                                &ndr_table_wkssvc,
 
882
                                NDR_WKSSVC_NETRUNJOINDOMAIN,
 
883
                                &r);
 
884
 
 
885
        if (!NT_STATUS_IS_OK(status)) {
 
886
                return status;
 
887
        }
 
888
 
 
889
        if (DEBUGLEVEL >= 10) {
 
890
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain, &r);
 
891
        }
 
892
 
 
893
        if (NT_STATUS_IS_ERR(status)) {
 
894
                return status;
 
895
        }
 
896
 
 
897
        /* Return variables */
 
898
 
 
899
        /* Return result */
 
900
        if (werror) {
 
901
                *werror = r.out.result;
 
902
        }
 
903
 
 
904
        return werror_to_ntstatus(r.out.result);
 
905
}
 
906
 
 
907
NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain(struct rpc_pipe_client *cli,
 
908
                                                 TALLOC_CTX *mem_ctx,
 
909
                                                 const char *server_name /* [in] [unique,charset(UTF16)] */,
 
910
                                                 const char *NewMachineName /* [in] [unique,charset(UTF16)] */,
 
911
                                                 const char *Account /* [in] [unique,charset(UTF16)] */,
 
912
                                                 const char *password /* [in] [unique,charset(UTF16)] */,
 
913
                                                 uint32_t RenameOptions /* [in]  */,
 
914
                                                 WERROR *werror)
 
915
{
 
916
        struct wkssvc_NetrRenameMachineInDomain r;
 
917
        NTSTATUS status;
 
918
 
 
919
        /* In parameters */
 
920
        r.in.server_name = server_name;
 
921
        r.in.NewMachineName = NewMachineName;
 
922
        r.in.Account = Account;
 
923
        r.in.password = password;
 
924
        r.in.RenameOptions = RenameOptions;
 
925
 
 
926
        if (DEBUGLEVEL >= 10) {
 
927
                NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain, &r);
 
928
        }
 
929
 
 
930
        status = cli->dispatch(cli,
 
931
                                mem_ctx,
 
932
                                &ndr_table_wkssvc,
 
933
                                NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN,
 
934
                                &r);
 
935
 
 
936
        if (!NT_STATUS_IS_OK(status)) {
 
937
                return status;
 
938
        }
 
939
 
 
940
        if (DEBUGLEVEL >= 10) {
 
941
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain, &r);
 
942
        }
 
943
 
 
944
        if (NT_STATUS_IS_ERR(status)) {
 
945
                return status;
 
946
        }
 
947
 
 
948
        /* Return variables */
 
949
 
 
950
        /* Return result */
 
951
        if (werror) {
 
952
                *werror = r.out.result;
 
953
        }
 
954
 
 
955
        return werror_to_ntstatus(r.out.result);
 
956
}
 
957
 
 
958
NTSTATUS rpccli_wkssvc_NetrValidateName(struct rpc_pipe_client *cli,
 
959
                                        TALLOC_CTX *mem_ctx,
 
960
                                        const char *server_name /* [in] [unique,charset(UTF16)] */,
 
961
                                        const char *name /* [in] [ref,charset(UTF16)] */,
 
962
                                        const char *Account /* [in] [unique,charset(UTF16)] */,
 
963
                                        const char *Password /* [in] [unique,charset(UTF16)] */,
 
964
                                        enum wkssvc_NetValidateNameType name_type /* [in]  */,
 
965
                                        WERROR *werror)
 
966
{
 
967
        struct wkssvc_NetrValidateName r;
 
968
        NTSTATUS status;
 
969
 
 
970
        /* In parameters */
 
971
        r.in.server_name = server_name;
 
972
        r.in.name = name;
 
973
        r.in.Account = Account;
 
974
        r.in.Password = Password;
 
975
        r.in.name_type = name_type;
 
976
 
 
977
        if (DEBUGLEVEL >= 10) {
 
978
                NDR_PRINT_IN_DEBUG(wkssvc_NetrValidateName, &r);
 
979
        }
 
980
 
 
981
        status = cli->dispatch(cli,
 
982
                                mem_ctx,
 
983
                                &ndr_table_wkssvc,
 
984
                                NDR_WKSSVC_NETRVALIDATENAME,
 
985
                                &r);
 
986
 
 
987
        if (!NT_STATUS_IS_OK(status)) {
 
988
                return status;
 
989
        }
 
990
 
 
991
        if (DEBUGLEVEL >= 10) {
 
992
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrValidateName, &r);
 
993
        }
 
994
 
 
995
        if (NT_STATUS_IS_ERR(status)) {
 
996
                return status;
 
997
        }
 
998
 
 
999
        /* Return variables */
 
1000
 
 
1001
        /* Return result */
 
1002
        if (werror) {
 
1003
                *werror = r.out.result;
 
1004
        }
 
1005
 
 
1006
        return werror_to_ntstatus(r.out.result);
 
1007
}
 
1008
 
 
1009
NTSTATUS rpccli_wkssvc_NetrGetJoinInformation(struct rpc_pipe_client *cli,
 
1010
                                              TALLOC_CTX *mem_ctx,
 
1011
                                              const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1012
                                              const char **name_buffer /* [in,out] [ref,charset(UTF16)] */,
 
1013
                                              enum wkssvc_NetJoinStatus *name_type /* [out] [ref] */,
 
1014
                                              WERROR *werror)
 
1015
{
 
1016
        struct wkssvc_NetrGetJoinInformation r;
 
1017
        NTSTATUS status;
 
1018
 
 
1019
        /* In parameters */
 
1020
        r.in.server_name = server_name;
 
1021
        r.in.name_buffer = name_buffer;
 
1022
 
 
1023
        if (DEBUGLEVEL >= 10) {
 
1024
                NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinInformation, &r);
 
1025
        }
 
1026
 
 
1027
        status = cli->dispatch(cli,
 
1028
                                mem_ctx,
 
1029
                                &ndr_table_wkssvc,
 
1030
                                NDR_WKSSVC_NETRGETJOININFORMATION,
 
1031
                                &r);
 
1032
 
 
1033
        if (!NT_STATUS_IS_OK(status)) {
 
1034
                return status;
 
1035
        }
 
1036
 
 
1037
        if (DEBUGLEVEL >= 10) {
 
1038
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinInformation, &r);
 
1039
        }
 
1040
 
 
1041
        if (NT_STATUS_IS_ERR(status)) {
 
1042
                return status;
 
1043
        }
 
1044
 
 
1045
        /* Return variables */
 
1046
        *name_buffer = *r.out.name_buffer;
 
1047
        *name_type = *r.out.name_type;
 
1048
 
 
1049
        /* Return result */
 
1050
        if (werror) {
 
1051
                *werror = r.out.result;
 
1052
        }
 
1053
 
 
1054
        return werror_to_ntstatus(r.out.result);
 
1055
}
 
1056
 
 
1057
NTSTATUS rpccli_wkssvc_NetrGetJoinableOus(struct rpc_pipe_client *cli,
 
1058
                                          TALLOC_CTX *mem_ctx,
 
1059
                                          const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1060
                                          const char *domain_name /* [in] [ref,charset(UTF16)] */,
 
1061
                                          const char *Account /* [in] [unique,charset(UTF16)] */,
 
1062
                                          const char *unknown /* [in] [unique,charset(UTF16)] */,
 
1063
                                          uint32_t *num_ous /* [in,out] [ref] */,
 
1064
                                          const char ***ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */,
 
1065
                                          WERROR *werror)
 
1066
{
 
1067
        struct wkssvc_NetrGetJoinableOus r;
 
1068
        NTSTATUS status;
 
1069
 
 
1070
        /* In parameters */
 
1071
        r.in.server_name = server_name;
 
1072
        r.in.domain_name = domain_name;
 
1073
        r.in.Account = Account;
 
1074
        r.in.unknown = unknown;
 
1075
        r.in.num_ous = num_ous;
 
1076
 
 
1077
        if (DEBUGLEVEL >= 10) {
 
1078
                NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinableOus, &r);
 
1079
        }
 
1080
 
 
1081
        status = cli->dispatch(cli,
 
1082
                                mem_ctx,
 
1083
                                &ndr_table_wkssvc,
 
1084
                                NDR_WKSSVC_NETRGETJOINABLEOUS,
 
1085
                                &r);
 
1086
 
 
1087
        if (!NT_STATUS_IS_OK(status)) {
 
1088
                return status;
 
1089
        }
 
1090
 
 
1091
        if (DEBUGLEVEL >= 10) {
 
1092
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinableOus, &r);
 
1093
        }
 
1094
 
 
1095
        if (NT_STATUS_IS_ERR(status)) {
 
1096
                return status;
 
1097
        }
 
1098
 
 
1099
        /* Return variables */
 
1100
        *num_ous = *r.out.num_ous;
 
1101
        *ous = *r.out.ous;
 
1102
 
 
1103
        /* Return result */
 
1104
        if (werror) {
 
1105
                *werror = r.out.result;
 
1106
        }
 
1107
 
 
1108
        return werror_to_ntstatus(r.out.result);
 
1109
}
 
1110
 
 
1111
NTSTATUS rpccli_wkssvc_NetrJoinDomain2(struct rpc_pipe_client *cli,
 
1112
                                       TALLOC_CTX *mem_ctx,
 
1113
                                       const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1114
                                       const char *domain_name /* [in] [ref,charset(UTF16)] */,
 
1115
                                       const char *account_ou /* [in] [unique,charset(UTF16)] */,
 
1116
                                       const char *admin_account /* [in] [unique,charset(UTF16)] */,
 
1117
                                       struct wkssvc_PasswordBuffer *encrypted_password /* [in] [unique] */,
 
1118
                                       uint32_t join_flags /* [in]  */,
 
1119
                                       WERROR *werror)
 
1120
{
 
1121
        struct wkssvc_NetrJoinDomain2 r;
 
1122
        NTSTATUS status;
 
1123
 
 
1124
        /* In parameters */
 
1125
        r.in.server_name = server_name;
 
1126
        r.in.domain_name = domain_name;
 
1127
        r.in.account_ou = account_ou;
 
1128
        r.in.admin_account = admin_account;
 
1129
        r.in.encrypted_password = encrypted_password;
 
1130
        r.in.join_flags = join_flags;
 
1131
 
 
1132
        if (DEBUGLEVEL >= 10) {
 
1133
                NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain2, &r);
 
1134
        }
 
1135
 
 
1136
        status = cli->dispatch(cli,
 
1137
                                mem_ctx,
 
1138
                                &ndr_table_wkssvc,
 
1139
                                NDR_WKSSVC_NETRJOINDOMAIN2,
 
1140
                                &r);
 
1141
 
 
1142
        if (!NT_STATUS_IS_OK(status)) {
 
1143
                return status;
 
1144
        }
 
1145
 
 
1146
        if (DEBUGLEVEL >= 10) {
 
1147
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain2, &r);
 
1148
        }
 
1149
 
 
1150
        if (NT_STATUS_IS_ERR(status)) {
 
1151
                return status;
 
1152
        }
 
1153
 
 
1154
        /* Return variables */
 
1155
 
 
1156
        /* Return result */
 
1157
        if (werror) {
 
1158
                *werror = r.out.result;
 
1159
        }
 
1160
 
 
1161
        return werror_to_ntstatus(r.out.result);
 
1162
}
 
1163
 
 
1164
NTSTATUS rpccli_wkssvc_NetrUnjoinDomain2(struct rpc_pipe_client *cli,
 
1165
                                         TALLOC_CTX *mem_ctx,
 
1166
                                         const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1167
                                         const char *account /* [in] [unique,charset(UTF16)] */,
 
1168
                                         struct wkssvc_PasswordBuffer *encrypted_password /* [in] [unique] */,
 
1169
                                         uint32_t unjoin_flags /* [in]  */,
 
1170
                                         WERROR *werror)
 
1171
{
 
1172
        struct wkssvc_NetrUnjoinDomain2 r;
 
1173
        NTSTATUS status;
 
1174
 
 
1175
        /* In parameters */
 
1176
        r.in.server_name = server_name;
 
1177
        r.in.account = account;
 
1178
        r.in.encrypted_password = encrypted_password;
 
1179
        r.in.unjoin_flags = unjoin_flags;
 
1180
 
 
1181
        if (DEBUGLEVEL >= 10) {
 
1182
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain2, &r);
 
1183
        }
 
1184
 
 
1185
        status = cli->dispatch(cli,
 
1186
                                mem_ctx,
 
1187
                                &ndr_table_wkssvc,
 
1188
                                NDR_WKSSVC_NETRUNJOINDOMAIN2,
 
1189
                                &r);
 
1190
 
 
1191
        if (!NT_STATUS_IS_OK(status)) {
 
1192
                return status;
 
1193
        }
 
1194
 
 
1195
        if (DEBUGLEVEL >= 10) {
 
1196
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain2, &r);
 
1197
        }
 
1198
 
 
1199
        if (NT_STATUS_IS_ERR(status)) {
 
1200
                return status;
 
1201
        }
 
1202
 
 
1203
        /* Return variables */
 
1204
 
 
1205
        /* Return result */
 
1206
        if (werror) {
 
1207
                *werror = r.out.result;
 
1208
        }
 
1209
 
 
1210
        return werror_to_ntstatus(r.out.result);
 
1211
}
 
1212
 
 
1213
NTSTATUS rpccli_wkssvc_NetrRenameMachineInDomain2(struct rpc_pipe_client *cli,
 
1214
                                                  TALLOC_CTX *mem_ctx,
 
1215
                                                  const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1216
                                                  const char *NewMachineName /* [in] [unique,charset(UTF16)] */,
 
1217
                                                  const char *Account /* [in] [unique,charset(UTF16)] */,
 
1218
                                                  struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
 
1219
                                                  uint32_t RenameOptions /* [in]  */,
 
1220
                                                  WERROR *werror)
 
1221
{
 
1222
        struct wkssvc_NetrRenameMachineInDomain2 r;
 
1223
        NTSTATUS status;
 
1224
 
 
1225
        /* In parameters */
 
1226
        r.in.server_name = server_name;
 
1227
        r.in.NewMachineName = NewMachineName;
 
1228
        r.in.Account = Account;
 
1229
        r.in.EncryptedPassword = EncryptedPassword;
 
1230
        r.in.RenameOptions = RenameOptions;
 
1231
 
 
1232
        if (DEBUGLEVEL >= 10) {
 
1233
                NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r);
 
1234
        }
 
1235
 
 
1236
        status = cli->dispatch(cli,
 
1237
                                mem_ctx,
 
1238
                                &ndr_table_wkssvc,
 
1239
                                NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2,
 
1240
                                &r);
 
1241
 
 
1242
        if (!NT_STATUS_IS_OK(status)) {
 
1243
                return status;
 
1244
        }
 
1245
 
 
1246
        if (DEBUGLEVEL >= 10) {
 
1247
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, &r);
 
1248
        }
 
1249
 
 
1250
        if (NT_STATUS_IS_ERR(status)) {
 
1251
                return status;
 
1252
        }
 
1253
 
 
1254
        /* Return variables */
 
1255
 
 
1256
        /* Return result */
 
1257
        if (werror) {
 
1258
                *werror = r.out.result;
 
1259
        }
 
1260
 
 
1261
        return werror_to_ntstatus(r.out.result);
 
1262
}
 
1263
 
 
1264
NTSTATUS rpccli_wkssvc_NetrValidateName2(struct rpc_pipe_client *cli,
 
1265
                                         TALLOC_CTX *mem_ctx,
 
1266
                                         const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1267
                                         const char *name /* [in] [ref,charset(UTF16)] */,
 
1268
                                         const char *Account /* [in] [unique,charset(UTF16)] */,
 
1269
                                         struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
 
1270
                                         enum wkssvc_NetValidateNameType name_type /* [in]  */,
 
1271
                                         WERROR *werror)
 
1272
{
 
1273
        struct wkssvc_NetrValidateName2 r;
 
1274
        NTSTATUS status;
 
1275
 
 
1276
        /* In parameters */
 
1277
        r.in.server_name = server_name;
 
1278
        r.in.name = name;
 
1279
        r.in.Account = Account;
 
1280
        r.in.EncryptedPassword = EncryptedPassword;
 
1281
        r.in.name_type = name_type;
 
1282
 
 
1283
        if (DEBUGLEVEL >= 10) {
 
1284
                NDR_PRINT_IN_DEBUG(wkssvc_NetrValidateName2, &r);
 
1285
        }
 
1286
 
 
1287
        status = cli->dispatch(cli,
 
1288
                                mem_ctx,
 
1289
                                &ndr_table_wkssvc,
 
1290
                                NDR_WKSSVC_NETRVALIDATENAME2,
 
1291
                                &r);
 
1292
 
 
1293
        if (!NT_STATUS_IS_OK(status)) {
 
1294
                return status;
 
1295
        }
 
1296
 
 
1297
        if (DEBUGLEVEL >= 10) {
 
1298
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrValidateName2, &r);
 
1299
        }
 
1300
 
 
1301
        if (NT_STATUS_IS_ERR(status)) {
 
1302
                return status;
 
1303
        }
 
1304
 
 
1305
        /* Return variables */
 
1306
 
 
1307
        /* Return result */
 
1308
        if (werror) {
 
1309
                *werror = r.out.result;
 
1310
        }
 
1311
 
 
1312
        return werror_to_ntstatus(r.out.result);
 
1313
}
 
1314
 
 
1315
NTSTATUS rpccli_wkssvc_NetrGetJoinableOus2(struct rpc_pipe_client *cli,
 
1316
                                           TALLOC_CTX *mem_ctx,
 
1317
                                           const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1318
                                           const char *domain_name /* [in] [ref,charset(UTF16)] */,
 
1319
                                           const char *Account /* [in] [unique,charset(UTF16)] */,
 
1320
                                           struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
 
1321
                                           uint32_t *num_ous /* [in,out] [ref] */,
 
1322
                                           const char ***ous /* [out] [ref,charset(UTF16),size_is(,*num_ous)] */,
 
1323
                                           WERROR *werror)
 
1324
{
 
1325
        struct wkssvc_NetrGetJoinableOus2 r;
 
1326
        NTSTATUS status;
 
1327
 
 
1328
        /* In parameters */
 
1329
        r.in.server_name = server_name;
 
1330
        r.in.domain_name = domain_name;
 
1331
        r.in.Account = Account;
 
1332
        r.in.EncryptedPassword = EncryptedPassword;
 
1333
        r.in.num_ous = num_ous;
 
1334
 
 
1335
        if (DEBUGLEVEL >= 10) {
 
1336
                NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinableOus2, &r);
 
1337
        }
 
1338
 
 
1339
        status = cli->dispatch(cli,
 
1340
                                mem_ctx,
 
1341
                                &ndr_table_wkssvc,
 
1342
                                NDR_WKSSVC_NETRGETJOINABLEOUS2,
 
1343
                                &r);
 
1344
 
 
1345
        if (!NT_STATUS_IS_OK(status)) {
 
1346
                return status;
 
1347
        }
 
1348
 
 
1349
        if (DEBUGLEVEL >= 10) {
 
1350
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinableOus2, &r);
 
1351
        }
 
1352
 
 
1353
        if (NT_STATUS_IS_ERR(status)) {
 
1354
                return status;
 
1355
        }
 
1356
 
 
1357
        /* Return variables */
 
1358
        *num_ous = *r.out.num_ous;
 
1359
        *ous = *r.out.ous;
 
1360
 
 
1361
        /* Return result */
 
1362
        if (werror) {
 
1363
                *werror = r.out.result;
 
1364
        }
 
1365
 
 
1366
        return werror_to_ntstatus(r.out.result);
 
1367
}
 
1368
 
 
1369
NTSTATUS rpccli_wkssvc_NetrAddAlternateComputerName(struct rpc_pipe_client *cli,
 
1370
                                                    TALLOC_CTX *mem_ctx,
 
1371
                                                    const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1372
                                                    const char *NewAlternateMachineName /* [in] [unique,charset(UTF16)] */,
 
1373
                                                    const char *Account /* [in] [unique,charset(UTF16)] */,
 
1374
                                                    struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
 
1375
                                                    uint32_t Reserved /* [in]  */,
 
1376
                                                    WERROR *werror)
 
1377
{
 
1378
        struct wkssvc_NetrAddAlternateComputerName r;
 
1379
        NTSTATUS status;
 
1380
 
 
1381
        /* In parameters */
 
1382
        r.in.server_name = server_name;
 
1383
        r.in.NewAlternateMachineName = NewAlternateMachineName;
 
1384
        r.in.Account = Account;
 
1385
        r.in.EncryptedPassword = EncryptedPassword;
 
1386
        r.in.Reserved = Reserved;
 
1387
 
 
1388
        if (DEBUGLEVEL >= 10) {
 
1389
                NDR_PRINT_IN_DEBUG(wkssvc_NetrAddAlternateComputerName, &r);
 
1390
        }
 
1391
 
 
1392
        status = cli->dispatch(cli,
 
1393
                                mem_ctx,
 
1394
                                &ndr_table_wkssvc,
 
1395
                                NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME,
 
1396
                                &r);
 
1397
 
 
1398
        if (!NT_STATUS_IS_OK(status)) {
 
1399
                return status;
 
1400
        }
 
1401
 
 
1402
        if (DEBUGLEVEL >= 10) {
 
1403
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrAddAlternateComputerName, &r);
 
1404
        }
 
1405
 
 
1406
        if (NT_STATUS_IS_ERR(status)) {
 
1407
                return status;
 
1408
        }
 
1409
 
 
1410
        /* Return variables */
 
1411
 
 
1412
        /* Return result */
 
1413
        if (werror) {
 
1414
                *werror = r.out.result;
 
1415
        }
 
1416
 
 
1417
        return werror_to_ntstatus(r.out.result);
 
1418
}
 
1419
 
 
1420
NTSTATUS rpccli_wkssvc_NetrRemoveAlternateComputerName(struct rpc_pipe_client *cli,
 
1421
                                                       TALLOC_CTX *mem_ctx,
 
1422
                                                       const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1423
                                                       const char *AlternateMachineNameToRemove /* [in] [unique,charset(UTF16)] */,
 
1424
                                                       const char *Account /* [in] [unique,charset(UTF16)] */,
 
1425
                                                       struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
 
1426
                                                       uint32_t Reserved /* [in]  */,
 
1427
                                                       WERROR *werror)
 
1428
{
 
1429
        struct wkssvc_NetrRemoveAlternateComputerName r;
 
1430
        NTSTATUS status;
 
1431
 
 
1432
        /* In parameters */
 
1433
        r.in.server_name = server_name;
 
1434
        r.in.AlternateMachineNameToRemove = AlternateMachineNameToRemove;
 
1435
        r.in.Account = Account;
 
1436
        r.in.EncryptedPassword = EncryptedPassword;
 
1437
        r.in.Reserved = Reserved;
 
1438
 
 
1439
        if (DEBUGLEVEL >= 10) {
 
1440
                NDR_PRINT_IN_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &r);
 
1441
        }
 
1442
 
 
1443
        status = cli->dispatch(cli,
 
1444
                                mem_ctx,
 
1445
                                &ndr_table_wkssvc,
 
1446
                                NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME,
 
1447
                                &r);
 
1448
 
 
1449
        if (!NT_STATUS_IS_OK(status)) {
 
1450
                return status;
 
1451
        }
 
1452
 
 
1453
        if (DEBUGLEVEL >= 10) {
 
1454
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrRemoveAlternateComputerName, &r);
 
1455
        }
 
1456
 
 
1457
        if (NT_STATUS_IS_ERR(status)) {
 
1458
                return status;
 
1459
        }
 
1460
 
 
1461
        /* Return variables */
 
1462
 
 
1463
        /* Return result */
 
1464
        if (werror) {
 
1465
                *werror = r.out.result;
 
1466
        }
 
1467
 
 
1468
        return werror_to_ntstatus(r.out.result);
 
1469
}
 
1470
 
 
1471
NTSTATUS rpccli_wkssvc_NetrSetPrimaryComputername(struct rpc_pipe_client *cli,
 
1472
                                                  TALLOC_CTX *mem_ctx,
 
1473
                                                  const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1474
                                                  const char *primary_name /* [in] [unique,charset(UTF16)] */,
 
1475
                                                  const char *Account /* [in] [unique,charset(UTF16)] */,
 
1476
                                                  struct wkssvc_PasswordBuffer *EncryptedPassword /* [in] [unique] */,
 
1477
                                                  uint32_t Reserved /* [in]  */,
 
1478
                                                  WERROR *werror)
 
1479
{
 
1480
        struct wkssvc_NetrSetPrimaryComputername r;
 
1481
        NTSTATUS status;
 
1482
 
 
1483
        /* In parameters */
 
1484
        r.in.server_name = server_name;
 
1485
        r.in.primary_name = primary_name;
 
1486
        r.in.Account = Account;
 
1487
        r.in.EncryptedPassword = EncryptedPassword;
 
1488
        r.in.Reserved = Reserved;
 
1489
 
 
1490
        if (DEBUGLEVEL >= 10) {
 
1491
                NDR_PRINT_IN_DEBUG(wkssvc_NetrSetPrimaryComputername, &r);
 
1492
        }
 
1493
 
 
1494
        status = cli->dispatch(cli,
 
1495
                                mem_ctx,
 
1496
                                &ndr_table_wkssvc,
 
1497
                                NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME,
 
1498
                                &r);
 
1499
 
 
1500
        if (!NT_STATUS_IS_OK(status)) {
 
1501
                return status;
 
1502
        }
 
1503
 
 
1504
        if (DEBUGLEVEL >= 10) {
 
1505
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrSetPrimaryComputername, &r);
 
1506
        }
 
1507
 
 
1508
        if (NT_STATUS_IS_ERR(status)) {
 
1509
                return status;
 
1510
        }
 
1511
 
 
1512
        /* Return variables */
 
1513
 
 
1514
        /* Return result */
 
1515
        if (werror) {
 
1516
                *werror = r.out.result;
 
1517
        }
 
1518
 
 
1519
        return werror_to_ntstatus(r.out.result);
 
1520
}
 
1521
 
 
1522
NTSTATUS rpccli_wkssvc_NetrEnumerateComputerNames(struct rpc_pipe_client *cli,
 
1523
                                                  TALLOC_CTX *mem_ctx,
 
1524
                                                  const char *server_name /* [in] [unique,charset(UTF16)] */,
 
1525
                                                  enum wkssvc_ComputerNameType name_type /* [in]  */,
 
1526
                                                  uint32_t Reserved /* [in]  */,
 
1527
                                                  struct wkssvc_ComputerNamesCtr **ctr /* [out] [ref] */,
 
1528
                                                  WERROR *werror)
 
1529
{
 
1530
        struct wkssvc_NetrEnumerateComputerNames r;
 
1531
        NTSTATUS status;
 
1532
 
 
1533
        /* In parameters */
 
1534
        r.in.server_name = server_name;
 
1535
        r.in.name_type = name_type;
 
1536
        r.in.Reserved = Reserved;
 
1537
 
 
1538
        if (DEBUGLEVEL >= 10) {
 
1539
                NDR_PRINT_IN_DEBUG(wkssvc_NetrEnumerateComputerNames, &r);
 
1540
        }
 
1541
 
 
1542
        status = cli->dispatch(cli,
 
1543
                                mem_ctx,
 
1544
                                &ndr_table_wkssvc,
 
1545
                                NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES,
 
1546
                                &r);
 
1547
 
 
1548
        if (!NT_STATUS_IS_OK(status)) {
 
1549
                return status;
 
1550
        }
 
1551
 
 
1552
        if (DEBUGLEVEL >= 10) {
 
1553
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrEnumerateComputerNames, &r);
 
1554
        }
 
1555
 
 
1556
        if (NT_STATUS_IS_ERR(status)) {
 
1557
                return status;
 
1558
        }
 
1559
 
 
1560
        /* Return variables */
 
1561
        *ctr = *r.out.ctr;
 
1562
 
 
1563
        /* Return result */
 
1564
        if (werror) {
 
1565
                *werror = r.out.result;
 
1566
        }
 
1567
 
 
1568
        return werror_to_ntstatus(r.out.result);
 
1569
}
 
1570