← Back to branch summary

~ubuntu-branches/ubuntu/vivid/samba/vivid

« back to all changes in this revision

Viewing changes to librpc/gen_ndr/srv_wkssvc.c

  • Committer: Package Import Robot
  • Author(s): Chuck Short
  • Date: 2011-12-21 13:18:04 UTC
  • mfrom: (0.39.21 sid)
  • Revision ID: package-import@ubuntu.com-20111221131804-xtlr39wx6njehxxr
Tags: 2:3.6.1-3ubuntu1
* Merge from Debian testing.  Remaining changes:
  + debian/patches/VERSION.patch:
    - set SAMBA_VERSION_SUFFIX to Ubuntu.
  + debian/patches/error-trans.fix-276472:
    - Add the translation of Unix Error code -ENOTSUP to NT Error Code
    - NT_STATUS_NOT_SUPPORTED to prevent the Permission denied error.
  + debian/smb.conf:
    - add "(Samba, Ubuntu)" to server string.
    - comment out the default [homes] share, and add a comment about
      "valid users = %S" to show users how to restrict access to
      \\server\username to only username.
    - Set 'usershare allow guests', so that usershare admins are 
      allowed to create public shares in addition to authenticated
      ones.
    - add map to guest = Bad user, maps bad username to guest access.
  + debian/samba-common.config:
    - Do not change priority to high if dhclient3 is installed.
    - Use priority medium instead of high for the workgroup question.
  + debian/control:
    - Don't build against or suggest ctdb.
    - Add dependency on samba-common-bin to samba.
  + Add ufw integration:
    - Created debian/samba.ufw.profile
    - debian/rules, debian/samba.dirs, debian/samba.files: install
      profile
    - debian/control: have samba suggest ufw
  + Add apport hook:
    - Created debian/source_samba.py.
    - debian/rules, debian/samba.dirs, debian/samba-common-bin.files: install
  + Switch to upstart:
    - Add debian/samba.{nmbd,smbd}.upstart.
  + debian/samba.logrotate, debian/samba-common.dhcp, debian/samba.if-up:
    - Make them upstart compatible
  + debian/samba.postinst: 
    - Avoid scary pdbedit warnings on first import.
  + debian/samba-common.postinst: Add more informative error message for
    the case where smb.conf was manually deleted
  + debian/patches/fix-debuglevel-name-conflict.patch: don't use 'debug_level'
    as a global variable name in an NSS module 
  + Dropped:
    - debian/patches/error-trans.fix-276472
    - debian/patches/fix-debuglevel-name-conflict.patch

Show diffs side-by-side

added added

removed removed

Lines of Context:
librpc/gen_ndr/srv_wkssvc.c
1
 
/*
2
 
 * Unix SMB/CIFS implementation.
3
 
 * server auto-generated by pidl. DO NOT MODIFY!
4
 
 */
5
 
 
6
 
#include "includes.h"
7
 
#include "../librpc/gen_ndr/srv_wkssvc.h"
8
 
 
9
 
static bool api_wkssvc_NetWkstaGetInfo(pipes_struct *p)
10
 
{
11
 
        const struct ndr_interface_call *call;
12
 
        struct ndr_pull *pull;
13
 
        struct ndr_push *push;
14
 
        enum ndr_err_code ndr_err;
15
 
        DATA_BLOB blob;
16
 
        struct wkssvc_NetWkstaGetInfo *r;
17
 
 
18
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETWKSTAGETINFO];
19
 
 
20
 
        r = talloc(talloc_tos(), struct wkssvc_NetWkstaGetInfo);
21
 
        if (r == NULL) {
22
 
                return false;
23
 
        }
24
 
 
25
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
26
 
                talloc_free(r);
27
 
                return false;
28
 
        }
29
 
 
30
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
31
 
        if (pull == NULL) {
32
 
                talloc_free(r);
33
 
                return false;
34
 
        }
35
 
 
36
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
37
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
38
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
39
 
                talloc_free(r);
40
 
                return false;
41
 
        }
42
 
 
43
 
        if (DEBUGLEVEL >= 10) {
44
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaGetInfo, r);
45
 
        }
46
 
 
47
 
        ZERO_STRUCT(r->out);
48
 
        r->out.info = talloc_zero(r, union wkssvc_NetWkstaInfo);
49
 
        if (r->out.info == NULL) {
50
 
                talloc_free(r);
51
 
                return false;
52
 
        }
53
 
 
54
 
        r->out.result = _wkssvc_NetWkstaGetInfo(p, r);
55
 
 
56
 
        if (p->rng_fault_state) {
57
 
                talloc_free(r);
58
 
                /* Return true here, srv_pipe_hnd.c will take care */
59
 
                return true;
60
 
        }
61
 
 
62
 
        if (DEBUGLEVEL >= 10) {
63
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaGetInfo, r);
64
 
        }
65
 
 
66
 
        push = ndr_push_init_ctx(r, NULL);
67
 
        if (push == NULL) {
68
 
                talloc_free(r);
69
 
                return false;
70
 
        }
71
 
 
72
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
73
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
74
 
                talloc_free(r);
75
 
                return false;
76
 
        }
77
 
 
78
 
        blob = ndr_push_blob(push);
79
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
80
 
                talloc_free(r);
81
 
                return false;
82
 
        }
83
 
 
84
 
        talloc_free(r);
85
 
 
86
 
        return true;
87
 
}
88
 
 
89
 
static bool api_wkssvc_NetWkstaSetInfo(pipes_struct *p)
90
 
{
91
 
        const struct ndr_interface_call *call;
92
 
        struct ndr_pull *pull;
93
 
        struct ndr_push *push;
94
 
        enum ndr_err_code ndr_err;
95
 
        DATA_BLOB blob;
96
 
        struct wkssvc_NetWkstaSetInfo *r;
97
 
 
98
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETWKSTASETINFO];
99
 
 
100
 
        r = talloc(talloc_tos(), struct wkssvc_NetWkstaSetInfo);
101
 
        if (r == NULL) {
102
 
                return false;
103
 
        }
104
 
 
105
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
106
 
                talloc_free(r);
107
 
                return false;
108
 
        }
109
 
 
110
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
111
 
        if (pull == NULL) {
112
 
                talloc_free(r);
113
 
                return false;
114
 
        }
115
 
 
116
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
117
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
118
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
119
 
                talloc_free(r);
120
 
                return false;
121
 
        }
122
 
 
123
 
        if (DEBUGLEVEL >= 10) {
124
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaSetInfo, r);
125
 
        }
126
 
 
127
 
        ZERO_STRUCT(r->out);
128
 
        r->out.parm_error = r->in.parm_error;
129
 
        r->out.result = _wkssvc_NetWkstaSetInfo(p, r);
130
 
 
131
 
        if (p->rng_fault_state) {
132
 
                talloc_free(r);
133
 
                /* Return true here, srv_pipe_hnd.c will take care */
134
 
                return true;
135
 
        }
136
 
 
137
 
        if (DEBUGLEVEL >= 10) {
138
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaSetInfo, r);
139
 
        }
140
 
 
141
 
        push = ndr_push_init_ctx(r, NULL);
142
 
        if (push == NULL) {
143
 
                talloc_free(r);
144
 
                return false;
145
 
        }
146
 
 
147
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
148
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
149
 
                talloc_free(r);
150
 
                return false;
151
 
        }
152
 
 
153
 
        blob = ndr_push_blob(push);
154
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
155
 
                talloc_free(r);
156
 
                return false;
157
 
        }
158
 
 
159
 
        talloc_free(r);
160
 
 
161
 
        return true;
162
 
}
163
 
 
164
 
static bool api_wkssvc_NetWkstaEnumUsers(pipes_struct *p)
165
 
{
166
 
        const struct ndr_interface_call *call;
167
 
        struct ndr_pull *pull;
168
 
        struct ndr_push *push;
169
 
        enum ndr_err_code ndr_err;
170
 
        DATA_BLOB blob;
171
 
        struct wkssvc_NetWkstaEnumUsers *r;
172
 
 
173
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETWKSTAENUMUSERS];
174
 
 
175
 
        r = talloc(talloc_tos(), struct wkssvc_NetWkstaEnumUsers);
176
 
        if (r == NULL) {
177
 
                return false;
178
 
        }
179
 
 
180
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
181
 
                talloc_free(r);
182
 
                return false;
183
 
        }
184
 
 
185
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
186
 
        if (pull == NULL) {
187
 
                talloc_free(r);
188
 
                return false;
189
 
        }
190
 
 
191
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
192
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
193
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
194
 
                talloc_free(r);
195
 
                return false;
196
 
        }
197
 
 
198
 
        if (DEBUGLEVEL >= 10) {
199
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaEnumUsers, r);
200
 
        }
201
 
 
202
 
        ZERO_STRUCT(r->out);
203
 
        r->out.info = r->in.info;
204
 
        r->out.resume_handle = r->in.resume_handle;
205
 
        r->out.entries_read = talloc_zero(r, uint32_t);
206
 
        if (r->out.entries_read == NULL) {
207
 
                talloc_free(r);
208
 
                return false;
209
 
        }
210
 
 
211
 
        r->out.result = _wkssvc_NetWkstaEnumUsers(p, r);
212
 
 
213
 
        if (p->rng_fault_state) {
214
 
                talloc_free(r);
215
 
                /* Return true here, srv_pipe_hnd.c will take care */
216
 
                return true;
217
 
        }
218
 
 
219
 
        if (DEBUGLEVEL >= 10) {
220
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaEnumUsers, r);
221
 
        }
222
 
 
223
 
        push = ndr_push_init_ctx(r, NULL);
224
 
        if (push == NULL) {
225
 
                talloc_free(r);
226
 
                return false;
227
 
        }
228
 
 
229
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
230
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
231
 
                talloc_free(r);
232
 
                return false;
233
 
        }
234
 
 
235
 
        blob = ndr_push_blob(push);
236
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
237
 
                talloc_free(r);
238
 
                return false;
239
 
        }
240
 
 
241
 
        talloc_free(r);
242
 
 
243
 
        return true;
244
 
}
245
 
 
246
 
static bool api_wkssvc_NetrWkstaUserGetInfo(pipes_struct *p)
247
 
{
248
 
        const struct ndr_interface_call *call;
249
 
        struct ndr_pull *pull;
250
 
        struct ndr_push *push;
251
 
        enum ndr_err_code ndr_err;
252
 
        DATA_BLOB blob;
253
 
        struct wkssvc_NetrWkstaUserGetInfo *r;
254
 
 
255
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWKSTAUSERGETINFO];
256
 
 
257
 
        r = talloc(talloc_tos(), struct wkssvc_NetrWkstaUserGetInfo);
258
 
        if (r == NULL) {
259
 
                return false;
260
 
        }
261
 
 
262
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
263
 
                talloc_free(r);
264
 
                return false;
265
 
        }
266
 
 
267
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
268
 
        if (pull == NULL) {
269
 
                talloc_free(r);
270
 
                return false;
271
 
        }
272
 
 
273
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
274
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
275
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
276
 
                talloc_free(r);
277
 
                return false;
278
 
        }
279
 
 
280
 
        if (DEBUGLEVEL >= 10) {
281
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaUserGetInfo, r);
282
 
        }
283
 
 
284
 
        ZERO_STRUCT(r->out);
285
 
        r->out.info = talloc_zero(r, union wkssvc_NetrWkstaUserInfo);
286
 
        if (r->out.info == NULL) {
287
 
                talloc_free(r);
288
 
                return false;
289
 
        }
290
 
 
291
 
        r->out.result = _wkssvc_NetrWkstaUserGetInfo(p, r);
292
 
 
293
 
        if (p->rng_fault_state) {
294
 
                talloc_free(r);
295
 
                /* Return true here, srv_pipe_hnd.c will take care */
296
 
                return true;
297
 
        }
298
 
 
299
 
        if (DEBUGLEVEL >= 10) {
300
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaUserGetInfo, r);
301
 
        }
302
 
 
303
 
        push = ndr_push_init_ctx(r, NULL);
304
 
        if (push == NULL) {
305
 
                talloc_free(r);
306
 
                return false;
307
 
        }
308
 
 
309
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
310
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
311
 
                talloc_free(r);
312
 
                return false;
313
 
        }
314
 
 
315
 
        blob = ndr_push_blob(push);
316
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
317
 
                talloc_free(r);
318
 
                return false;
319
 
        }
320
 
 
321
 
        talloc_free(r);
322
 
 
323
 
        return true;
324
 
}
325
 
 
326
 
static bool api_wkssvc_NetrWkstaUserSetInfo(pipes_struct *p)
327
 
{
328
 
        const struct ndr_interface_call *call;
329
 
        struct ndr_pull *pull;
330
 
        struct ndr_push *push;
331
 
        enum ndr_err_code ndr_err;
332
 
        DATA_BLOB blob;
333
 
        struct wkssvc_NetrWkstaUserSetInfo *r;
334
 
 
335
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWKSTAUSERSETINFO];
336
 
 
337
 
        r = talloc(talloc_tos(), struct wkssvc_NetrWkstaUserSetInfo);
338
 
        if (r == NULL) {
339
 
                return false;
340
 
        }
341
 
 
342
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
343
 
                talloc_free(r);
344
 
                return false;
345
 
        }
346
 
 
347
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
348
 
        if (pull == NULL) {
349
 
                talloc_free(r);
350
 
                return false;
351
 
        }
352
 
 
353
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
354
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
355
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
356
 
                talloc_free(r);
357
 
                return false;
358
 
        }
359
 
 
360
 
        if (DEBUGLEVEL >= 10) {
361
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaUserSetInfo, r);
362
 
        }
363
 
 
364
 
        ZERO_STRUCT(r->out);
365
 
        r->out.parm_err = r->in.parm_err;
366
 
        r->out.result = _wkssvc_NetrWkstaUserSetInfo(p, r);
367
 
 
368
 
        if (p->rng_fault_state) {
369
 
                talloc_free(r);
370
 
                /* Return true here, srv_pipe_hnd.c will take care */
371
 
                return true;
372
 
        }
373
 
 
374
 
        if (DEBUGLEVEL >= 10) {
375
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaUserSetInfo, r);
376
 
        }
377
 
 
378
 
        push = ndr_push_init_ctx(r, NULL);
379
 
        if (push == NULL) {
380
 
                talloc_free(r);
381
 
                return false;
382
 
        }
383
 
 
384
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
385
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
386
 
                talloc_free(r);
387
 
                return false;
388
 
        }
389
 
 
390
 
        blob = ndr_push_blob(push);
391
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
392
 
                talloc_free(r);
393
 
                return false;
394
 
        }
395
 
 
396
 
        talloc_free(r);
397
 
 
398
 
        return true;
399
 
}
400
 
 
401
 
static bool api_wkssvc_NetWkstaTransportEnum(pipes_struct *p)
402
 
{
403
 
        const struct ndr_interface_call *call;
404
 
        struct ndr_pull *pull;
405
 
        struct ndr_push *push;
406
 
        enum ndr_err_code ndr_err;
407
 
        DATA_BLOB blob;
408
 
        struct wkssvc_NetWkstaTransportEnum *r;
409
 
 
410
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETWKSTATRANSPORTENUM];
411
 
 
412
 
        r = talloc(talloc_tos(), struct wkssvc_NetWkstaTransportEnum);
413
 
        if (r == NULL) {
414
 
                return false;
415
 
        }
416
 
 
417
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
418
 
                talloc_free(r);
419
 
                return false;
420
 
        }
421
 
 
422
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
423
 
        if (pull == NULL) {
424
 
                talloc_free(r);
425
 
                return false;
426
 
        }
427
 
 
428
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
429
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
430
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
431
 
                talloc_free(r);
432
 
                return false;
433
 
        }
434
 
 
435
 
        if (DEBUGLEVEL >= 10) {
436
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetWkstaTransportEnum, r);
437
 
        }
438
 
 
439
 
        ZERO_STRUCT(r->out);
440
 
        r->out.info = r->in.info;
441
 
        r->out.resume_handle = r->in.resume_handle;
442
 
        r->out.total_entries = talloc_zero(r, uint32_t);
443
 
        if (r->out.total_entries == NULL) {
444
 
                talloc_free(r);
445
 
                return false;
446
 
        }
447
 
 
448
 
        r->out.result = _wkssvc_NetWkstaTransportEnum(p, r);
449
 
 
450
 
        if (p->rng_fault_state) {
451
 
                talloc_free(r);
452
 
                /* Return true here, srv_pipe_hnd.c will take care */
453
 
                return true;
454
 
        }
455
 
 
456
 
        if (DEBUGLEVEL >= 10) {
457
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetWkstaTransportEnum, r);
458
 
        }
459
 
 
460
 
        push = ndr_push_init_ctx(r, NULL);
461
 
        if (push == NULL) {
462
 
                talloc_free(r);
463
 
                return false;
464
 
        }
465
 
 
466
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
467
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
468
 
                talloc_free(r);
469
 
                return false;
470
 
        }
471
 
 
472
 
        blob = ndr_push_blob(push);
473
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
474
 
                talloc_free(r);
475
 
                return false;
476
 
        }
477
 
 
478
 
        talloc_free(r);
479
 
 
480
 
        return true;
481
 
}
482
 
 
483
 
static bool api_wkssvc_NetrWkstaTransportAdd(pipes_struct *p)
484
 
{
485
 
        const struct ndr_interface_call *call;
486
 
        struct ndr_pull *pull;
487
 
        struct ndr_push *push;
488
 
        enum ndr_err_code ndr_err;
489
 
        DATA_BLOB blob;
490
 
        struct wkssvc_NetrWkstaTransportAdd *r;
491
 
 
492
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWKSTATRANSPORTADD];
493
 
 
494
 
        r = talloc(talloc_tos(), struct wkssvc_NetrWkstaTransportAdd);
495
 
        if (r == NULL) {
496
 
                return false;
497
 
        }
498
 
 
499
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
500
 
                talloc_free(r);
501
 
                return false;
502
 
        }
503
 
 
504
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
505
 
        if (pull == NULL) {
506
 
                talloc_free(r);
507
 
                return false;
508
 
        }
509
 
 
510
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
511
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
512
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
513
 
                talloc_free(r);
514
 
                return false;
515
 
        }
516
 
 
517
 
        if (DEBUGLEVEL >= 10) {
518
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaTransportAdd, r);
519
 
        }
520
 
 
521
 
        ZERO_STRUCT(r->out);
522
 
        r->out.parm_err = r->in.parm_err;
523
 
        r->out.result = _wkssvc_NetrWkstaTransportAdd(p, r);
524
 
 
525
 
        if (p->rng_fault_state) {
526
 
                talloc_free(r);
527
 
                /* Return true here, srv_pipe_hnd.c will take care */
528
 
                return true;
529
 
        }
530
 
 
531
 
        if (DEBUGLEVEL >= 10) {
532
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaTransportAdd, r);
533
 
        }
534
 
 
535
 
        push = ndr_push_init_ctx(r, NULL);
536
 
        if (push == NULL) {
537
 
                talloc_free(r);
538
 
                return false;
539
 
        }
540
 
 
541
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
542
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
543
 
                talloc_free(r);
544
 
                return false;
545
 
        }
546
 
 
547
 
        blob = ndr_push_blob(push);
548
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
549
 
                talloc_free(r);
550
 
                return false;
551
 
        }
552
 
 
553
 
        talloc_free(r);
554
 
 
555
 
        return true;
556
 
}
557
 
 
558
 
static bool api_wkssvc_NetrWkstaTransportDel(pipes_struct *p)
559
 
{
560
 
        const struct ndr_interface_call *call;
561
 
        struct ndr_pull *pull;
562
 
        struct ndr_push *push;
563
 
        enum ndr_err_code ndr_err;
564
 
        DATA_BLOB blob;
565
 
        struct wkssvc_NetrWkstaTransportDel *r;
566
 
 
567
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWKSTATRANSPORTDEL];
568
 
 
569
 
        r = talloc(talloc_tos(), struct wkssvc_NetrWkstaTransportDel);
570
 
        if (r == NULL) {
571
 
                return false;
572
 
        }
573
 
 
574
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
575
 
                talloc_free(r);
576
 
                return false;
577
 
        }
578
 
 
579
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
580
 
        if (pull == NULL) {
581
 
                talloc_free(r);
582
 
                return false;
583
 
        }
584
 
 
585
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
586
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
587
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
588
 
                talloc_free(r);
589
 
                return false;
590
 
        }
591
 
 
592
 
        if (DEBUGLEVEL >= 10) {
593
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWkstaTransportDel, r);
594
 
        }
595
 
 
596
 
        r->out.result = _wkssvc_NetrWkstaTransportDel(p, r);
597
 
 
598
 
        if (p->rng_fault_state) {
599
 
                talloc_free(r);
600
 
                /* Return true here, srv_pipe_hnd.c will take care */
601
 
                return true;
602
 
        }
603
 
 
604
 
        if (DEBUGLEVEL >= 10) {
605
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWkstaTransportDel, r);
606
 
        }
607
 
 
608
 
        push = ndr_push_init_ctx(r, NULL);
609
 
        if (push == NULL) {
610
 
                talloc_free(r);
611
 
                return false;
612
 
        }
613
 
 
614
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
615
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
616
 
                talloc_free(r);
617
 
                return false;
618
 
        }
619
 
 
620
 
        blob = ndr_push_blob(push);
621
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
622
 
                talloc_free(r);
623
 
                return false;
624
 
        }
625
 
 
626
 
        talloc_free(r);
627
 
 
628
 
        return true;
629
 
}
630
 
 
631
 
static bool api_wkssvc_NetrUseAdd(pipes_struct *p)
632
 
{
633
 
        const struct ndr_interface_call *call;
634
 
        struct ndr_pull *pull;
635
 
        struct ndr_push *push;
636
 
        enum ndr_err_code ndr_err;
637
 
        DATA_BLOB blob;
638
 
        struct wkssvc_NetrUseAdd *r;
639
 
 
640
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUSEADD];
641
 
 
642
 
        r = talloc(talloc_tos(), struct wkssvc_NetrUseAdd);
643
 
        if (r == NULL) {
644
 
                return false;
645
 
        }
646
 
 
647
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
648
 
                talloc_free(r);
649
 
                return false;
650
 
        }
651
 
 
652
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
653
 
        if (pull == NULL) {
654
 
                talloc_free(r);
655
 
                return false;
656
 
        }
657
 
 
658
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
659
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
660
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
661
 
                talloc_free(r);
662
 
                return false;
663
 
        }
664
 
 
665
 
        if (DEBUGLEVEL >= 10) {
666
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUseAdd, r);
667
 
        }
668
 
 
669
 
        ZERO_STRUCT(r->out);
670
 
        r->out.parm_err = r->in.parm_err;
671
 
        r->out.result = _wkssvc_NetrUseAdd(p, r);
672
 
 
673
 
        if (p->rng_fault_state) {
674
 
                talloc_free(r);
675
 
                /* Return true here, srv_pipe_hnd.c will take care */
676
 
                return true;
677
 
        }
678
 
 
679
 
        if (DEBUGLEVEL >= 10) {
680
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseAdd, r);
681
 
        }
682
 
 
683
 
        push = ndr_push_init_ctx(r, NULL);
684
 
        if (push == NULL) {
685
 
                talloc_free(r);
686
 
                return false;
687
 
        }
688
 
 
689
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
690
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
691
 
                talloc_free(r);
692
 
                return false;
693
 
        }
694
 
 
695
 
        blob = ndr_push_blob(push);
696
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
697
 
                talloc_free(r);
698
 
                return false;
699
 
        }
700
 
 
701
 
        talloc_free(r);
702
 
 
703
 
        return true;
704
 
}
705
 
 
706
 
static bool api_wkssvc_NetrUseGetInfo(pipes_struct *p)
707
 
{
708
 
        const struct ndr_interface_call *call;
709
 
        struct ndr_pull *pull;
710
 
        struct ndr_push *push;
711
 
        enum ndr_err_code ndr_err;
712
 
        DATA_BLOB blob;
713
 
        struct wkssvc_NetrUseGetInfo *r;
714
 
 
715
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUSEGETINFO];
716
 
 
717
 
        r = talloc(talloc_tos(), struct wkssvc_NetrUseGetInfo);
718
 
        if (r == NULL) {
719
 
                return false;
720
 
        }
721
 
 
722
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
723
 
                talloc_free(r);
724
 
                return false;
725
 
        }
726
 
 
727
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
728
 
        if (pull == NULL) {
729
 
                talloc_free(r);
730
 
                return false;
731
 
        }
732
 
 
733
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
734
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
735
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
736
 
                talloc_free(r);
737
 
                return false;
738
 
        }
739
 
 
740
 
        if (DEBUGLEVEL >= 10) {
741
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUseGetInfo, r);
742
 
        }
743
 
 
744
 
        ZERO_STRUCT(r->out);
745
 
        r->out.ctr = talloc_zero(r, union wkssvc_NetrUseGetInfoCtr);
746
 
        if (r->out.ctr == NULL) {
747
 
                talloc_free(r);
748
 
                return false;
749
 
        }
750
 
 
751
 
        r->out.result = _wkssvc_NetrUseGetInfo(p, r);
752
 
 
753
 
        if (p->rng_fault_state) {
754
 
                talloc_free(r);
755
 
                /* Return true here, srv_pipe_hnd.c will take care */
756
 
                return true;
757
 
        }
758
 
 
759
 
        if (DEBUGLEVEL >= 10) {
760
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseGetInfo, r);
761
 
        }
762
 
 
763
 
        push = ndr_push_init_ctx(r, NULL);
764
 
        if (push == NULL) {
765
 
                talloc_free(r);
766
 
                return false;
767
 
        }
768
 
 
769
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
770
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
771
 
                talloc_free(r);
772
 
                return false;
773
 
        }
774
 
 
775
 
        blob = ndr_push_blob(push);
776
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
777
 
                talloc_free(r);
778
 
                return false;
779
 
        }
780
 
 
781
 
        talloc_free(r);
782
 
 
783
 
        return true;
784
 
}
785
 
 
786
 
static bool api_wkssvc_NetrUseDel(pipes_struct *p)
787
 
{
788
 
        const struct ndr_interface_call *call;
789
 
        struct ndr_pull *pull;
790
 
        struct ndr_push *push;
791
 
        enum ndr_err_code ndr_err;
792
 
        DATA_BLOB blob;
793
 
        struct wkssvc_NetrUseDel *r;
794
 
 
795
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUSEDEL];
796
 
 
797
 
        r = talloc(talloc_tos(), struct wkssvc_NetrUseDel);
798
 
        if (r == NULL) {
799
 
                return false;
800
 
        }
801
 
 
802
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
803
 
                talloc_free(r);
804
 
                return false;
805
 
        }
806
 
 
807
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
808
 
        if (pull == NULL) {
809
 
                talloc_free(r);
810
 
                return false;
811
 
        }
812
 
 
813
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
814
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
815
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
816
 
                talloc_free(r);
817
 
                return false;
818
 
        }
819
 
 
820
 
        if (DEBUGLEVEL >= 10) {
821
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUseDel, r);
822
 
        }
823
 
 
824
 
        r->out.result = _wkssvc_NetrUseDel(p, r);
825
 
 
826
 
        if (p->rng_fault_state) {
827
 
                talloc_free(r);
828
 
                /* Return true here, srv_pipe_hnd.c will take care */
829
 
                return true;
830
 
        }
831
 
 
832
 
        if (DEBUGLEVEL >= 10) {
833
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseDel, r);
834
 
        }
835
 
 
836
 
        push = ndr_push_init_ctx(r, NULL);
837
 
        if (push == NULL) {
838
 
                talloc_free(r);
839
 
                return false;
840
 
        }
841
 
 
842
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
843
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
844
 
                talloc_free(r);
845
 
                return false;
846
 
        }
847
 
 
848
 
        blob = ndr_push_blob(push);
849
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
850
 
                talloc_free(r);
851
 
                return false;
852
 
        }
853
 
 
854
 
        talloc_free(r);
855
 
 
856
 
        return true;
857
 
}
858
 
 
859
 
static bool api_wkssvc_NetrUseEnum(pipes_struct *p)
860
 
{
861
 
        const struct ndr_interface_call *call;
862
 
        struct ndr_pull *pull;
863
 
        struct ndr_push *push;
864
 
        enum ndr_err_code ndr_err;
865
 
        DATA_BLOB blob;
866
 
        struct wkssvc_NetrUseEnum *r;
867
 
 
868
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUSEENUM];
869
 
 
870
 
        r = talloc(talloc_tos(), struct wkssvc_NetrUseEnum);
871
 
        if (r == NULL) {
872
 
                return false;
873
 
        }
874
 
 
875
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
876
 
                talloc_free(r);
877
 
                return false;
878
 
        }
879
 
 
880
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
881
 
        if (pull == NULL) {
882
 
                talloc_free(r);
883
 
                return false;
884
 
        }
885
 
 
886
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
887
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
888
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
889
 
                talloc_free(r);
890
 
                return false;
891
 
        }
892
 
 
893
 
        if (DEBUGLEVEL >= 10) {
894
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUseEnum, r);
895
 
        }
896
 
 
897
 
        ZERO_STRUCT(r->out);
898
 
        r->out.info = r->in.info;
899
 
        r->out.resume_handle = r->in.resume_handle;
900
 
        r->out.entries_read = talloc_zero(r, uint32_t);
901
 
        if (r->out.entries_read == NULL) {
902
 
                talloc_free(r);
903
 
                return false;
904
 
        }
905
 
 
906
 
        r->out.result = _wkssvc_NetrUseEnum(p, r);
907
 
 
908
 
        if (p->rng_fault_state) {
909
 
                talloc_free(r);
910
 
                /* Return true here, srv_pipe_hnd.c will take care */
911
 
                return true;
912
 
        }
913
 
 
914
 
        if (DEBUGLEVEL >= 10) {
915
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUseEnum, r);
916
 
        }
917
 
 
918
 
        push = ndr_push_init_ctx(r, NULL);
919
 
        if (push == NULL) {
920
 
                talloc_free(r);
921
 
                return false;
922
 
        }
923
 
 
924
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
925
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
926
 
                talloc_free(r);
927
 
                return false;
928
 
        }
929
 
 
930
 
        blob = ndr_push_blob(push);
931
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
932
 
                talloc_free(r);
933
 
                return false;
934
 
        }
935
 
 
936
 
        talloc_free(r);
937
 
 
938
 
        return true;
939
 
}
940
 
 
941
 
static bool api_wkssvc_NetrMessageBufferSend(pipes_struct *p)
942
 
{
943
 
        const struct ndr_interface_call *call;
944
 
        struct ndr_pull *pull;
945
 
        struct ndr_push *push;
946
 
        enum ndr_err_code ndr_err;
947
 
        DATA_BLOB blob;
948
 
        struct wkssvc_NetrMessageBufferSend *r;
949
 
 
950
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRMESSAGEBUFFERSEND];
951
 
 
952
 
        r = talloc(talloc_tos(), struct wkssvc_NetrMessageBufferSend);
953
 
        if (r == NULL) {
954
 
                return false;
955
 
        }
956
 
 
957
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
958
 
                talloc_free(r);
959
 
                return false;
960
 
        }
961
 
 
962
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
963
 
        if (pull == NULL) {
964
 
                talloc_free(r);
965
 
                return false;
966
 
        }
967
 
 
968
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
969
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
970
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
971
 
                talloc_free(r);
972
 
                return false;
973
 
        }
974
 
 
975
 
        if (DEBUGLEVEL >= 10) {
976
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrMessageBufferSend, r);
977
 
        }
978
 
 
979
 
        r->out.result = _wkssvc_NetrMessageBufferSend(p, r);
980
 
 
981
 
        if (p->rng_fault_state) {
982
 
                talloc_free(r);
983
 
                /* Return true here, srv_pipe_hnd.c will take care */
984
 
                return true;
985
 
        }
986
 
 
987
 
        if (DEBUGLEVEL >= 10) {
988
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrMessageBufferSend, r);
989
 
        }
990
 
 
991
 
        push = ndr_push_init_ctx(r, NULL);
992
 
        if (push == NULL) {
993
 
                talloc_free(r);
994
 
                return false;
995
 
        }
996
 
 
997
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
998
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
999
 
                talloc_free(r);
1000
 
                return false;
1001
 
        }
1002
 
 
1003
 
        blob = ndr_push_blob(push);
1004
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1005
 
                talloc_free(r);
1006
 
                return false;
1007
 
        }
1008
 
 
1009
 
        talloc_free(r);
1010
 
 
1011
 
        return true;
1012
 
}
1013
 
 
1014
 
static bool api_wkssvc_NetrWorkstationStatisticsGet(pipes_struct *p)
1015
 
{
1016
 
        const struct ndr_interface_call *call;
1017
 
        struct ndr_pull *pull;
1018
 
        struct ndr_push *push;
1019
 
        enum ndr_err_code ndr_err;
1020
 
        DATA_BLOB blob;
1021
 
        struct wkssvc_NetrWorkstationStatisticsGet *r;
1022
 
 
1023
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET];
1024
 
 
1025
 
        r = talloc(talloc_tos(), struct wkssvc_NetrWorkstationStatisticsGet);
1026
 
        if (r == NULL) {
1027
 
                return false;
1028
 
        }
1029
 
 
1030
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1031
 
                talloc_free(r);
1032
 
                return false;
1033
 
        }
1034
 
 
1035
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1036
 
        if (pull == NULL) {
1037
 
                talloc_free(r);
1038
 
                return false;
1039
 
        }
1040
 
 
1041
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1042
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1043
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1044
 
                talloc_free(r);
1045
 
                return false;
1046
 
        }
1047
 
 
1048
 
        if (DEBUGLEVEL >= 10) {
1049
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrWorkstationStatisticsGet, r);
1050
 
        }
1051
 
 
1052
 
        ZERO_STRUCT(r->out);
1053
 
        r->out.info = talloc_zero(r, struct wkssvc_NetrWorkstationStatistics *);
1054
 
        if (r->out.info == NULL) {
1055
 
                talloc_free(r);
1056
 
                return false;
1057
 
        }
1058
 
 
1059
 
        r->out.result = _wkssvc_NetrWorkstationStatisticsGet(p, r);
1060
 
 
1061
 
        if (p->rng_fault_state) {
1062
 
                talloc_free(r);
1063
 
                /* Return true here, srv_pipe_hnd.c will take care */
1064
 
                return true;
1065
 
        }
1066
 
 
1067
 
        if (DEBUGLEVEL >= 10) {
1068
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrWorkstationStatisticsGet, r);
1069
 
        }
1070
 
 
1071
 
        push = ndr_push_init_ctx(r, NULL);
1072
 
        if (push == NULL) {
1073
 
                talloc_free(r);
1074
 
                return false;
1075
 
        }
1076
 
 
1077
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1078
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1079
 
                talloc_free(r);
1080
 
                return false;
1081
 
        }
1082
 
 
1083
 
        blob = ndr_push_blob(push);
1084
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1085
 
                talloc_free(r);
1086
 
                return false;
1087
 
        }
1088
 
 
1089
 
        talloc_free(r);
1090
 
 
1091
 
        return true;
1092
 
}
1093
 
 
1094
 
static bool api_wkssvc_NetrLogonDomainNameAdd(pipes_struct *p)
1095
 
{
1096
 
        const struct ndr_interface_call *call;
1097
 
        struct ndr_pull *pull;
1098
 
        struct ndr_push *push;
1099
 
        enum ndr_err_code ndr_err;
1100
 
        DATA_BLOB blob;
1101
 
        struct wkssvc_NetrLogonDomainNameAdd *r;
1102
 
 
1103
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRLOGONDOMAINNAMEADD];
1104
 
 
1105
 
        r = talloc(talloc_tos(), struct wkssvc_NetrLogonDomainNameAdd);
1106
 
        if (r == NULL) {
1107
 
                return false;
1108
 
        }
1109
 
 
1110
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1111
 
                talloc_free(r);
1112
 
                return false;
1113
 
        }
1114
 
 
1115
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1116
 
        if (pull == NULL) {
1117
 
                talloc_free(r);
1118
 
                return false;
1119
 
        }
1120
 
 
1121
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1122
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1123
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1124
 
                talloc_free(r);
1125
 
                return false;
1126
 
        }
1127
 
 
1128
 
        if (DEBUGLEVEL >= 10) {
1129
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrLogonDomainNameAdd, r);
1130
 
        }
1131
 
 
1132
 
        r->out.result = _wkssvc_NetrLogonDomainNameAdd(p, r);
1133
 
 
1134
 
        if (p->rng_fault_state) {
1135
 
                talloc_free(r);
1136
 
                /* Return true here, srv_pipe_hnd.c will take care */
1137
 
                return true;
1138
 
        }
1139
 
 
1140
 
        if (DEBUGLEVEL >= 10) {
1141
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrLogonDomainNameAdd, r);
1142
 
        }
1143
 
 
1144
 
        push = ndr_push_init_ctx(r, NULL);
1145
 
        if (push == NULL) {
1146
 
                talloc_free(r);
1147
 
                return false;
1148
 
        }
1149
 
 
1150
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1151
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1152
 
                talloc_free(r);
1153
 
                return false;
1154
 
        }
1155
 
 
1156
 
        blob = ndr_push_blob(push);
1157
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1158
 
                talloc_free(r);
1159
 
                return false;
1160
 
        }
1161
 
 
1162
 
        talloc_free(r);
1163
 
 
1164
 
        return true;
1165
 
}
1166
 
 
1167
 
static bool api_wkssvc_NetrLogonDomainNameDel(pipes_struct *p)
1168
 
{
1169
 
        const struct ndr_interface_call *call;
1170
 
        struct ndr_pull *pull;
1171
 
        struct ndr_push *push;
1172
 
        enum ndr_err_code ndr_err;
1173
 
        DATA_BLOB blob;
1174
 
        struct wkssvc_NetrLogonDomainNameDel *r;
1175
 
 
1176
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL];
1177
 
 
1178
 
        r = talloc(talloc_tos(), struct wkssvc_NetrLogonDomainNameDel);
1179
 
        if (r == NULL) {
1180
 
                return false;
1181
 
        }
1182
 
 
1183
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1184
 
                talloc_free(r);
1185
 
                return false;
1186
 
        }
1187
 
 
1188
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1189
 
        if (pull == NULL) {
1190
 
                talloc_free(r);
1191
 
                return false;
1192
 
        }
1193
 
 
1194
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1195
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1196
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1197
 
                talloc_free(r);
1198
 
                return false;
1199
 
        }
1200
 
 
1201
 
        if (DEBUGLEVEL >= 10) {
1202
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrLogonDomainNameDel, r);
1203
 
        }
1204
 
 
1205
 
        r->out.result = _wkssvc_NetrLogonDomainNameDel(p, r);
1206
 
 
1207
 
        if (p->rng_fault_state) {
1208
 
                talloc_free(r);
1209
 
                /* Return true here, srv_pipe_hnd.c will take care */
1210
 
                return true;
1211
 
        }
1212
 
 
1213
 
        if (DEBUGLEVEL >= 10) {
1214
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrLogonDomainNameDel, r);
1215
 
        }
1216
 
 
1217
 
        push = ndr_push_init_ctx(r, NULL);
1218
 
        if (push == NULL) {
1219
 
                talloc_free(r);
1220
 
                return false;
1221
 
        }
1222
 
 
1223
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1224
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1225
 
                talloc_free(r);
1226
 
                return false;
1227
 
        }
1228
 
 
1229
 
        blob = ndr_push_blob(push);
1230
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1231
 
                talloc_free(r);
1232
 
                return false;
1233
 
        }
1234
 
 
1235
 
        talloc_free(r);
1236
 
 
1237
 
        return true;
1238
 
}
1239
 
 
1240
 
static bool api_wkssvc_NetrJoinDomain(pipes_struct *p)
1241
 
{
1242
 
        const struct ndr_interface_call *call;
1243
 
        struct ndr_pull *pull;
1244
 
        struct ndr_push *push;
1245
 
        enum ndr_err_code ndr_err;
1246
 
        DATA_BLOB blob;
1247
 
        struct wkssvc_NetrJoinDomain *r;
1248
 
 
1249
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRJOINDOMAIN];
1250
 
 
1251
 
        r = talloc(talloc_tos(), struct wkssvc_NetrJoinDomain);
1252
 
        if (r == NULL) {
1253
 
                return false;
1254
 
        }
1255
 
 
1256
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1257
 
                talloc_free(r);
1258
 
                return false;
1259
 
        }
1260
 
 
1261
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1262
 
        if (pull == NULL) {
1263
 
                talloc_free(r);
1264
 
                return false;
1265
 
        }
1266
 
 
1267
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1268
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1269
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1270
 
                talloc_free(r);
1271
 
                return false;
1272
 
        }
1273
 
 
1274
 
        if (DEBUGLEVEL >= 10) {
1275
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain, r);
1276
 
        }
1277
 
 
1278
 
        r->out.result = _wkssvc_NetrJoinDomain(p, r);
1279
 
 
1280
 
        if (p->rng_fault_state) {
1281
 
                talloc_free(r);
1282
 
                /* Return true here, srv_pipe_hnd.c will take care */
1283
 
                return true;
1284
 
        }
1285
 
 
1286
 
        if (DEBUGLEVEL >= 10) {
1287
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain, r);
1288
 
        }
1289
 
 
1290
 
        push = ndr_push_init_ctx(r, NULL);
1291
 
        if (push == NULL) {
1292
 
                talloc_free(r);
1293
 
                return false;
1294
 
        }
1295
 
 
1296
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1297
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1298
 
                talloc_free(r);
1299
 
                return false;
1300
 
        }
1301
 
 
1302
 
        blob = ndr_push_blob(push);
1303
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1304
 
                talloc_free(r);
1305
 
                return false;
1306
 
        }
1307
 
 
1308
 
        talloc_free(r);
1309
 
 
1310
 
        return true;
1311
 
}
1312
 
 
1313
 
static bool api_wkssvc_NetrUnjoinDomain(pipes_struct *p)
1314
 
{
1315
 
        const struct ndr_interface_call *call;
1316
 
        struct ndr_pull *pull;
1317
 
        struct ndr_push *push;
1318
 
        enum ndr_err_code ndr_err;
1319
 
        DATA_BLOB blob;
1320
 
        struct wkssvc_NetrUnjoinDomain *r;
1321
 
 
1322
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUNJOINDOMAIN];
1323
 
 
1324
 
        r = talloc(talloc_tos(), struct wkssvc_NetrUnjoinDomain);
1325
 
        if (r == NULL) {
1326
 
                return false;
1327
 
        }
1328
 
 
1329
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1330
 
                talloc_free(r);
1331
 
                return false;
1332
 
        }
1333
 
 
1334
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1335
 
        if (pull == NULL) {
1336
 
                talloc_free(r);
1337
 
                return false;
1338
 
        }
1339
 
 
1340
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1341
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1342
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1343
 
                talloc_free(r);
1344
 
                return false;
1345
 
        }
1346
 
 
1347
 
        if (DEBUGLEVEL >= 10) {
1348
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain, r);
1349
 
        }
1350
 
 
1351
 
        r->out.result = _wkssvc_NetrUnjoinDomain(p, r);
1352
 
 
1353
 
        if (p->rng_fault_state) {
1354
 
                talloc_free(r);
1355
 
                /* Return true here, srv_pipe_hnd.c will take care */
1356
 
                return true;
1357
 
        }
1358
 
 
1359
 
        if (DEBUGLEVEL >= 10) {
1360
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain, r);
1361
 
        }
1362
 
 
1363
 
        push = ndr_push_init_ctx(r, NULL);
1364
 
        if (push == NULL) {
1365
 
                talloc_free(r);
1366
 
                return false;
1367
 
        }
1368
 
 
1369
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1370
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1371
 
                talloc_free(r);
1372
 
                return false;
1373
 
        }
1374
 
 
1375
 
        blob = ndr_push_blob(push);
1376
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1377
 
                talloc_free(r);
1378
 
                return false;
1379
 
        }
1380
 
 
1381
 
        talloc_free(r);
1382
 
 
1383
 
        return true;
1384
 
}
1385
 
 
1386
 
static bool api_wkssvc_NetrRenameMachineInDomain(pipes_struct *p)
1387
 
{
1388
 
        const struct ndr_interface_call *call;
1389
 
        struct ndr_pull *pull;
1390
 
        struct ndr_push *push;
1391
 
        enum ndr_err_code ndr_err;
1392
 
        DATA_BLOB blob;
1393
 
        struct wkssvc_NetrRenameMachineInDomain *r;
1394
 
 
1395
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN];
1396
 
 
1397
 
        r = talloc(talloc_tos(), struct wkssvc_NetrRenameMachineInDomain);
1398
 
        if (r == NULL) {
1399
 
                return false;
1400
 
        }
1401
 
 
1402
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1403
 
                talloc_free(r);
1404
 
                return false;
1405
 
        }
1406
 
 
1407
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1408
 
        if (pull == NULL) {
1409
 
                talloc_free(r);
1410
 
                return false;
1411
 
        }
1412
 
 
1413
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1414
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1415
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1416
 
                talloc_free(r);
1417
 
                return false;
1418
 
        }
1419
 
 
1420
 
        if (DEBUGLEVEL >= 10) {
1421
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain, r);
1422
 
        }
1423
 
 
1424
 
        r->out.result = _wkssvc_NetrRenameMachineInDomain(p, r);
1425
 
 
1426
 
        if (p->rng_fault_state) {
1427
 
                talloc_free(r);
1428
 
                /* Return true here, srv_pipe_hnd.c will take care */
1429
 
                return true;
1430
 
        }
1431
 
 
1432
 
        if (DEBUGLEVEL >= 10) {
1433
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain, r);
1434
 
        }
1435
 
 
1436
 
        push = ndr_push_init_ctx(r, NULL);
1437
 
        if (push == NULL) {
1438
 
                talloc_free(r);
1439
 
                return false;
1440
 
        }
1441
 
 
1442
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1443
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1444
 
                talloc_free(r);
1445
 
                return false;
1446
 
        }
1447
 
 
1448
 
        blob = ndr_push_blob(push);
1449
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1450
 
                talloc_free(r);
1451
 
                return false;
1452
 
        }
1453
 
 
1454
 
        talloc_free(r);
1455
 
 
1456
 
        return true;
1457
 
}
1458
 
 
1459
 
static bool api_wkssvc_NetrValidateName(pipes_struct *p)
1460
 
{
1461
 
        const struct ndr_interface_call *call;
1462
 
        struct ndr_pull *pull;
1463
 
        struct ndr_push *push;
1464
 
        enum ndr_err_code ndr_err;
1465
 
        DATA_BLOB blob;
1466
 
        struct wkssvc_NetrValidateName *r;
1467
 
 
1468
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRVALIDATENAME];
1469
 
 
1470
 
        r = talloc(talloc_tos(), struct wkssvc_NetrValidateName);
1471
 
        if (r == NULL) {
1472
 
                return false;
1473
 
        }
1474
 
 
1475
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1476
 
                talloc_free(r);
1477
 
                return false;
1478
 
        }
1479
 
 
1480
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1481
 
        if (pull == NULL) {
1482
 
                talloc_free(r);
1483
 
                return false;
1484
 
        }
1485
 
 
1486
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1487
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1488
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1489
 
                talloc_free(r);
1490
 
                return false;
1491
 
        }
1492
 
 
1493
 
        if (DEBUGLEVEL >= 10) {
1494
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrValidateName, r);
1495
 
        }
1496
 
 
1497
 
        r->out.result = _wkssvc_NetrValidateName(p, r);
1498
 
 
1499
 
        if (p->rng_fault_state) {
1500
 
                talloc_free(r);
1501
 
                /* Return true here, srv_pipe_hnd.c will take care */
1502
 
                return true;
1503
 
        }
1504
 
 
1505
 
        if (DEBUGLEVEL >= 10) {
1506
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrValidateName, r);
1507
 
        }
1508
 
 
1509
 
        push = ndr_push_init_ctx(r, NULL);
1510
 
        if (push == NULL) {
1511
 
                talloc_free(r);
1512
 
                return false;
1513
 
        }
1514
 
 
1515
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1516
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1517
 
                talloc_free(r);
1518
 
                return false;
1519
 
        }
1520
 
 
1521
 
        blob = ndr_push_blob(push);
1522
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1523
 
                talloc_free(r);
1524
 
                return false;
1525
 
        }
1526
 
 
1527
 
        talloc_free(r);
1528
 
 
1529
 
        return true;
1530
 
}
1531
 
 
1532
 
static bool api_wkssvc_NetrGetJoinInformation(pipes_struct *p)
1533
 
{
1534
 
        const struct ndr_interface_call *call;
1535
 
        struct ndr_pull *pull;
1536
 
        struct ndr_push *push;
1537
 
        enum ndr_err_code ndr_err;
1538
 
        DATA_BLOB blob;
1539
 
        struct wkssvc_NetrGetJoinInformation *r;
1540
 
 
1541
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRGETJOININFORMATION];
1542
 
 
1543
 
        r = talloc(talloc_tos(), struct wkssvc_NetrGetJoinInformation);
1544
 
        if (r == NULL) {
1545
 
                return false;
1546
 
        }
1547
 
 
1548
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1549
 
                talloc_free(r);
1550
 
                return false;
1551
 
        }
1552
 
 
1553
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1554
 
        if (pull == NULL) {
1555
 
                talloc_free(r);
1556
 
                return false;
1557
 
        }
1558
 
 
1559
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1560
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1561
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1562
 
                talloc_free(r);
1563
 
                return false;
1564
 
        }
1565
 
 
1566
 
        if (DEBUGLEVEL >= 10) {
1567
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinInformation, r);
1568
 
        }
1569
 
 
1570
 
        ZERO_STRUCT(r->out);
1571
 
        r->out.name_buffer = r->in.name_buffer;
1572
 
        r->out.name_type = talloc_zero(r, enum wkssvc_NetJoinStatus);
1573
 
        if (r->out.name_type == NULL) {
1574
 
                talloc_free(r);
1575
 
                return false;
1576
 
        }
1577
 
 
1578
 
        r->out.result = _wkssvc_NetrGetJoinInformation(p, r);
1579
 
 
1580
 
        if (p->rng_fault_state) {
1581
 
                talloc_free(r);
1582
 
                /* Return true here, srv_pipe_hnd.c will take care */
1583
 
                return true;
1584
 
        }
1585
 
 
1586
 
        if (DEBUGLEVEL >= 10) {
1587
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinInformation, r);
1588
 
        }
1589
 
 
1590
 
        push = ndr_push_init_ctx(r, NULL);
1591
 
        if (push == NULL) {
1592
 
                talloc_free(r);
1593
 
                return false;
1594
 
        }
1595
 
 
1596
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1597
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1598
 
                talloc_free(r);
1599
 
                return false;
1600
 
        }
1601
 
 
1602
 
        blob = ndr_push_blob(push);
1603
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1604
 
                talloc_free(r);
1605
 
                return false;
1606
 
        }
1607
 
 
1608
 
        talloc_free(r);
1609
 
 
1610
 
        return true;
1611
 
}
1612
 
 
1613
 
static bool api_wkssvc_NetrGetJoinableOus(pipes_struct *p)
1614
 
{
1615
 
        const struct ndr_interface_call *call;
1616
 
        struct ndr_pull *pull;
1617
 
        struct ndr_push *push;
1618
 
        enum ndr_err_code ndr_err;
1619
 
        DATA_BLOB blob;
1620
 
        struct wkssvc_NetrGetJoinableOus *r;
1621
 
 
1622
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRGETJOINABLEOUS];
1623
 
 
1624
 
        r = talloc(talloc_tos(), struct wkssvc_NetrGetJoinableOus);
1625
 
        if (r == NULL) {
1626
 
                return false;
1627
 
        }
1628
 
 
1629
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1630
 
                talloc_free(r);
1631
 
                return false;
1632
 
        }
1633
 
 
1634
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1635
 
        if (pull == NULL) {
1636
 
                talloc_free(r);
1637
 
                return false;
1638
 
        }
1639
 
 
1640
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1641
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1642
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1643
 
                talloc_free(r);
1644
 
                return false;
1645
 
        }
1646
 
 
1647
 
        if (DEBUGLEVEL >= 10) {
1648
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinableOus, r);
1649
 
        }
1650
 
 
1651
 
        ZERO_STRUCT(r->out);
1652
 
        r->out.num_ous = r->in.num_ous;
1653
 
        r->out.ous = talloc_zero(r, const char **);
1654
 
        if (r->out.ous == NULL) {
1655
 
                talloc_free(r);
1656
 
                return false;
1657
 
        }
1658
 
 
1659
 
        r->out.result = _wkssvc_NetrGetJoinableOus(p, r);
1660
 
 
1661
 
        if (p->rng_fault_state) {
1662
 
                talloc_free(r);
1663
 
                /* Return true here, srv_pipe_hnd.c will take care */
1664
 
                return true;
1665
 
        }
1666
 
 
1667
 
        if (DEBUGLEVEL >= 10) {
1668
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinableOus, r);
1669
 
        }
1670
 
 
1671
 
        push = ndr_push_init_ctx(r, NULL);
1672
 
        if (push == NULL) {
1673
 
                talloc_free(r);
1674
 
                return false;
1675
 
        }
1676
 
 
1677
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1678
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1679
 
                talloc_free(r);
1680
 
                return false;
1681
 
        }
1682
 
 
1683
 
        blob = ndr_push_blob(push);
1684
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1685
 
                talloc_free(r);
1686
 
                return false;
1687
 
        }
1688
 
 
1689
 
        talloc_free(r);
1690
 
 
1691
 
        return true;
1692
 
}
1693
 
 
1694
 
static bool api_wkssvc_NetrJoinDomain2(pipes_struct *p)
1695
 
{
1696
 
        const struct ndr_interface_call *call;
1697
 
        struct ndr_pull *pull;
1698
 
        struct ndr_push *push;
1699
 
        enum ndr_err_code ndr_err;
1700
 
        DATA_BLOB blob;
1701
 
        struct wkssvc_NetrJoinDomain2 *r;
1702
 
 
1703
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRJOINDOMAIN2];
1704
 
 
1705
 
        r = talloc(talloc_tos(), struct wkssvc_NetrJoinDomain2);
1706
 
        if (r == NULL) {
1707
 
                return false;
1708
 
        }
1709
 
 
1710
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1711
 
                talloc_free(r);
1712
 
                return false;
1713
 
        }
1714
 
 
1715
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1716
 
        if (pull == NULL) {
1717
 
                talloc_free(r);
1718
 
                return false;
1719
 
        }
1720
 
 
1721
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1722
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1723
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1724
 
                talloc_free(r);
1725
 
                return false;
1726
 
        }
1727
 
 
1728
 
        if (DEBUGLEVEL >= 10) {
1729
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrJoinDomain2, r);
1730
 
        }
1731
 
 
1732
 
        r->out.result = _wkssvc_NetrJoinDomain2(p, r);
1733
 
 
1734
 
        if (p->rng_fault_state) {
1735
 
                talloc_free(r);
1736
 
                /* Return true here, srv_pipe_hnd.c will take care */
1737
 
                return true;
1738
 
        }
1739
 
 
1740
 
        if (DEBUGLEVEL >= 10) {
1741
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrJoinDomain2, r);
1742
 
        }
1743
 
 
1744
 
        push = ndr_push_init_ctx(r, NULL);
1745
 
        if (push == NULL) {
1746
 
                talloc_free(r);
1747
 
                return false;
1748
 
        }
1749
 
 
1750
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1751
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1752
 
                talloc_free(r);
1753
 
                return false;
1754
 
        }
1755
 
 
1756
 
        blob = ndr_push_blob(push);
1757
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1758
 
                talloc_free(r);
1759
 
                return false;
1760
 
        }
1761
 
 
1762
 
        talloc_free(r);
1763
 
 
1764
 
        return true;
1765
 
}
1766
 
 
1767
 
static bool api_wkssvc_NetrUnjoinDomain2(pipes_struct *p)
1768
 
{
1769
 
        const struct ndr_interface_call *call;
1770
 
        struct ndr_pull *pull;
1771
 
        struct ndr_push *push;
1772
 
        enum ndr_err_code ndr_err;
1773
 
        DATA_BLOB blob;
1774
 
        struct wkssvc_NetrUnjoinDomain2 *r;
1775
 
 
1776
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRUNJOINDOMAIN2];
1777
 
 
1778
 
        r = talloc(talloc_tos(), struct wkssvc_NetrUnjoinDomain2);
1779
 
        if (r == NULL) {
1780
 
                return false;
1781
 
        }
1782
 
 
1783
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1784
 
                talloc_free(r);
1785
 
                return false;
1786
 
        }
1787
 
 
1788
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1789
 
        if (pull == NULL) {
1790
 
                talloc_free(r);
1791
 
                return false;
1792
 
        }
1793
 
 
1794
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1795
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1796
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1797
 
                talloc_free(r);
1798
 
                return false;
1799
 
        }
1800
 
 
1801
 
        if (DEBUGLEVEL >= 10) {
1802
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrUnjoinDomain2, r);
1803
 
        }
1804
 
 
1805
 
        r->out.result = _wkssvc_NetrUnjoinDomain2(p, r);
1806
 
 
1807
 
        if (p->rng_fault_state) {
1808
 
                talloc_free(r);
1809
 
                /* Return true here, srv_pipe_hnd.c will take care */
1810
 
                return true;
1811
 
        }
1812
 
 
1813
 
        if (DEBUGLEVEL >= 10) {
1814
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrUnjoinDomain2, r);
1815
 
        }
1816
 
 
1817
 
        push = ndr_push_init_ctx(r, NULL);
1818
 
        if (push == NULL) {
1819
 
                talloc_free(r);
1820
 
                return false;
1821
 
        }
1822
 
 
1823
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1824
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1825
 
                talloc_free(r);
1826
 
                return false;
1827
 
        }
1828
 
 
1829
 
        blob = ndr_push_blob(push);
1830
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1831
 
                talloc_free(r);
1832
 
                return false;
1833
 
        }
1834
 
 
1835
 
        talloc_free(r);
1836
 
 
1837
 
        return true;
1838
 
}
1839
 
 
1840
 
static bool api_wkssvc_NetrRenameMachineInDomain2(pipes_struct *p)
1841
 
{
1842
 
        const struct ndr_interface_call *call;
1843
 
        struct ndr_pull *pull;
1844
 
        struct ndr_push *push;
1845
 
        enum ndr_err_code ndr_err;
1846
 
        DATA_BLOB blob;
1847
 
        struct wkssvc_NetrRenameMachineInDomain2 *r;
1848
 
 
1849
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2];
1850
 
 
1851
 
        r = talloc(talloc_tos(), struct wkssvc_NetrRenameMachineInDomain2);
1852
 
        if (r == NULL) {
1853
 
                return false;
1854
 
        }
1855
 
 
1856
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1857
 
                talloc_free(r);
1858
 
                return false;
1859
 
        }
1860
 
 
1861
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1862
 
        if (pull == NULL) {
1863
 
                talloc_free(r);
1864
 
                return false;
1865
 
        }
1866
 
 
1867
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1868
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1869
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1870
 
                talloc_free(r);
1871
 
                return false;
1872
 
        }
1873
 
 
1874
 
        if (DEBUGLEVEL >= 10) {
1875
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrRenameMachineInDomain2, r);
1876
 
        }
1877
 
 
1878
 
        r->out.result = _wkssvc_NetrRenameMachineInDomain2(p, r);
1879
 
 
1880
 
        if (p->rng_fault_state) {
1881
 
                talloc_free(r);
1882
 
                /* Return true here, srv_pipe_hnd.c will take care */
1883
 
                return true;
1884
 
        }
1885
 
 
1886
 
        if (DEBUGLEVEL >= 10) {
1887
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrRenameMachineInDomain2, r);
1888
 
        }
1889
 
 
1890
 
        push = ndr_push_init_ctx(r, NULL);
1891
 
        if (push == NULL) {
1892
 
                talloc_free(r);
1893
 
                return false;
1894
 
        }
1895
 
 
1896
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1897
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1898
 
                talloc_free(r);
1899
 
                return false;
1900
 
        }
1901
 
 
1902
 
        blob = ndr_push_blob(push);
1903
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1904
 
                talloc_free(r);
1905
 
                return false;
1906
 
        }
1907
 
 
1908
 
        talloc_free(r);
1909
 
 
1910
 
        return true;
1911
 
}
1912
 
 
1913
 
static bool api_wkssvc_NetrValidateName2(pipes_struct *p)
1914
 
{
1915
 
        const struct ndr_interface_call *call;
1916
 
        struct ndr_pull *pull;
1917
 
        struct ndr_push *push;
1918
 
        enum ndr_err_code ndr_err;
1919
 
        DATA_BLOB blob;
1920
 
        struct wkssvc_NetrValidateName2 *r;
1921
 
 
1922
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRVALIDATENAME2];
1923
 
 
1924
 
        r = talloc(talloc_tos(), struct wkssvc_NetrValidateName2);
1925
 
        if (r == NULL) {
1926
 
                return false;
1927
 
        }
1928
 
 
1929
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
1930
 
                talloc_free(r);
1931
 
                return false;
1932
 
        }
1933
 
 
1934
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
1935
 
        if (pull == NULL) {
1936
 
                talloc_free(r);
1937
 
                return false;
1938
 
        }
1939
 
 
1940
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
1941
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
1942
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1943
 
                talloc_free(r);
1944
 
                return false;
1945
 
        }
1946
 
 
1947
 
        if (DEBUGLEVEL >= 10) {
1948
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrValidateName2, r);
1949
 
        }
1950
 
 
1951
 
        r->out.result = _wkssvc_NetrValidateName2(p, r);
1952
 
 
1953
 
        if (p->rng_fault_state) {
1954
 
                talloc_free(r);
1955
 
                /* Return true here, srv_pipe_hnd.c will take care */
1956
 
                return true;
1957
 
        }
1958
 
 
1959
 
        if (DEBUGLEVEL >= 10) {
1960
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrValidateName2, r);
1961
 
        }
1962
 
 
1963
 
        push = ndr_push_init_ctx(r, NULL);
1964
 
        if (push == NULL) {
1965
 
                talloc_free(r);
1966
 
                return false;
1967
 
        }
1968
 
 
1969
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
1970
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
1971
 
                talloc_free(r);
1972
 
                return false;
1973
 
        }
1974
 
 
1975
 
        blob = ndr_push_blob(push);
1976
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
1977
 
                talloc_free(r);
1978
 
                return false;
1979
 
        }
1980
 
 
1981
 
        talloc_free(r);
1982
 
 
1983
 
        return true;
1984
 
}
1985
 
 
1986
 
static bool api_wkssvc_NetrGetJoinableOus2(pipes_struct *p)
1987
 
{
1988
 
        const struct ndr_interface_call *call;
1989
 
        struct ndr_pull *pull;
1990
 
        struct ndr_push *push;
1991
 
        enum ndr_err_code ndr_err;
1992
 
        DATA_BLOB blob;
1993
 
        struct wkssvc_NetrGetJoinableOus2 *r;
1994
 
 
1995
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRGETJOINABLEOUS2];
1996
 
 
1997
 
        r = talloc(talloc_tos(), struct wkssvc_NetrGetJoinableOus2);
1998
 
        if (r == NULL) {
1999
 
                return false;
2000
 
        }
2001
 
 
2002
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2003
 
                talloc_free(r);
2004
 
                return false;
2005
 
        }
2006
 
 
2007
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
2008
 
        if (pull == NULL) {
2009
 
                talloc_free(r);
2010
 
                return false;
2011
 
        }
2012
 
 
2013
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2014
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
2015
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2016
 
                talloc_free(r);
2017
 
                return false;
2018
 
        }
2019
 
 
2020
 
        if (DEBUGLEVEL >= 10) {
2021
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrGetJoinableOus2, r);
2022
 
        }
2023
 
 
2024
 
        ZERO_STRUCT(r->out);
2025
 
        r->out.num_ous = r->in.num_ous;
2026
 
        r->out.ous = talloc_zero(r, const char **);
2027
 
        if (r->out.ous == NULL) {
2028
 
                talloc_free(r);
2029
 
                return false;
2030
 
        }
2031
 
 
2032
 
        r->out.result = _wkssvc_NetrGetJoinableOus2(p, r);
2033
 
 
2034
 
        if (p->rng_fault_state) {
2035
 
                talloc_free(r);
2036
 
                /* Return true here, srv_pipe_hnd.c will take care */
2037
 
                return true;
2038
 
        }
2039
 
 
2040
 
        if (DEBUGLEVEL >= 10) {
2041
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrGetJoinableOus2, r);
2042
 
        }
2043
 
 
2044
 
        push = ndr_push_init_ctx(r, NULL);
2045
 
        if (push == NULL) {
2046
 
                talloc_free(r);
2047
 
                return false;
2048
 
        }
2049
 
 
2050
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
2051
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2052
 
                talloc_free(r);
2053
 
                return false;
2054
 
        }
2055
 
 
2056
 
        blob = ndr_push_blob(push);
2057
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2058
 
                talloc_free(r);
2059
 
                return false;
2060
 
        }
2061
 
 
2062
 
        talloc_free(r);
2063
 
 
2064
 
        return true;
2065
 
}
2066
 
 
2067
 
static bool api_wkssvc_NetrAddAlternateComputerName(pipes_struct *p)
2068
 
{
2069
 
        const struct ndr_interface_call *call;
2070
 
        struct ndr_pull *pull;
2071
 
        struct ndr_push *push;
2072
 
        enum ndr_err_code ndr_err;
2073
 
        DATA_BLOB blob;
2074
 
        struct wkssvc_NetrAddAlternateComputerName *r;
2075
 
 
2076
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME];
2077
 
 
2078
 
        r = talloc(talloc_tos(), struct wkssvc_NetrAddAlternateComputerName);
2079
 
        if (r == NULL) {
2080
 
                return false;
2081
 
        }
2082
 
 
2083
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2084
 
                talloc_free(r);
2085
 
                return false;
2086
 
        }
2087
 
 
2088
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
2089
 
        if (pull == NULL) {
2090
 
                talloc_free(r);
2091
 
                return false;
2092
 
        }
2093
 
 
2094
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2095
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
2096
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2097
 
                talloc_free(r);
2098
 
                return false;
2099
 
        }
2100
 
 
2101
 
        if (DEBUGLEVEL >= 10) {
2102
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrAddAlternateComputerName, r);
2103
 
        }
2104
 
 
2105
 
        r->out.result = _wkssvc_NetrAddAlternateComputerName(p, r);
2106
 
 
2107
 
        if (p->rng_fault_state) {
2108
 
                talloc_free(r);
2109
 
                /* Return true here, srv_pipe_hnd.c will take care */
2110
 
                return true;
2111
 
        }
2112
 
 
2113
 
        if (DEBUGLEVEL >= 10) {
2114
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrAddAlternateComputerName, r);
2115
 
        }
2116
 
 
2117
 
        push = ndr_push_init_ctx(r, NULL);
2118
 
        if (push == NULL) {
2119
 
                talloc_free(r);
2120
 
                return false;
2121
 
        }
2122
 
 
2123
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
2124
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2125
 
                talloc_free(r);
2126
 
                return false;
2127
 
        }
2128
 
 
2129
 
        blob = ndr_push_blob(push);
2130
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2131
 
                talloc_free(r);
2132
 
                return false;
2133
 
        }
2134
 
 
2135
 
        talloc_free(r);
2136
 
 
2137
 
        return true;
2138
 
}
2139
 
 
2140
 
static bool api_wkssvc_NetrRemoveAlternateComputerName(pipes_struct *p)
2141
 
{
2142
 
        const struct ndr_interface_call *call;
2143
 
        struct ndr_pull *pull;
2144
 
        struct ndr_push *push;
2145
 
        enum ndr_err_code ndr_err;
2146
 
        DATA_BLOB blob;
2147
 
        struct wkssvc_NetrRemoveAlternateComputerName *r;
2148
 
 
2149
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME];
2150
 
 
2151
 
        r = talloc(talloc_tos(), struct wkssvc_NetrRemoveAlternateComputerName);
2152
 
        if (r == NULL) {
2153
 
                return false;
2154
 
        }
2155
 
 
2156
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2157
 
                talloc_free(r);
2158
 
                return false;
2159
 
        }
2160
 
 
2161
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
2162
 
        if (pull == NULL) {
2163
 
                talloc_free(r);
2164
 
                return false;
2165
 
        }
2166
 
 
2167
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2168
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
2169
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2170
 
                talloc_free(r);
2171
 
                return false;
2172
 
        }
2173
 
 
2174
 
        if (DEBUGLEVEL >= 10) {
2175
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrRemoveAlternateComputerName, r);
2176
 
        }
2177
 
 
2178
 
        r->out.result = _wkssvc_NetrRemoveAlternateComputerName(p, r);
2179
 
 
2180
 
        if (p->rng_fault_state) {
2181
 
                talloc_free(r);
2182
 
                /* Return true here, srv_pipe_hnd.c will take care */
2183
 
                return true;
2184
 
        }
2185
 
 
2186
 
        if (DEBUGLEVEL >= 10) {
2187
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrRemoveAlternateComputerName, r);
2188
 
        }
2189
 
 
2190
 
        push = ndr_push_init_ctx(r, NULL);
2191
 
        if (push == NULL) {
2192
 
                talloc_free(r);
2193
 
                return false;
2194
 
        }
2195
 
 
2196
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
2197
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2198
 
                talloc_free(r);
2199
 
                return false;
2200
 
        }
2201
 
 
2202
 
        blob = ndr_push_blob(push);
2203
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2204
 
                talloc_free(r);
2205
 
                return false;
2206
 
        }
2207
 
 
2208
 
        talloc_free(r);
2209
 
 
2210
 
        return true;
2211
 
}
2212
 
 
2213
 
static bool api_wkssvc_NetrSetPrimaryComputername(pipes_struct *p)
2214
 
{
2215
 
        const struct ndr_interface_call *call;
2216
 
        struct ndr_pull *pull;
2217
 
        struct ndr_push *push;
2218
 
        enum ndr_err_code ndr_err;
2219
 
        DATA_BLOB blob;
2220
 
        struct wkssvc_NetrSetPrimaryComputername *r;
2221
 
 
2222
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME];
2223
 
 
2224
 
        r = talloc(talloc_tos(), struct wkssvc_NetrSetPrimaryComputername);
2225
 
        if (r == NULL) {
2226
 
                return false;
2227
 
        }
2228
 
 
2229
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2230
 
                talloc_free(r);
2231
 
                return false;
2232
 
        }
2233
 
 
2234
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
2235
 
        if (pull == NULL) {
2236
 
                talloc_free(r);
2237
 
                return false;
2238
 
        }
2239
 
 
2240
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2241
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
2242
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2243
 
                talloc_free(r);
2244
 
                return false;
2245
 
        }
2246
 
 
2247
 
        if (DEBUGLEVEL >= 10) {
2248
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrSetPrimaryComputername, r);
2249
 
        }
2250
 
 
2251
 
        r->out.result = _wkssvc_NetrSetPrimaryComputername(p, r);
2252
 
 
2253
 
        if (p->rng_fault_state) {
2254
 
                talloc_free(r);
2255
 
                /* Return true here, srv_pipe_hnd.c will take care */
2256
 
                return true;
2257
 
        }
2258
 
 
2259
 
        if (DEBUGLEVEL >= 10) {
2260
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrSetPrimaryComputername, r);
2261
 
        }
2262
 
 
2263
 
        push = ndr_push_init_ctx(r, NULL);
2264
 
        if (push == NULL) {
2265
 
                talloc_free(r);
2266
 
                return false;
2267
 
        }
2268
 
 
2269
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
2270
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2271
 
                talloc_free(r);
2272
 
                return false;
2273
 
        }
2274
 
 
2275
 
        blob = ndr_push_blob(push);
2276
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2277
 
                talloc_free(r);
2278
 
                return false;
2279
 
        }
2280
 
 
2281
 
        talloc_free(r);
2282
 
 
2283
 
        return true;
2284
 
}
2285
 
 
2286
 
static bool api_wkssvc_NetrEnumerateComputerNames(pipes_struct *p)
2287
 
{
2288
 
        const struct ndr_interface_call *call;
2289
 
        struct ndr_pull *pull;
2290
 
        struct ndr_push *push;
2291
 
        enum ndr_err_code ndr_err;
2292
 
        DATA_BLOB blob;
2293
 
        struct wkssvc_NetrEnumerateComputerNames *r;
2294
 
 
2295
 
        call = &ndr_table_wkssvc.calls[NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES];
2296
 
 
2297
 
        r = talloc(talloc_tos(), struct wkssvc_NetrEnumerateComputerNames);
2298
 
        if (r == NULL) {
2299
 
                return false;
2300
 
        }
2301
 
 
2302
 
        if (!prs_data_blob(&p->in_data.data, &blob, r)) {
2303
 
                talloc_free(r);
2304
 
                return false;
2305
 
        }
2306
 
 
2307
 
        pull = ndr_pull_init_blob(&blob, r, NULL);
2308
 
        if (pull == NULL) {
2309
 
                talloc_free(r);
2310
 
                return false;
2311
 
        }
2312
 
 
2313
 
        pull->flags |= LIBNDR_FLAG_REF_ALLOC;
2314
 
        ndr_err = call->ndr_pull(pull, NDR_IN, r);
2315
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2316
 
                talloc_free(r);
2317
 
                return false;
2318
 
        }
2319
 
 
2320
 
        if (DEBUGLEVEL >= 10) {
2321
 
                NDR_PRINT_IN_DEBUG(wkssvc_NetrEnumerateComputerNames, r);
2322
 
        }
2323
 
 
2324
 
        ZERO_STRUCT(r->out);
2325
 
        r->out.ctr = talloc_zero(r, struct wkssvc_ComputerNamesCtr *);
2326
 
        if (r->out.ctr == NULL) {
2327
 
                talloc_free(r);
2328
 
                return false;
2329
 
        }
2330
 
 
2331
 
        r->out.result = _wkssvc_NetrEnumerateComputerNames(p, r);
2332
 
 
2333
 
        if (p->rng_fault_state) {
2334
 
                talloc_free(r);
2335
 
                /* Return true here, srv_pipe_hnd.c will take care */
2336
 
                return true;
2337
 
        }
2338
 
 
2339
 
        if (DEBUGLEVEL >= 10) {
2340
 
                NDR_PRINT_OUT_DEBUG(wkssvc_NetrEnumerateComputerNames, r);
2341
 
        }
2342
 
 
2343
 
        push = ndr_push_init_ctx(r, NULL);
2344
 
        if (push == NULL) {
2345
 
                talloc_free(r);
2346
 
                return false;
2347
 
        }
2348
 
 
2349
 
        ndr_err = call->ndr_push(push, NDR_OUT, r);
2350
 
        if (!NDR_ERR_CODE_IS_SUCCESS(ndr_err)) {
2351
 
                talloc_free(r);
2352
 
                return false;
2353
 
        }
2354
 
 
2355
 
        blob = ndr_push_blob(push);
2356
 
        if (!prs_copy_data_in(&p->out_data.rdata, (const char *)blob.data, (uint32_t)blob.length)) {
2357
 
                talloc_free(r);
2358
 
                return false;
2359
 
        }
2360
 
 
2361
 
        talloc_free(r);
2362
 
 
2363
 
        return true;
2364
 
}
2365
 
 
2366
 
 
2367
 
/* Tables */
2368
 
static struct api_struct api_wkssvc_cmds[] = 
2369
 
{
2370
 
        {"WKSSVC_NETWKSTAGETINFO", NDR_WKSSVC_NETWKSTAGETINFO, api_wkssvc_NetWkstaGetInfo},
2371
 
        {"WKSSVC_NETWKSTASETINFO", NDR_WKSSVC_NETWKSTASETINFO, api_wkssvc_NetWkstaSetInfo},
2372
 
        {"WKSSVC_NETWKSTAENUMUSERS", NDR_WKSSVC_NETWKSTAENUMUSERS, api_wkssvc_NetWkstaEnumUsers},
2373
 
        {"WKSSVC_NETRWKSTAUSERGETINFO", NDR_WKSSVC_NETRWKSTAUSERGETINFO, api_wkssvc_NetrWkstaUserGetInfo},
2374
 
        {"WKSSVC_NETRWKSTAUSERSETINFO", NDR_WKSSVC_NETRWKSTAUSERSETINFO, api_wkssvc_NetrWkstaUserSetInfo},
2375
 
        {"WKSSVC_NETWKSTATRANSPORTENUM", NDR_WKSSVC_NETWKSTATRANSPORTENUM, api_wkssvc_NetWkstaTransportEnum},
2376
 
        {"WKSSVC_NETRWKSTATRANSPORTADD", NDR_WKSSVC_NETRWKSTATRANSPORTADD, api_wkssvc_NetrWkstaTransportAdd},
2377
 
        {"WKSSVC_NETRWKSTATRANSPORTDEL", NDR_WKSSVC_NETRWKSTATRANSPORTDEL, api_wkssvc_NetrWkstaTransportDel},
2378
 
        {"WKSSVC_NETRUSEADD", NDR_WKSSVC_NETRUSEADD, api_wkssvc_NetrUseAdd},
2379
 
        {"WKSSVC_NETRUSEGETINFO", NDR_WKSSVC_NETRUSEGETINFO, api_wkssvc_NetrUseGetInfo},
2380
 
        {"WKSSVC_NETRUSEDEL", NDR_WKSSVC_NETRUSEDEL, api_wkssvc_NetrUseDel},
2381
 
        {"WKSSVC_NETRUSEENUM", NDR_WKSSVC_NETRUSEENUM, api_wkssvc_NetrUseEnum},
2382
 
        {"WKSSVC_NETRMESSAGEBUFFERSEND", NDR_WKSSVC_NETRMESSAGEBUFFERSEND, api_wkssvc_NetrMessageBufferSend},
2383
 
        {"WKSSVC_NETRWORKSTATIONSTATISTICSGET", NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET, api_wkssvc_NetrWorkstationStatisticsGet},
2384
 
        {"WKSSVC_NETRLOGONDOMAINNAMEADD", NDR_WKSSVC_NETRLOGONDOMAINNAMEADD, api_wkssvc_NetrLogonDomainNameAdd},
2385
 
        {"WKSSVC_NETRLOGONDOMAINNAMEDEL", NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL, api_wkssvc_NetrLogonDomainNameDel},
2386
 
        {"WKSSVC_NETRJOINDOMAIN", NDR_WKSSVC_NETRJOINDOMAIN, api_wkssvc_NetrJoinDomain},
2387
 
        {"WKSSVC_NETRUNJOINDOMAIN", NDR_WKSSVC_NETRUNJOINDOMAIN, api_wkssvc_NetrUnjoinDomain},
2388
 
        {"WKSSVC_NETRRENAMEMACHINEINDOMAIN", NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN, api_wkssvc_NetrRenameMachineInDomain},
2389
 
        {"WKSSVC_NETRVALIDATENAME", NDR_WKSSVC_NETRVALIDATENAME, api_wkssvc_NetrValidateName},
2390
 
        {"WKSSVC_NETRGETJOININFORMATION", NDR_WKSSVC_NETRGETJOININFORMATION, api_wkssvc_NetrGetJoinInformation},
2391
 
        {"WKSSVC_NETRGETJOINABLEOUS", NDR_WKSSVC_NETRGETJOINABLEOUS, api_wkssvc_NetrGetJoinableOus},
2392
 
        {"WKSSVC_NETRJOINDOMAIN2", NDR_WKSSVC_NETRJOINDOMAIN2, api_wkssvc_NetrJoinDomain2},
2393
 
        {"WKSSVC_NETRUNJOINDOMAIN2", NDR_WKSSVC_NETRUNJOINDOMAIN2, api_wkssvc_NetrUnjoinDomain2},
2394
 
        {"WKSSVC_NETRRENAMEMACHINEINDOMAIN2", NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2, api_wkssvc_NetrRenameMachineInDomain2},
2395
 
        {"WKSSVC_NETRVALIDATENAME2", NDR_WKSSVC_NETRVALIDATENAME2, api_wkssvc_NetrValidateName2},
2396
 
        {"WKSSVC_NETRGETJOINABLEOUS2", NDR_WKSSVC_NETRGETJOINABLEOUS2, api_wkssvc_NetrGetJoinableOus2},
2397
 
        {"WKSSVC_NETRADDALTERNATECOMPUTERNAME", NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME, api_wkssvc_NetrAddAlternateComputerName},
2398
 
        {"WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME", NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME, api_wkssvc_NetrRemoveAlternateComputerName},
2399
 
        {"WKSSVC_NETRSETPRIMARYCOMPUTERNAME", NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME, api_wkssvc_NetrSetPrimaryComputername},
2400
 
        {"WKSSVC_NETRENUMERATECOMPUTERNAMES", NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES, api_wkssvc_NetrEnumerateComputerNames},
2401
 
};
2402
 
 
2403
 
void wkssvc_get_pipe_fns(struct api_struct **fns, int *n_fns)
2404
 
{
2405
 
        *fns = api_wkssvc_cmds;
2406
 
        *n_fns = sizeof(api_wkssvc_cmds) / sizeof(struct api_struct);
2407
 
}
2408
 
 
2409
 
NTSTATUS rpc_wkssvc_dispatch(struct rpc_pipe_client *cli, TALLOC_CTX *mem_ctx, const struct ndr_interface_table *table, uint32_t opnum, void *_r)
2410
 
{
2411
 
        if (cli->pipes_struct == NULL) {
2412
 
                return NT_STATUS_INVALID_PARAMETER;
2413
 
        }
2414
 
 
2415
 
        switch (opnum)
2416
 
        {
2417
 
                case NDR_WKSSVC_NETWKSTAGETINFO: {
2418
 
                        struct wkssvc_NetWkstaGetInfo *r = (struct wkssvc_NetWkstaGetInfo *)_r;
2419
 
                        ZERO_STRUCT(r->out);
2420
 
                        r->out.info = talloc_zero(mem_ctx, union wkssvc_NetWkstaInfo);
2421
 
                        if (r->out.info == NULL) {
2422
 
                        return NT_STATUS_NO_MEMORY;
2423
 
                        }
2424
 
 
2425
 
                        r->out.result = _wkssvc_NetWkstaGetInfo(cli->pipes_struct, r);
2426
 
                        return NT_STATUS_OK;
2427
 
                }
2428
 
 
2429
 
                case NDR_WKSSVC_NETWKSTASETINFO: {
2430
 
                        struct wkssvc_NetWkstaSetInfo *r = (struct wkssvc_NetWkstaSetInfo *)_r;
2431
 
                        ZERO_STRUCT(r->out);
2432
 
                        r->out.parm_error = r->in.parm_error;
2433
 
                        r->out.result = _wkssvc_NetWkstaSetInfo(cli->pipes_struct, r);
2434
 
                        return NT_STATUS_OK;
2435
 
                }
2436
 
 
2437
 
                case NDR_WKSSVC_NETWKSTAENUMUSERS: {
2438
 
                        struct wkssvc_NetWkstaEnumUsers *r = (struct wkssvc_NetWkstaEnumUsers *)_r;
2439
 
                        ZERO_STRUCT(r->out);
2440
 
                        r->out.info = r->in.info;
2441
 
                        r->out.resume_handle = r->in.resume_handle;
2442
 
                        r->out.entries_read = talloc_zero(mem_ctx, uint32_t);
2443
 
                        if (r->out.entries_read == NULL) {
2444
 
                        return NT_STATUS_NO_MEMORY;
2445
 
                        }
2446
 
 
2447
 
                        r->out.result = _wkssvc_NetWkstaEnumUsers(cli->pipes_struct, r);
2448
 
                        return NT_STATUS_OK;
2449
 
                }
2450
 
 
2451
 
                case NDR_WKSSVC_NETRWKSTAUSERGETINFO: {
2452
 
                        struct wkssvc_NetrWkstaUserGetInfo *r = (struct wkssvc_NetrWkstaUserGetInfo *)_r;
2453
 
                        ZERO_STRUCT(r->out);
2454
 
                        r->out.info = talloc_zero(mem_ctx, union wkssvc_NetrWkstaUserInfo);
2455
 
                        if (r->out.info == NULL) {
2456
 
                        return NT_STATUS_NO_MEMORY;
2457
 
                        }
2458
 
 
2459
 
                        r->out.result = _wkssvc_NetrWkstaUserGetInfo(cli->pipes_struct, r);
2460
 
                        return NT_STATUS_OK;
2461
 
                }
2462
 
 
2463
 
                case NDR_WKSSVC_NETRWKSTAUSERSETINFO: {
2464
 
                        struct wkssvc_NetrWkstaUserSetInfo *r = (struct wkssvc_NetrWkstaUserSetInfo *)_r;
2465
 
                        ZERO_STRUCT(r->out);
2466
 
                        r->out.parm_err = r->in.parm_err;
2467
 
                        r->out.result = _wkssvc_NetrWkstaUserSetInfo(cli->pipes_struct, r);
2468
 
                        return NT_STATUS_OK;
2469
 
                }
2470
 
 
2471
 
                case NDR_WKSSVC_NETWKSTATRANSPORTENUM: {
2472
 
                        struct wkssvc_NetWkstaTransportEnum *r = (struct wkssvc_NetWkstaTransportEnum *)_r;
2473
 
                        ZERO_STRUCT(r->out);
2474
 
                        r->out.info = r->in.info;
2475
 
                        r->out.resume_handle = r->in.resume_handle;
2476
 
                        r->out.total_entries = talloc_zero(mem_ctx, uint32_t);
2477
 
                        if (r->out.total_entries == NULL) {
2478
 
                        return NT_STATUS_NO_MEMORY;
2479
 
                        }
2480
 
 
2481
 
                        r->out.result = _wkssvc_NetWkstaTransportEnum(cli->pipes_struct, r);
2482
 
                        return NT_STATUS_OK;
2483
 
                }
2484
 
 
2485
 
                case NDR_WKSSVC_NETRWKSTATRANSPORTADD: {
2486
 
                        struct wkssvc_NetrWkstaTransportAdd *r = (struct wkssvc_NetrWkstaTransportAdd *)_r;
2487
 
                        ZERO_STRUCT(r->out);
2488
 
                        r->out.parm_err = r->in.parm_err;
2489
 
                        r->out.result = _wkssvc_NetrWkstaTransportAdd(cli->pipes_struct, r);
2490
 
                        return NT_STATUS_OK;
2491
 
                }
2492
 
 
2493
 
                case NDR_WKSSVC_NETRWKSTATRANSPORTDEL: {
2494
 
                        struct wkssvc_NetrWkstaTransportDel *r = (struct wkssvc_NetrWkstaTransportDel *)_r;
2495
 
                        r->out.result = _wkssvc_NetrWkstaTransportDel(cli->pipes_struct, r);
2496
 
                        return NT_STATUS_OK;
2497
 
                }
2498
 
 
2499
 
                case NDR_WKSSVC_NETRUSEADD: {
2500
 
                        struct wkssvc_NetrUseAdd *r = (struct wkssvc_NetrUseAdd *)_r;
2501
 
                        ZERO_STRUCT(r->out);
2502
 
                        r->out.parm_err = r->in.parm_err;
2503
 
                        r->out.result = _wkssvc_NetrUseAdd(cli->pipes_struct, r);
2504
 
                        return NT_STATUS_OK;
2505
 
                }
2506
 
 
2507
 
                case NDR_WKSSVC_NETRUSEGETINFO: {
2508
 
                        struct wkssvc_NetrUseGetInfo *r = (struct wkssvc_NetrUseGetInfo *)_r;
2509
 
                        ZERO_STRUCT(r->out);
2510
 
                        r->out.ctr = talloc_zero(mem_ctx, union wkssvc_NetrUseGetInfoCtr);
2511
 
                        if (r->out.ctr == NULL) {
2512
 
                        return NT_STATUS_NO_MEMORY;
2513
 
                        }
2514
 
 
2515
 
                        r->out.result = _wkssvc_NetrUseGetInfo(cli->pipes_struct, r);
2516
 
                        return NT_STATUS_OK;
2517
 
                }
2518
 
 
2519
 
                case NDR_WKSSVC_NETRUSEDEL: {
2520
 
                        struct wkssvc_NetrUseDel *r = (struct wkssvc_NetrUseDel *)_r;
2521
 
                        r->out.result = _wkssvc_NetrUseDel(cli->pipes_struct, r);
2522
 
                        return NT_STATUS_OK;
2523
 
                }
2524
 
 
2525
 
                case NDR_WKSSVC_NETRUSEENUM: {
2526
 
                        struct wkssvc_NetrUseEnum *r = (struct wkssvc_NetrUseEnum *)_r;
2527
 
                        ZERO_STRUCT(r->out);
2528
 
                        r->out.info = r->in.info;
2529
 
                        r->out.resume_handle = r->in.resume_handle;
2530
 
                        r->out.entries_read = talloc_zero(mem_ctx, uint32_t);
2531
 
                        if (r->out.entries_read == NULL) {
2532
 
                        return NT_STATUS_NO_MEMORY;
2533
 
                        }
2534
 
 
2535
 
                        r->out.result = _wkssvc_NetrUseEnum(cli->pipes_struct, r);
2536
 
                        return NT_STATUS_OK;
2537
 
                }
2538
 
 
2539
 
                case NDR_WKSSVC_NETRMESSAGEBUFFERSEND: {
2540
 
                        struct wkssvc_NetrMessageBufferSend *r = (struct wkssvc_NetrMessageBufferSend *)_r;
2541
 
                        r->out.result = _wkssvc_NetrMessageBufferSend(cli->pipes_struct, r);
2542
 
                        return NT_STATUS_OK;
2543
 
                }
2544
 
 
2545
 
                case NDR_WKSSVC_NETRWORKSTATIONSTATISTICSGET: {
2546
 
                        struct wkssvc_NetrWorkstationStatisticsGet *r = (struct wkssvc_NetrWorkstationStatisticsGet *)_r;
2547
 
                        ZERO_STRUCT(r->out);
2548
 
                        r->out.info = talloc_zero(mem_ctx, struct wkssvc_NetrWorkstationStatistics *);
2549
 
                        if (r->out.info == NULL) {
2550
 
                        return NT_STATUS_NO_MEMORY;
2551
 
                        }
2552
 
 
2553
 
                        r->out.result = _wkssvc_NetrWorkstationStatisticsGet(cli->pipes_struct, r);
2554
 
                        return NT_STATUS_OK;
2555
 
                }
2556
 
 
2557
 
                case NDR_WKSSVC_NETRLOGONDOMAINNAMEADD: {
2558
 
                        struct wkssvc_NetrLogonDomainNameAdd *r = (struct wkssvc_NetrLogonDomainNameAdd *)_r;
2559
 
                        r->out.result = _wkssvc_NetrLogonDomainNameAdd(cli->pipes_struct, r);
2560
 
                        return NT_STATUS_OK;
2561
 
                }
2562
 
 
2563
 
                case NDR_WKSSVC_NETRLOGONDOMAINNAMEDEL: {
2564
 
                        struct wkssvc_NetrLogonDomainNameDel *r = (struct wkssvc_NetrLogonDomainNameDel *)_r;
2565
 
                        r->out.result = _wkssvc_NetrLogonDomainNameDel(cli->pipes_struct, r);
2566
 
                        return NT_STATUS_OK;
2567
 
                }
2568
 
 
2569
 
                case NDR_WKSSVC_NETRJOINDOMAIN: {
2570
 
                        struct wkssvc_NetrJoinDomain *r = (struct wkssvc_NetrJoinDomain *)_r;
2571
 
                        r->out.result = _wkssvc_NetrJoinDomain(cli->pipes_struct, r);
2572
 
                        return NT_STATUS_OK;
2573
 
                }
2574
 
 
2575
 
                case NDR_WKSSVC_NETRUNJOINDOMAIN: {
2576
 
                        struct wkssvc_NetrUnjoinDomain *r = (struct wkssvc_NetrUnjoinDomain *)_r;
2577
 
                        r->out.result = _wkssvc_NetrUnjoinDomain(cli->pipes_struct, r);
2578
 
                        return NT_STATUS_OK;
2579
 
                }
2580
 
 
2581
 
                case NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN: {
2582
 
                        struct wkssvc_NetrRenameMachineInDomain *r = (struct wkssvc_NetrRenameMachineInDomain *)_r;
2583
 
                        r->out.result = _wkssvc_NetrRenameMachineInDomain(cli->pipes_struct, r);
2584
 
                        return NT_STATUS_OK;
2585
 
                }
2586
 
 
2587
 
                case NDR_WKSSVC_NETRVALIDATENAME: {
2588
 
                        struct wkssvc_NetrValidateName *r = (struct wkssvc_NetrValidateName *)_r;
2589
 
                        r->out.result = _wkssvc_NetrValidateName(cli->pipes_struct, r);
2590
 
                        return NT_STATUS_OK;
2591
 
                }
2592
 
 
2593
 
                case NDR_WKSSVC_NETRGETJOININFORMATION: {
2594
 
                        struct wkssvc_NetrGetJoinInformation *r = (struct wkssvc_NetrGetJoinInformation *)_r;
2595
 
                        ZERO_STRUCT(r->out);
2596
 
                        r->out.name_buffer = r->in.name_buffer;
2597
 
                        r->out.name_type = talloc_zero(mem_ctx, enum wkssvc_NetJoinStatus);
2598
 
                        if (r->out.name_type == NULL) {
2599
 
                        return NT_STATUS_NO_MEMORY;
2600
 
                        }
2601
 
 
2602
 
                        r->out.result = _wkssvc_NetrGetJoinInformation(cli->pipes_struct, r);
2603
 
                        return NT_STATUS_OK;
2604
 
                }
2605
 
 
2606
 
                case NDR_WKSSVC_NETRGETJOINABLEOUS: {
2607
 
                        struct wkssvc_NetrGetJoinableOus *r = (struct wkssvc_NetrGetJoinableOus *)_r;
2608
 
                        ZERO_STRUCT(r->out);
2609
 
                        r->out.num_ous = r->in.num_ous;
2610
 
                        r->out.ous = talloc_zero(mem_ctx, const char **);
2611
 
                        if (r->out.ous == NULL) {
2612
 
                        return NT_STATUS_NO_MEMORY;
2613
 
                        }
2614
 
 
2615
 
                        r->out.result = _wkssvc_NetrGetJoinableOus(cli->pipes_struct, r);
2616
 
                        return NT_STATUS_OK;
2617
 
                }
2618
 
 
2619
 
                case NDR_WKSSVC_NETRJOINDOMAIN2: {
2620
 
                        struct wkssvc_NetrJoinDomain2 *r = (struct wkssvc_NetrJoinDomain2 *)_r;
2621
 
                        r->out.result = _wkssvc_NetrJoinDomain2(cli->pipes_struct, r);
2622
 
                        return NT_STATUS_OK;
2623
 
                }
2624
 
 
2625
 
                case NDR_WKSSVC_NETRUNJOINDOMAIN2: {
2626
 
                        struct wkssvc_NetrUnjoinDomain2 *r = (struct wkssvc_NetrUnjoinDomain2 *)_r;
2627
 
                        r->out.result = _wkssvc_NetrUnjoinDomain2(cli->pipes_struct, r);
2628
 
                        return NT_STATUS_OK;
2629
 
                }
2630
 
 
2631
 
                case NDR_WKSSVC_NETRRENAMEMACHINEINDOMAIN2: {
2632
 
                        struct wkssvc_NetrRenameMachineInDomain2 *r = (struct wkssvc_NetrRenameMachineInDomain2 *)_r;
2633
 
                        r->out.result = _wkssvc_NetrRenameMachineInDomain2(cli->pipes_struct, r);
2634
 
                        return NT_STATUS_OK;
2635
 
                }
2636
 
 
2637
 
                case NDR_WKSSVC_NETRVALIDATENAME2: {
2638
 
                        struct wkssvc_NetrValidateName2 *r = (struct wkssvc_NetrValidateName2 *)_r;
2639
 
                        r->out.result = _wkssvc_NetrValidateName2(cli->pipes_struct, r);
2640
 
                        return NT_STATUS_OK;
2641
 
                }
2642
 
 
2643
 
                case NDR_WKSSVC_NETRGETJOINABLEOUS2: {
2644
 
                        struct wkssvc_NetrGetJoinableOus2 *r = (struct wkssvc_NetrGetJoinableOus2 *)_r;
2645
 
                        ZERO_STRUCT(r->out);
2646
 
                        r->out.num_ous = r->in.num_ous;
2647
 
                        r->out.ous = talloc_zero(mem_ctx, const char **);
2648
 
                        if (r->out.ous == NULL) {
2649
 
                        return NT_STATUS_NO_MEMORY;
2650
 
                        }
2651
 
 
2652
 
                        r->out.result = _wkssvc_NetrGetJoinableOus2(cli->pipes_struct, r);
2653
 
                        return NT_STATUS_OK;
2654
 
                }
2655
 
 
2656
 
                case NDR_WKSSVC_NETRADDALTERNATECOMPUTERNAME: {
2657
 
                        struct wkssvc_NetrAddAlternateComputerName *r = (struct wkssvc_NetrAddAlternateComputerName *)_r;
2658
 
                        r->out.result = _wkssvc_NetrAddAlternateComputerName(cli->pipes_struct, r);
2659
 
                        return NT_STATUS_OK;
2660
 
                }
2661
 
 
2662
 
                case NDR_WKSSVC_NETRREMOVEALTERNATECOMPUTERNAME: {
2663
 
                        struct wkssvc_NetrRemoveAlternateComputerName *r = (struct wkssvc_NetrRemoveAlternateComputerName *)_r;
2664
 
                        r->out.result = _wkssvc_NetrRemoveAlternateComputerName(cli->pipes_struct, r);
2665
 
                        return NT_STATUS_OK;
2666
 
                }
2667
 
 
2668
 
                case NDR_WKSSVC_NETRSETPRIMARYCOMPUTERNAME: {
2669
 
                        struct wkssvc_NetrSetPrimaryComputername *r = (struct wkssvc_NetrSetPrimaryComputername *)_r;
2670
 
                        r->out.result = _wkssvc_NetrSetPrimaryComputername(cli->pipes_struct, r);
2671
 
                        return NT_STATUS_OK;
2672
 
                }
2673
 
 
2674
 
                case NDR_WKSSVC_NETRENUMERATECOMPUTERNAMES: {
2675
 
                        struct wkssvc_NetrEnumerateComputerNames *r = (struct wkssvc_NetrEnumerateComputerNames *)_r;
2676
 
                        ZERO_STRUCT(r->out);
2677
 
                        r->out.ctr = talloc_zero(mem_ctx, struct wkssvc_ComputerNamesCtr *);
2678
 
                        if (r->out.ctr == NULL) {
2679
 
                        return NT_STATUS_NO_MEMORY;
2680
 
                        }
2681
 
 
2682
 
                        r->out.result = _wkssvc_NetrEnumerateComputerNames(cli->pipes_struct, r);
2683
 
                        return NT_STATUS_OK;
2684
 
                }
2685
 
 
2686
 
                default:
2687
 
                        return NT_STATUS_NOT_IMPLEMENTED;
2688
 
        }
2689
 
}
2690
 
 
2691
 
NTSTATUS rpc_wkssvc_init(void)
2692
 
{
2693
 
        return rpc_srv_register(SMB_RPC_INTERFACE_VERSION, "wkssvc", "wkssvc", &ndr_table_wkssvc, api_wkssvc_cmds, sizeof(api_wkssvc_cmds) / sizeof(struct api_struct));
2694
 
}