Share RPC binding string utility functions.
[samba.git] / source3 / 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.entries_read = talloc_zero(r, uint32_t);
205         if (r->out.entries_read == NULL) {
206                 talloc_free(r);
207                 return false;
208         }
209
210         r->out.resume_handle = r->in.resume_handle;
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.total_entries = talloc_zero(r, uint32_t);
442         if (r->out.total_entries == NULL) {
443                 talloc_free(r);
444                 return false;
445         }
446
447         r->out.resume_handle = r->in.resume_handle;
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.entries_read = talloc_zero(r, uint32_t);
900         if (r->out.entries_read == NULL) {
901                 talloc_free(r);
902                 return false;
903         }
904
905         r->out.resume_handle = r->in.resume_handle;
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_init(void)
2410 {
2411         return rpc_pipe_register_commands(SMB_RPC_INTERFACE_VERSION, "wkssvc", "wkssvc", &ndr_table_wkssvc.syntax_id, api_wkssvc_cmds, sizeof(api_wkssvc_cmds) / sizeof(struct api_struct));
2412 }