s3-build: re-run make samba3-idl.
[ira/wip.git] / source3 / lib / netapi / libnetapi.c
1 /*
2  *  Unix SMB/CIFS implementation.
3  *  NetApi Support
4  *  Copyright (C) Guenther Deschner 2007-2008
5  *
6  *  This program is free software; you can redistribute it and/or modify
7  *  it under the terms of the GNU General Public License as published by
8  *  the Free Software Foundation; either version 3 of the License, or
9  *  (at your option) any later version.
10  *
11  *  This program is distributed in the hope that it will be useful,
12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14  *  GNU General Public License for more details.
15  *
16  *  You should have received a copy of the GNU General Public License
17  *  along with this program; if not, see <http://www.gnu.org/licenses/>.
18  */
19
20 #include "includes.h"
21 #include "librpc/gen_ndr/libnetapi.h"
22 #include "lib/netapi/netapi.h"
23 #include "lib/netapi/netapi_private.h"
24 #include "lib/netapi/libnetapi.h"
25 #include "librpc/gen_ndr/ndr_libnetapi.h"
26
27 /****************************************************************
28  NetJoinDomain
29 ****************************************************************/
30
31 NET_API_STATUS NetJoinDomain(const char * server /* [in] [unique] */,
32                              const char * domain /* [in] [ref] */,
33                              const char * account_ou /* [in] [unique] */,
34                              const char * account /* [in] [unique] */,
35                              const char * password /* [in] [unique] */,
36                              uint32_t join_flags /* [in] */)
37 {
38         struct NetJoinDomain r;
39         struct libnetapi_ctx *ctx = NULL;
40         NET_API_STATUS status;
41         WERROR werr;
42
43         status = libnetapi_getctx(&ctx);
44         if (status != 0) {
45                 return status;
46         }
47
48         /* In parameters */
49         r.in.server = server;
50         r.in.domain = domain;
51         r.in.account_ou = account_ou;
52         r.in.account = account;
53         r.in.password = password;
54         r.in.join_flags = join_flags;
55
56         /* Out parameters */
57
58         if (DEBUGLEVEL >= 10) {
59                 NDR_PRINT_IN_DEBUG(NetJoinDomain, &r);
60         }
61
62         if (LIBNETAPI_LOCAL_SERVER(server)) {
63                 werr = NetJoinDomain_l(ctx, &r);
64         } else {
65                 werr = NetJoinDomain_r(ctx, &r);
66         }
67
68         r.out.result = W_ERROR_V(werr);
69
70         if (DEBUGLEVEL >= 10) {
71                 NDR_PRINT_OUT_DEBUG(NetJoinDomain, &r);
72         }
73
74         return r.out.result;
75 }
76
77 /****************************************************************
78  NetUnjoinDomain
79 ****************************************************************/
80
81 NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] [unique] */,
82                                const char * account /* [in] [unique] */,
83                                const char * password /* [in] [unique] */,
84                                uint32_t unjoin_flags /* [in] */)
85 {
86         struct NetUnjoinDomain r;
87         struct libnetapi_ctx *ctx = NULL;
88         NET_API_STATUS status;
89         WERROR werr;
90
91         status = libnetapi_getctx(&ctx);
92         if (status != 0) {
93                 return status;
94         }
95
96         /* In parameters */
97         r.in.server_name = server_name;
98         r.in.account = account;
99         r.in.password = password;
100         r.in.unjoin_flags = unjoin_flags;
101
102         /* Out parameters */
103
104         if (DEBUGLEVEL >= 10) {
105                 NDR_PRINT_IN_DEBUG(NetUnjoinDomain, &r);
106         }
107
108         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
109                 werr = NetUnjoinDomain_l(ctx, &r);
110         } else {
111                 werr = NetUnjoinDomain_r(ctx, &r);
112         }
113
114         r.out.result = W_ERROR_V(werr);
115
116         if (DEBUGLEVEL >= 10) {
117                 NDR_PRINT_OUT_DEBUG(NetUnjoinDomain, &r);
118         }
119
120         return r.out.result;
121 }
122
123 /****************************************************************
124  NetGetJoinInformation
125 ****************************************************************/
126
127 NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] [unique] */,
128                                      const char * *name_buffer /* [out] [ref] */,
129                                      uint16_t *name_type /* [out] [ref] */)
130 {
131         struct NetGetJoinInformation r;
132         struct libnetapi_ctx *ctx = NULL;
133         NET_API_STATUS status;
134         WERROR werr;
135
136         status = libnetapi_getctx(&ctx);
137         if (status != 0) {
138                 return status;
139         }
140
141         /* In parameters */
142         r.in.server_name = server_name;
143
144         /* Out parameters */
145         r.out.name_buffer = name_buffer;
146         r.out.name_type = name_type;
147
148         if (DEBUGLEVEL >= 10) {
149                 NDR_PRINT_IN_DEBUG(NetGetJoinInformation, &r);
150         }
151
152         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
153                 werr = NetGetJoinInformation_l(ctx, &r);
154         } else {
155                 werr = NetGetJoinInformation_r(ctx, &r);
156         }
157
158         r.out.result = W_ERROR_V(werr);
159
160         if (DEBUGLEVEL >= 10) {
161                 NDR_PRINT_OUT_DEBUG(NetGetJoinInformation, &r);
162         }
163
164         return r.out.result;
165 }
166
167 /****************************************************************
168  NetGetJoinableOUs
169 ****************************************************************/
170
171 NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] [unique] */,
172                                  const char * domain /* [in] [ref] */,
173                                  const char * account /* [in] [unique] */,
174                                  const char * password /* [in] [unique] */,
175                                  uint32_t *ou_count /* [out] [ref] */,
176                                  const char * **ous /* [out] [ref] */)
177 {
178         struct NetGetJoinableOUs r;
179         struct libnetapi_ctx *ctx = NULL;
180         NET_API_STATUS status;
181         WERROR werr;
182
183         status = libnetapi_getctx(&ctx);
184         if (status != 0) {
185                 return status;
186         }
187
188         /* In parameters */
189         r.in.server_name = server_name;
190         r.in.domain = domain;
191         r.in.account = account;
192         r.in.password = password;
193
194         /* Out parameters */
195         r.out.ou_count = ou_count;
196         r.out.ous = ous;
197
198         if (DEBUGLEVEL >= 10) {
199                 NDR_PRINT_IN_DEBUG(NetGetJoinableOUs, &r);
200         }
201
202         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
203                 werr = NetGetJoinableOUs_l(ctx, &r);
204         } else {
205                 werr = NetGetJoinableOUs_r(ctx, &r);
206         }
207
208         r.out.result = W_ERROR_V(werr);
209
210         if (DEBUGLEVEL >= 10) {
211                 NDR_PRINT_OUT_DEBUG(NetGetJoinableOUs, &r);
212         }
213
214         return r.out.result;
215 }
216
217 /****************************************************************
218  NetRenameMachineInDomain
219 ****************************************************************/
220
221 NET_API_STATUS NetRenameMachineInDomain(const char * server_name /* [in] */,
222                                         const char * new_machine_name /* [in] */,
223                                         const char * account /* [in] */,
224                                         const char * password /* [in] */,
225                                         uint32_t rename_options /* [in] */)
226 {
227         struct NetRenameMachineInDomain r;
228         struct libnetapi_ctx *ctx = NULL;
229         NET_API_STATUS status;
230         WERROR werr;
231
232         status = libnetapi_getctx(&ctx);
233         if (status != 0) {
234                 return status;
235         }
236
237         /* In parameters */
238         r.in.server_name = server_name;
239         r.in.new_machine_name = new_machine_name;
240         r.in.account = account;
241         r.in.password = password;
242         r.in.rename_options = rename_options;
243
244         /* Out parameters */
245
246         if (DEBUGLEVEL >= 10) {
247                 NDR_PRINT_IN_DEBUG(NetRenameMachineInDomain, &r);
248         }
249
250         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
251                 werr = NetRenameMachineInDomain_l(ctx, &r);
252         } else {
253                 werr = NetRenameMachineInDomain_r(ctx, &r);
254         }
255
256         r.out.result = W_ERROR_V(werr);
257
258         if (DEBUGLEVEL >= 10) {
259                 NDR_PRINT_OUT_DEBUG(NetRenameMachineInDomain, &r);
260         }
261
262         return r.out.result;
263 }
264
265 /****************************************************************
266  NetServerGetInfo
267 ****************************************************************/
268
269 NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] [unique] */,
270                                 uint32_t level /* [in] */,
271                                 uint8_t **buffer /* [out] [ref] */)
272 {
273         struct NetServerGetInfo r;
274         struct libnetapi_ctx *ctx = NULL;
275         NET_API_STATUS status;
276         WERROR werr;
277
278         status = libnetapi_getctx(&ctx);
279         if (status != 0) {
280                 return status;
281         }
282
283         /* In parameters */
284         r.in.server_name = server_name;
285         r.in.level = level;
286
287         /* Out parameters */
288         r.out.buffer = buffer;
289
290         if (DEBUGLEVEL >= 10) {
291                 NDR_PRINT_IN_DEBUG(NetServerGetInfo, &r);
292         }
293
294         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
295                 werr = NetServerGetInfo_l(ctx, &r);
296         } else {
297                 werr = NetServerGetInfo_r(ctx, &r);
298         }
299
300         r.out.result = W_ERROR_V(werr);
301
302         if (DEBUGLEVEL >= 10) {
303                 NDR_PRINT_OUT_DEBUG(NetServerGetInfo, &r);
304         }
305
306         return r.out.result;
307 }
308
309 /****************************************************************
310  NetServerSetInfo
311 ****************************************************************/
312
313 NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] [unique] */,
314                                 uint32_t level /* [in] */,
315                                 uint8_t *buffer /* [in] [ref] */,
316                                 uint32_t *parm_error /* [out] [ref] */)
317 {
318         struct NetServerSetInfo r;
319         struct libnetapi_ctx *ctx = NULL;
320         NET_API_STATUS status;
321         WERROR werr;
322
323         status = libnetapi_getctx(&ctx);
324         if (status != 0) {
325                 return status;
326         }
327
328         /* In parameters */
329         r.in.server_name = server_name;
330         r.in.level = level;
331         r.in.buffer = buffer;
332
333         /* Out parameters */
334         r.out.parm_error = parm_error;
335
336         if (DEBUGLEVEL >= 10) {
337                 NDR_PRINT_IN_DEBUG(NetServerSetInfo, &r);
338         }
339
340         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
341                 werr = NetServerSetInfo_l(ctx, &r);
342         } else {
343                 werr = NetServerSetInfo_r(ctx, &r);
344         }
345
346         r.out.result = W_ERROR_V(werr);
347
348         if (DEBUGLEVEL >= 10) {
349                 NDR_PRINT_OUT_DEBUG(NetServerSetInfo, &r);
350         }
351
352         return r.out.result;
353 }
354
355 /****************************************************************
356  NetGetDCName
357 ****************************************************************/
358
359 NET_API_STATUS NetGetDCName(const char * server_name /* [in] [unique] */,
360                             const char * domain_name /* [in] [unique] */,
361                             uint8_t **buffer /* [out] [ref] */)
362 {
363         struct NetGetDCName r;
364         struct libnetapi_ctx *ctx = NULL;
365         NET_API_STATUS status;
366         WERROR werr;
367
368         status = libnetapi_getctx(&ctx);
369         if (status != 0) {
370                 return status;
371         }
372
373         /* In parameters */
374         r.in.server_name = server_name;
375         r.in.domain_name = domain_name;
376
377         /* Out parameters */
378         r.out.buffer = buffer;
379
380         if (DEBUGLEVEL >= 10) {
381                 NDR_PRINT_IN_DEBUG(NetGetDCName, &r);
382         }
383
384         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
385                 werr = NetGetDCName_l(ctx, &r);
386         } else {
387                 werr = NetGetDCName_r(ctx, &r);
388         }
389
390         r.out.result = W_ERROR_V(werr);
391
392         if (DEBUGLEVEL >= 10) {
393                 NDR_PRINT_OUT_DEBUG(NetGetDCName, &r);
394         }
395
396         return r.out.result;
397 }
398
399 /****************************************************************
400  NetGetAnyDCName
401 ****************************************************************/
402
403 NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] [unique] */,
404                                const char * domain_name /* [in] [unique] */,
405                                uint8_t **buffer /* [out] [ref] */)
406 {
407         struct NetGetAnyDCName r;
408         struct libnetapi_ctx *ctx = NULL;
409         NET_API_STATUS status;
410         WERROR werr;
411
412         status = libnetapi_getctx(&ctx);
413         if (status != 0) {
414                 return status;
415         }
416
417         /* In parameters */
418         r.in.server_name = server_name;
419         r.in.domain_name = domain_name;
420
421         /* Out parameters */
422         r.out.buffer = buffer;
423
424         if (DEBUGLEVEL >= 10) {
425                 NDR_PRINT_IN_DEBUG(NetGetAnyDCName, &r);
426         }
427
428         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
429                 werr = NetGetAnyDCName_l(ctx, &r);
430         } else {
431                 werr = NetGetAnyDCName_r(ctx, &r);
432         }
433
434         r.out.result = W_ERROR_V(werr);
435
436         if (DEBUGLEVEL >= 10) {
437                 NDR_PRINT_OUT_DEBUG(NetGetAnyDCName, &r);
438         }
439
440         return r.out.result;
441 }
442
443 /****************************************************************
444  DsGetDcName
445 ****************************************************************/
446
447 NET_API_STATUS DsGetDcName(const char * server_name /* [in] [unique] */,
448                            const char * domain_name /* [in] [ref] */,
449                            struct GUID *domain_guid /* [in] [unique] */,
450                            const char * site_name /* [in] [unique] */,
451                            uint32_t flags /* [in] */,
452                            struct DOMAIN_CONTROLLER_INFO **dc_info /* [out] [ref] */)
453 {
454         struct DsGetDcName r;
455         struct libnetapi_ctx *ctx = NULL;
456         NET_API_STATUS status;
457         WERROR werr;
458
459         status = libnetapi_getctx(&ctx);
460         if (status != 0) {
461                 return status;
462         }
463
464         /* In parameters */
465         r.in.server_name = server_name;
466         r.in.domain_name = domain_name;
467         r.in.domain_guid = domain_guid;
468         r.in.site_name = site_name;
469         r.in.flags = flags;
470
471         /* Out parameters */
472         r.out.dc_info = dc_info;
473
474         if (DEBUGLEVEL >= 10) {
475                 NDR_PRINT_IN_DEBUG(DsGetDcName, &r);
476         }
477
478         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
479                 werr = DsGetDcName_l(ctx, &r);
480         } else {
481                 werr = DsGetDcName_r(ctx, &r);
482         }
483
484         r.out.result = W_ERROR_V(werr);
485
486         if (DEBUGLEVEL >= 10) {
487                 NDR_PRINT_OUT_DEBUG(DsGetDcName, &r);
488         }
489
490         return r.out.result;
491 }
492
493 /****************************************************************
494  NetUserAdd
495 ****************************************************************/
496
497 NET_API_STATUS NetUserAdd(const char * server_name /* [in] [unique] */,
498                           uint32_t level /* [in] */,
499                           uint8_t *buffer /* [in] [ref] */,
500                           uint32_t *parm_error /* [out] [ref] */)
501 {
502         struct NetUserAdd r;
503         struct libnetapi_ctx *ctx = NULL;
504         NET_API_STATUS status;
505         WERROR werr;
506
507         status = libnetapi_getctx(&ctx);
508         if (status != 0) {
509                 return status;
510         }
511
512         /* In parameters */
513         r.in.server_name = server_name;
514         r.in.level = level;
515         r.in.buffer = buffer;
516
517         /* Out parameters */
518         r.out.parm_error = parm_error;
519
520         if (DEBUGLEVEL >= 10) {
521                 NDR_PRINT_IN_DEBUG(NetUserAdd, &r);
522         }
523
524         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
525                 werr = NetUserAdd_l(ctx, &r);
526         } else {
527                 werr = NetUserAdd_r(ctx, &r);
528         }
529
530         r.out.result = W_ERROR_V(werr);
531
532         if (DEBUGLEVEL >= 10) {
533                 NDR_PRINT_OUT_DEBUG(NetUserAdd, &r);
534         }
535
536         return r.out.result;
537 }
538
539 /****************************************************************
540  NetUserDel
541 ****************************************************************/
542
543 NET_API_STATUS NetUserDel(const char * server_name /* [in] [unique] */,
544                           const char * user_name /* [in] [ref] */)
545 {
546         struct NetUserDel r;
547         struct libnetapi_ctx *ctx = NULL;
548         NET_API_STATUS status;
549         WERROR werr;
550
551         status = libnetapi_getctx(&ctx);
552         if (status != 0) {
553                 return status;
554         }
555
556         /* In parameters */
557         r.in.server_name = server_name;
558         r.in.user_name = user_name;
559
560         /* Out parameters */
561
562         if (DEBUGLEVEL >= 10) {
563                 NDR_PRINT_IN_DEBUG(NetUserDel, &r);
564         }
565
566         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
567                 werr = NetUserDel_l(ctx, &r);
568         } else {
569                 werr = NetUserDel_r(ctx, &r);
570         }
571
572         r.out.result = W_ERROR_V(werr);
573
574         if (DEBUGLEVEL >= 10) {
575                 NDR_PRINT_OUT_DEBUG(NetUserDel, &r);
576         }
577
578         return r.out.result;
579 }
580
581 /****************************************************************
582  NetUserEnum
583 ****************************************************************/
584
585 NET_API_STATUS NetUserEnum(const char * server_name /* [in] [unique] */,
586                            uint32_t level /* [in] */,
587                            uint32_t filter /* [in] */,
588                            uint8_t **buffer /* [out] [ref] */,
589                            uint32_t prefmaxlen /* [in] */,
590                            uint32_t *entries_read /* [out] [ref] */,
591                            uint32_t *total_entries /* [out] [ref] */,
592                            uint32_t *resume_handle /* [in,out] [ref] */)
593 {
594         struct NetUserEnum r;
595         struct libnetapi_ctx *ctx = NULL;
596         NET_API_STATUS status;
597         WERROR werr;
598
599         status = libnetapi_getctx(&ctx);
600         if (status != 0) {
601                 return status;
602         }
603
604         /* In parameters */
605         r.in.server_name = server_name;
606         r.in.level = level;
607         r.in.filter = filter;
608         r.in.prefmaxlen = prefmaxlen;
609         r.in.resume_handle = resume_handle;
610
611         /* Out parameters */
612         r.out.buffer = buffer;
613         r.out.entries_read = entries_read;
614         r.out.total_entries = total_entries;
615         r.out.resume_handle = resume_handle;
616
617         if (DEBUGLEVEL >= 10) {
618                 NDR_PRINT_IN_DEBUG(NetUserEnum, &r);
619         }
620
621         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
622                 werr = NetUserEnum_l(ctx, &r);
623         } else {
624                 werr = NetUserEnum_r(ctx, &r);
625         }
626
627         r.out.result = W_ERROR_V(werr);
628
629         if (DEBUGLEVEL >= 10) {
630                 NDR_PRINT_OUT_DEBUG(NetUserEnum, &r);
631         }
632
633         return r.out.result;
634 }
635
636 /****************************************************************
637  NetUserChangePassword
638 ****************************************************************/
639
640 NET_API_STATUS NetUserChangePassword(const char * domain_name /* [in] */,
641                                      const char * user_name /* [in] */,
642                                      const char * old_password /* [in] */,
643                                      const char * new_password /* [in] */)
644 {
645         struct NetUserChangePassword r;
646         struct libnetapi_ctx *ctx = NULL;
647         NET_API_STATUS status;
648         WERROR werr;
649
650         status = libnetapi_getctx(&ctx);
651         if (status != 0) {
652                 return status;
653         }
654
655         /* In parameters */
656         r.in.domain_name = domain_name;
657         r.in.user_name = user_name;
658         r.in.old_password = old_password;
659         r.in.new_password = new_password;
660
661         /* Out parameters */
662
663         if (DEBUGLEVEL >= 10) {
664                 NDR_PRINT_IN_DEBUG(NetUserChangePassword, &r);
665         }
666
667         if (LIBNETAPI_LOCAL_SERVER(domain_name)) {
668                 werr = NetUserChangePassword_l(ctx, &r);
669         } else {
670                 werr = NetUserChangePassword_r(ctx, &r);
671         }
672
673         r.out.result = W_ERROR_V(werr);
674
675         if (DEBUGLEVEL >= 10) {
676                 NDR_PRINT_OUT_DEBUG(NetUserChangePassword, &r);
677         }
678
679         return r.out.result;
680 }
681
682 /****************************************************************
683  NetUserGetInfo
684 ****************************************************************/
685
686 NET_API_STATUS NetUserGetInfo(const char * server_name /* [in] */,
687                               const char * user_name /* [in] */,
688                               uint32_t level /* [in] */,
689                               uint8_t **buffer /* [out] [ref] */)
690 {
691         struct NetUserGetInfo r;
692         struct libnetapi_ctx *ctx = NULL;
693         NET_API_STATUS status;
694         WERROR werr;
695
696         status = libnetapi_getctx(&ctx);
697         if (status != 0) {
698                 return status;
699         }
700
701         /* In parameters */
702         r.in.server_name = server_name;
703         r.in.user_name = user_name;
704         r.in.level = level;
705
706         /* Out parameters */
707         r.out.buffer = buffer;
708
709         if (DEBUGLEVEL >= 10) {
710                 NDR_PRINT_IN_DEBUG(NetUserGetInfo, &r);
711         }
712
713         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
714                 werr = NetUserGetInfo_l(ctx, &r);
715         } else {
716                 werr = NetUserGetInfo_r(ctx, &r);
717         }
718
719         r.out.result = W_ERROR_V(werr);
720
721         if (DEBUGLEVEL >= 10) {
722                 NDR_PRINT_OUT_DEBUG(NetUserGetInfo, &r);
723         }
724
725         return r.out.result;
726 }
727
728 /****************************************************************
729  NetUserSetInfo
730 ****************************************************************/
731
732 NET_API_STATUS NetUserSetInfo(const char * server_name /* [in] */,
733                               const char * user_name /* [in] */,
734                               uint32_t level /* [in] */,
735                               uint8_t *buffer /* [in] [ref] */,
736                               uint32_t *parm_err /* [out] [ref] */)
737 {
738         struct NetUserSetInfo r;
739         struct libnetapi_ctx *ctx = NULL;
740         NET_API_STATUS status;
741         WERROR werr;
742
743         status = libnetapi_getctx(&ctx);
744         if (status != 0) {
745                 return status;
746         }
747
748         /* In parameters */
749         r.in.server_name = server_name;
750         r.in.user_name = user_name;
751         r.in.level = level;
752         r.in.buffer = buffer;
753
754         /* Out parameters */
755         r.out.parm_err = parm_err;
756
757         if (DEBUGLEVEL >= 10) {
758                 NDR_PRINT_IN_DEBUG(NetUserSetInfo, &r);
759         }
760
761         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
762                 werr = NetUserSetInfo_l(ctx, &r);
763         } else {
764                 werr = NetUserSetInfo_r(ctx, &r);
765         }
766
767         r.out.result = W_ERROR_V(werr);
768
769         if (DEBUGLEVEL >= 10) {
770                 NDR_PRINT_OUT_DEBUG(NetUserSetInfo, &r);
771         }
772
773         return r.out.result;
774 }
775
776 /****************************************************************
777  NetUserGetGroups
778 ****************************************************************/
779
780 NET_API_STATUS NetUserGetGroups(const char * server_name /* [in] */,
781                                 const char * user_name /* [in] */,
782                                 uint32_t level /* [in] */,
783                                 uint8_t **buffer /* [out] [ref] */,
784                                 uint32_t prefmaxlen /* [in] */,
785                                 uint32_t *entries_read /* [out] [ref] */,
786                                 uint32_t *total_entries /* [out] [ref] */)
787 {
788         struct NetUserGetGroups r;
789         struct libnetapi_ctx *ctx = NULL;
790         NET_API_STATUS status;
791         WERROR werr;
792
793         status = libnetapi_getctx(&ctx);
794         if (status != 0) {
795                 return status;
796         }
797
798         /* In parameters */
799         r.in.server_name = server_name;
800         r.in.user_name = user_name;
801         r.in.level = level;
802         r.in.prefmaxlen = prefmaxlen;
803
804         /* Out parameters */
805         r.out.buffer = buffer;
806         r.out.entries_read = entries_read;
807         r.out.total_entries = total_entries;
808
809         if (DEBUGLEVEL >= 10) {
810                 NDR_PRINT_IN_DEBUG(NetUserGetGroups, &r);
811         }
812
813         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
814                 werr = NetUserGetGroups_l(ctx, &r);
815         } else {
816                 werr = NetUserGetGroups_r(ctx, &r);
817         }
818
819         r.out.result = W_ERROR_V(werr);
820
821         if (DEBUGLEVEL >= 10) {
822                 NDR_PRINT_OUT_DEBUG(NetUserGetGroups, &r);
823         }
824
825         return r.out.result;
826 }
827
828 /****************************************************************
829  NetUserSetGroups
830 ****************************************************************/
831
832 NET_API_STATUS NetUserSetGroups(const char * server_name /* [in] */,
833                                 const char * user_name /* [in] */,
834                                 uint32_t level /* [in] */,
835                                 uint8_t *buffer /* [in] [ref] */,
836                                 uint32_t num_entries /* [in] */)
837 {
838         struct NetUserSetGroups r;
839         struct libnetapi_ctx *ctx = NULL;
840         NET_API_STATUS status;
841         WERROR werr;
842
843         status = libnetapi_getctx(&ctx);
844         if (status != 0) {
845                 return status;
846         }
847
848         /* In parameters */
849         r.in.server_name = server_name;
850         r.in.user_name = user_name;
851         r.in.level = level;
852         r.in.buffer = buffer;
853         r.in.num_entries = num_entries;
854
855         /* Out parameters */
856
857         if (DEBUGLEVEL >= 10) {
858                 NDR_PRINT_IN_DEBUG(NetUserSetGroups, &r);
859         }
860
861         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
862                 werr = NetUserSetGroups_l(ctx, &r);
863         } else {
864                 werr = NetUserSetGroups_r(ctx, &r);
865         }
866
867         r.out.result = W_ERROR_V(werr);
868
869         if (DEBUGLEVEL >= 10) {
870                 NDR_PRINT_OUT_DEBUG(NetUserSetGroups, &r);
871         }
872
873         return r.out.result;
874 }
875
876 /****************************************************************
877  NetUserGetLocalGroups
878 ****************************************************************/
879
880 NET_API_STATUS NetUserGetLocalGroups(const char * server_name /* [in] */,
881                                      const char * user_name /* [in] */,
882                                      uint32_t level /* [in] */,
883                                      uint32_t flags /* [in] */,
884                                      uint8_t **buffer /* [out] [ref] */,
885                                      uint32_t prefmaxlen /* [in] */,
886                                      uint32_t *entries_read /* [out] [ref] */,
887                                      uint32_t *total_entries /* [out] [ref] */)
888 {
889         struct NetUserGetLocalGroups r;
890         struct libnetapi_ctx *ctx = NULL;
891         NET_API_STATUS status;
892         WERROR werr;
893
894         status = libnetapi_getctx(&ctx);
895         if (status != 0) {
896                 return status;
897         }
898
899         /* In parameters */
900         r.in.server_name = server_name;
901         r.in.user_name = user_name;
902         r.in.level = level;
903         r.in.flags = flags;
904         r.in.prefmaxlen = prefmaxlen;
905
906         /* Out parameters */
907         r.out.buffer = buffer;
908         r.out.entries_read = entries_read;
909         r.out.total_entries = total_entries;
910
911         if (DEBUGLEVEL >= 10) {
912                 NDR_PRINT_IN_DEBUG(NetUserGetLocalGroups, &r);
913         }
914
915         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
916                 werr = NetUserGetLocalGroups_l(ctx, &r);
917         } else {
918                 werr = NetUserGetLocalGroups_r(ctx, &r);
919         }
920
921         r.out.result = W_ERROR_V(werr);
922
923         if (DEBUGLEVEL >= 10) {
924                 NDR_PRINT_OUT_DEBUG(NetUserGetLocalGroups, &r);
925         }
926
927         return r.out.result;
928 }
929
930 /****************************************************************
931  NetUserModalsGet
932 ****************************************************************/
933
934 NET_API_STATUS NetUserModalsGet(const char * server_name /* [in] */,
935                                 uint32_t level /* [in] */,
936                                 uint8_t **buffer /* [out] [ref] */)
937 {
938         struct NetUserModalsGet r;
939         struct libnetapi_ctx *ctx = NULL;
940         NET_API_STATUS status;
941         WERROR werr;
942
943         status = libnetapi_getctx(&ctx);
944         if (status != 0) {
945                 return status;
946         }
947
948         /* In parameters */
949         r.in.server_name = server_name;
950         r.in.level = level;
951
952         /* Out parameters */
953         r.out.buffer = buffer;
954
955         if (DEBUGLEVEL >= 10) {
956                 NDR_PRINT_IN_DEBUG(NetUserModalsGet, &r);
957         }
958
959         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
960                 werr = NetUserModalsGet_l(ctx, &r);
961         } else {
962                 werr = NetUserModalsGet_r(ctx, &r);
963         }
964
965         r.out.result = W_ERROR_V(werr);
966
967         if (DEBUGLEVEL >= 10) {
968                 NDR_PRINT_OUT_DEBUG(NetUserModalsGet, &r);
969         }
970
971         return r.out.result;
972 }
973
974 /****************************************************************
975  NetUserModalsSet
976 ****************************************************************/
977
978 NET_API_STATUS NetUserModalsSet(const char * server_name /* [in] */,
979                                 uint32_t level /* [in] */,
980                                 uint8_t *buffer /* [in] [ref] */,
981                                 uint32_t *parm_err /* [out] [ref] */)
982 {
983         struct NetUserModalsSet r;
984         struct libnetapi_ctx *ctx = NULL;
985         NET_API_STATUS status;
986         WERROR werr;
987
988         status = libnetapi_getctx(&ctx);
989         if (status != 0) {
990                 return status;
991         }
992
993         /* In parameters */
994         r.in.server_name = server_name;
995         r.in.level = level;
996         r.in.buffer = buffer;
997
998         /* Out parameters */
999         r.out.parm_err = parm_err;
1000
1001         if (DEBUGLEVEL >= 10) {
1002                 NDR_PRINT_IN_DEBUG(NetUserModalsSet, &r);
1003         }
1004
1005         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1006                 werr = NetUserModalsSet_l(ctx, &r);
1007         } else {
1008                 werr = NetUserModalsSet_r(ctx, &r);
1009         }
1010
1011         r.out.result = W_ERROR_V(werr);
1012
1013         if (DEBUGLEVEL >= 10) {
1014                 NDR_PRINT_OUT_DEBUG(NetUserModalsSet, &r);
1015         }
1016
1017         return r.out.result;
1018 }
1019
1020 /****************************************************************
1021  NetQueryDisplayInformation
1022 ****************************************************************/
1023
1024 NET_API_STATUS NetQueryDisplayInformation(const char * server_name /* [in] [unique] */,
1025                                           uint32_t level /* [in] */,
1026                                           uint32_t idx /* [in] */,
1027                                           uint32_t entries_requested /* [in] */,
1028                                           uint32_t prefmaxlen /* [in] */,
1029                                           uint32_t *entries_read /* [out] [ref] */,
1030                                           void **buffer /* [out] [noprint,ref] */)
1031 {
1032         struct NetQueryDisplayInformation r;
1033         struct libnetapi_ctx *ctx = NULL;
1034         NET_API_STATUS status;
1035         WERROR werr;
1036
1037         status = libnetapi_getctx(&ctx);
1038         if (status != 0) {
1039                 return status;
1040         }
1041
1042         /* In parameters */
1043         r.in.server_name = server_name;
1044         r.in.level = level;
1045         r.in.idx = idx;
1046         r.in.entries_requested = entries_requested;
1047         r.in.prefmaxlen = prefmaxlen;
1048
1049         /* Out parameters */
1050         r.out.entries_read = entries_read;
1051         r.out.buffer = buffer;
1052
1053         if (DEBUGLEVEL >= 10) {
1054                 NDR_PRINT_IN_DEBUG(NetQueryDisplayInformation, &r);
1055         }
1056
1057         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1058                 werr = NetQueryDisplayInformation_l(ctx, &r);
1059         } else {
1060                 werr = NetQueryDisplayInformation_r(ctx, &r);
1061         }
1062
1063         r.out.result = W_ERROR_V(werr);
1064
1065         if (DEBUGLEVEL >= 10) {
1066                 NDR_PRINT_OUT_DEBUG(NetQueryDisplayInformation, &r);
1067         }
1068
1069         return r.out.result;
1070 }
1071
1072 /****************************************************************
1073  NetGroupAdd
1074 ****************************************************************/
1075
1076 NET_API_STATUS NetGroupAdd(const char * server_name /* [in] */,
1077                            uint32_t level /* [in] */,
1078                            uint8_t *buffer /* [in] [ref] */,
1079                            uint32_t *parm_err /* [out] [ref] */)
1080 {
1081         struct NetGroupAdd r;
1082         struct libnetapi_ctx *ctx = NULL;
1083         NET_API_STATUS status;
1084         WERROR werr;
1085
1086         status = libnetapi_getctx(&ctx);
1087         if (status != 0) {
1088                 return status;
1089         }
1090
1091         /* In parameters */
1092         r.in.server_name = server_name;
1093         r.in.level = level;
1094         r.in.buffer = buffer;
1095
1096         /* Out parameters */
1097         r.out.parm_err = parm_err;
1098
1099         if (DEBUGLEVEL >= 10) {
1100                 NDR_PRINT_IN_DEBUG(NetGroupAdd, &r);
1101         }
1102
1103         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1104                 werr = NetGroupAdd_l(ctx, &r);
1105         } else {
1106                 werr = NetGroupAdd_r(ctx, &r);
1107         }
1108
1109         r.out.result = W_ERROR_V(werr);
1110
1111         if (DEBUGLEVEL >= 10) {
1112                 NDR_PRINT_OUT_DEBUG(NetGroupAdd, &r);
1113         }
1114
1115         return r.out.result;
1116 }
1117
1118 /****************************************************************
1119  NetGroupDel
1120 ****************************************************************/
1121
1122 NET_API_STATUS NetGroupDel(const char * server_name /* [in] */,
1123                            const char * group_name /* [in] */)
1124 {
1125         struct NetGroupDel r;
1126         struct libnetapi_ctx *ctx = NULL;
1127         NET_API_STATUS status;
1128         WERROR werr;
1129
1130         status = libnetapi_getctx(&ctx);
1131         if (status != 0) {
1132                 return status;
1133         }
1134
1135         /* In parameters */
1136         r.in.server_name = server_name;
1137         r.in.group_name = group_name;
1138
1139         /* Out parameters */
1140
1141         if (DEBUGLEVEL >= 10) {
1142                 NDR_PRINT_IN_DEBUG(NetGroupDel, &r);
1143         }
1144
1145         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1146                 werr = NetGroupDel_l(ctx, &r);
1147         } else {
1148                 werr = NetGroupDel_r(ctx, &r);
1149         }
1150
1151         r.out.result = W_ERROR_V(werr);
1152
1153         if (DEBUGLEVEL >= 10) {
1154                 NDR_PRINT_OUT_DEBUG(NetGroupDel, &r);
1155         }
1156
1157         return r.out.result;
1158 }
1159
1160 /****************************************************************
1161  NetGroupEnum
1162 ****************************************************************/
1163
1164 NET_API_STATUS NetGroupEnum(const char * server_name /* [in] */,
1165                             uint32_t level /* [in] */,
1166                             uint8_t **buffer /* [out] [ref] */,
1167                             uint32_t prefmaxlen /* [in] */,
1168                             uint32_t *entries_read /* [out] [ref] */,
1169                             uint32_t *total_entries /* [out] [ref] */,
1170                             uint32_t *resume_handle /* [in,out] [ref] */)
1171 {
1172         struct NetGroupEnum r;
1173         struct libnetapi_ctx *ctx = NULL;
1174         NET_API_STATUS status;
1175         WERROR werr;
1176
1177         status = libnetapi_getctx(&ctx);
1178         if (status != 0) {
1179                 return status;
1180         }
1181
1182         /* In parameters */
1183         r.in.server_name = server_name;
1184         r.in.level = level;
1185         r.in.prefmaxlen = prefmaxlen;
1186         r.in.resume_handle = resume_handle;
1187
1188         /* Out parameters */
1189         r.out.buffer = buffer;
1190         r.out.entries_read = entries_read;
1191         r.out.total_entries = total_entries;
1192         r.out.resume_handle = resume_handle;
1193
1194         if (DEBUGLEVEL >= 10) {
1195                 NDR_PRINT_IN_DEBUG(NetGroupEnum, &r);
1196         }
1197
1198         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1199                 werr = NetGroupEnum_l(ctx, &r);
1200         } else {
1201                 werr = NetGroupEnum_r(ctx, &r);
1202         }
1203
1204         r.out.result = W_ERROR_V(werr);
1205
1206         if (DEBUGLEVEL >= 10) {
1207                 NDR_PRINT_OUT_DEBUG(NetGroupEnum, &r);
1208         }
1209
1210         return r.out.result;
1211 }
1212
1213 /****************************************************************
1214  NetGroupSetInfo
1215 ****************************************************************/
1216
1217 NET_API_STATUS NetGroupSetInfo(const char * server_name /* [in] */,
1218                                const char * group_name /* [in] */,
1219                                uint32_t level /* [in] */,
1220                                uint8_t *buffer /* [in] [ref] */,
1221                                uint32_t *parm_err /* [out] [ref] */)
1222 {
1223         struct NetGroupSetInfo r;
1224         struct libnetapi_ctx *ctx = NULL;
1225         NET_API_STATUS status;
1226         WERROR werr;
1227
1228         status = libnetapi_getctx(&ctx);
1229         if (status != 0) {
1230                 return status;
1231         }
1232
1233         /* In parameters */
1234         r.in.server_name = server_name;
1235         r.in.group_name = group_name;
1236         r.in.level = level;
1237         r.in.buffer = buffer;
1238
1239         /* Out parameters */
1240         r.out.parm_err = parm_err;
1241
1242         if (DEBUGLEVEL >= 10) {
1243                 NDR_PRINT_IN_DEBUG(NetGroupSetInfo, &r);
1244         }
1245
1246         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1247                 werr = NetGroupSetInfo_l(ctx, &r);
1248         } else {
1249                 werr = NetGroupSetInfo_r(ctx, &r);
1250         }
1251
1252         r.out.result = W_ERROR_V(werr);
1253
1254         if (DEBUGLEVEL >= 10) {
1255                 NDR_PRINT_OUT_DEBUG(NetGroupSetInfo, &r);
1256         }
1257
1258         return r.out.result;
1259 }
1260
1261 /****************************************************************
1262  NetGroupGetInfo
1263 ****************************************************************/
1264
1265 NET_API_STATUS NetGroupGetInfo(const char * server_name /* [in] */,
1266                                const char * group_name /* [in] */,
1267                                uint32_t level /* [in] */,
1268                                uint8_t **buffer /* [out] [ref] */)
1269 {
1270         struct NetGroupGetInfo r;
1271         struct libnetapi_ctx *ctx = NULL;
1272         NET_API_STATUS status;
1273         WERROR werr;
1274
1275         status = libnetapi_getctx(&ctx);
1276         if (status != 0) {
1277                 return status;
1278         }
1279
1280         /* In parameters */
1281         r.in.server_name = server_name;
1282         r.in.group_name = group_name;
1283         r.in.level = level;
1284
1285         /* Out parameters */
1286         r.out.buffer = buffer;
1287
1288         if (DEBUGLEVEL >= 10) {
1289                 NDR_PRINT_IN_DEBUG(NetGroupGetInfo, &r);
1290         }
1291
1292         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1293                 werr = NetGroupGetInfo_l(ctx, &r);
1294         } else {
1295                 werr = NetGroupGetInfo_r(ctx, &r);
1296         }
1297
1298         r.out.result = W_ERROR_V(werr);
1299
1300         if (DEBUGLEVEL >= 10) {
1301                 NDR_PRINT_OUT_DEBUG(NetGroupGetInfo, &r);
1302         }
1303
1304         return r.out.result;
1305 }
1306
1307 /****************************************************************
1308  NetGroupAddUser
1309 ****************************************************************/
1310
1311 NET_API_STATUS NetGroupAddUser(const char * server_name /* [in] */,
1312                                const char * group_name /* [in] */,
1313                                const char * user_name /* [in] */)
1314 {
1315         struct NetGroupAddUser r;
1316         struct libnetapi_ctx *ctx = NULL;
1317         NET_API_STATUS status;
1318         WERROR werr;
1319
1320         status = libnetapi_getctx(&ctx);
1321         if (status != 0) {
1322                 return status;
1323         }
1324
1325         /* In parameters */
1326         r.in.server_name = server_name;
1327         r.in.group_name = group_name;
1328         r.in.user_name = user_name;
1329
1330         /* Out parameters */
1331
1332         if (DEBUGLEVEL >= 10) {
1333                 NDR_PRINT_IN_DEBUG(NetGroupAddUser, &r);
1334         }
1335
1336         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1337                 werr = NetGroupAddUser_l(ctx, &r);
1338         } else {
1339                 werr = NetGroupAddUser_r(ctx, &r);
1340         }
1341
1342         r.out.result = W_ERROR_V(werr);
1343
1344         if (DEBUGLEVEL >= 10) {
1345                 NDR_PRINT_OUT_DEBUG(NetGroupAddUser, &r);
1346         }
1347
1348         return r.out.result;
1349 }
1350
1351 /****************************************************************
1352  NetGroupDelUser
1353 ****************************************************************/
1354
1355 NET_API_STATUS NetGroupDelUser(const char * server_name /* [in] */,
1356                                const char * group_name /* [in] */,
1357                                const char * user_name /* [in] */)
1358 {
1359         struct NetGroupDelUser r;
1360         struct libnetapi_ctx *ctx = NULL;
1361         NET_API_STATUS status;
1362         WERROR werr;
1363
1364         status = libnetapi_getctx(&ctx);
1365         if (status != 0) {
1366                 return status;
1367         }
1368
1369         /* In parameters */
1370         r.in.server_name = server_name;
1371         r.in.group_name = group_name;
1372         r.in.user_name = user_name;
1373
1374         /* Out parameters */
1375
1376         if (DEBUGLEVEL >= 10) {
1377                 NDR_PRINT_IN_DEBUG(NetGroupDelUser, &r);
1378         }
1379
1380         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1381                 werr = NetGroupDelUser_l(ctx, &r);
1382         } else {
1383                 werr = NetGroupDelUser_r(ctx, &r);
1384         }
1385
1386         r.out.result = W_ERROR_V(werr);
1387
1388         if (DEBUGLEVEL >= 10) {
1389                 NDR_PRINT_OUT_DEBUG(NetGroupDelUser, &r);
1390         }
1391
1392         return r.out.result;
1393 }
1394
1395 /****************************************************************
1396  NetGroupGetUsers
1397 ****************************************************************/
1398
1399 NET_API_STATUS NetGroupGetUsers(const char * server_name /* [in] */,
1400                                 const char * group_name /* [in] */,
1401                                 uint32_t level /* [in] */,
1402                                 uint8_t **buffer /* [out] [ref] */,
1403                                 uint32_t prefmaxlen /* [in] */,
1404                                 uint32_t *entries_read /* [out] [ref] */,
1405                                 uint32_t *total_entries /* [out] [ref] */,
1406                                 uint32_t *resume_handle /* [in,out] [ref] */)
1407 {
1408         struct NetGroupGetUsers r;
1409         struct libnetapi_ctx *ctx = NULL;
1410         NET_API_STATUS status;
1411         WERROR werr;
1412
1413         status = libnetapi_getctx(&ctx);
1414         if (status != 0) {
1415                 return status;
1416         }
1417
1418         /* In parameters */
1419         r.in.server_name = server_name;
1420         r.in.group_name = group_name;
1421         r.in.level = level;
1422         r.in.prefmaxlen = prefmaxlen;
1423         r.in.resume_handle = resume_handle;
1424
1425         /* Out parameters */
1426         r.out.buffer = buffer;
1427         r.out.entries_read = entries_read;
1428         r.out.total_entries = total_entries;
1429         r.out.resume_handle = resume_handle;
1430
1431         if (DEBUGLEVEL >= 10) {
1432                 NDR_PRINT_IN_DEBUG(NetGroupGetUsers, &r);
1433         }
1434
1435         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1436                 werr = NetGroupGetUsers_l(ctx, &r);
1437         } else {
1438                 werr = NetGroupGetUsers_r(ctx, &r);
1439         }
1440
1441         r.out.result = W_ERROR_V(werr);
1442
1443         if (DEBUGLEVEL >= 10) {
1444                 NDR_PRINT_OUT_DEBUG(NetGroupGetUsers, &r);
1445         }
1446
1447         return r.out.result;
1448 }
1449
1450 /****************************************************************
1451  NetGroupSetUsers
1452 ****************************************************************/
1453
1454 NET_API_STATUS NetGroupSetUsers(const char * server_name /* [in] */,
1455                                 const char * group_name /* [in] */,
1456                                 uint32_t level /* [in] */,
1457                                 uint8_t *buffer /* [in] [ref] */,
1458                                 uint32_t num_entries /* [in] */)
1459 {
1460         struct NetGroupSetUsers r;
1461         struct libnetapi_ctx *ctx = NULL;
1462         NET_API_STATUS status;
1463         WERROR werr;
1464
1465         status = libnetapi_getctx(&ctx);
1466         if (status != 0) {
1467                 return status;
1468         }
1469
1470         /* In parameters */
1471         r.in.server_name = server_name;
1472         r.in.group_name = group_name;
1473         r.in.level = level;
1474         r.in.buffer = buffer;
1475         r.in.num_entries = num_entries;
1476
1477         /* Out parameters */
1478
1479         if (DEBUGLEVEL >= 10) {
1480                 NDR_PRINT_IN_DEBUG(NetGroupSetUsers, &r);
1481         }
1482
1483         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1484                 werr = NetGroupSetUsers_l(ctx, &r);
1485         } else {
1486                 werr = NetGroupSetUsers_r(ctx, &r);
1487         }
1488
1489         r.out.result = W_ERROR_V(werr);
1490
1491         if (DEBUGLEVEL >= 10) {
1492                 NDR_PRINT_OUT_DEBUG(NetGroupSetUsers, &r);
1493         }
1494
1495         return r.out.result;
1496 }
1497
1498 /****************************************************************
1499  NetLocalGroupAdd
1500 ****************************************************************/
1501
1502 NET_API_STATUS NetLocalGroupAdd(const char * server_name /* [in] */,
1503                                 uint32_t level /* [in] */,
1504                                 uint8_t *buffer /* [in] [ref] */,
1505                                 uint32_t *parm_err /* [out] [ref] */)
1506 {
1507         struct NetLocalGroupAdd r;
1508         struct libnetapi_ctx *ctx = NULL;
1509         NET_API_STATUS status;
1510         WERROR werr;
1511
1512         status = libnetapi_getctx(&ctx);
1513         if (status != 0) {
1514                 return status;
1515         }
1516
1517         /* In parameters */
1518         r.in.server_name = server_name;
1519         r.in.level = level;
1520         r.in.buffer = buffer;
1521
1522         /* Out parameters */
1523         r.out.parm_err = parm_err;
1524
1525         if (DEBUGLEVEL >= 10) {
1526                 NDR_PRINT_IN_DEBUG(NetLocalGroupAdd, &r);
1527         }
1528
1529         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1530                 werr = NetLocalGroupAdd_l(ctx, &r);
1531         } else {
1532                 werr = NetLocalGroupAdd_r(ctx, &r);
1533         }
1534
1535         r.out.result = W_ERROR_V(werr);
1536
1537         if (DEBUGLEVEL >= 10) {
1538                 NDR_PRINT_OUT_DEBUG(NetLocalGroupAdd, &r);
1539         }
1540
1541         return r.out.result;
1542 }
1543
1544 /****************************************************************
1545  NetLocalGroupDel
1546 ****************************************************************/
1547
1548 NET_API_STATUS NetLocalGroupDel(const char * server_name /* [in] */,
1549                                 const char * group_name /* [in] */)
1550 {
1551         struct NetLocalGroupDel r;
1552         struct libnetapi_ctx *ctx = NULL;
1553         NET_API_STATUS status;
1554         WERROR werr;
1555
1556         status = libnetapi_getctx(&ctx);
1557         if (status != 0) {
1558                 return status;
1559         }
1560
1561         /* In parameters */
1562         r.in.server_name = server_name;
1563         r.in.group_name = group_name;
1564
1565         /* Out parameters */
1566
1567         if (DEBUGLEVEL >= 10) {
1568                 NDR_PRINT_IN_DEBUG(NetLocalGroupDel, &r);
1569         }
1570
1571         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1572                 werr = NetLocalGroupDel_l(ctx, &r);
1573         } else {
1574                 werr = NetLocalGroupDel_r(ctx, &r);
1575         }
1576
1577         r.out.result = W_ERROR_V(werr);
1578
1579         if (DEBUGLEVEL >= 10) {
1580                 NDR_PRINT_OUT_DEBUG(NetLocalGroupDel, &r);
1581         }
1582
1583         return r.out.result;
1584 }
1585
1586 /****************************************************************
1587  NetLocalGroupGetInfo
1588 ****************************************************************/
1589
1590 NET_API_STATUS NetLocalGroupGetInfo(const char * server_name /* [in] */,
1591                                     const char * group_name /* [in] */,
1592                                     uint32_t level /* [in] */,
1593                                     uint8_t **buffer /* [out] [ref] */)
1594 {
1595         struct NetLocalGroupGetInfo r;
1596         struct libnetapi_ctx *ctx = NULL;
1597         NET_API_STATUS status;
1598         WERROR werr;
1599
1600         status = libnetapi_getctx(&ctx);
1601         if (status != 0) {
1602                 return status;
1603         }
1604
1605         /* In parameters */
1606         r.in.server_name = server_name;
1607         r.in.group_name = group_name;
1608         r.in.level = level;
1609
1610         /* Out parameters */
1611         r.out.buffer = buffer;
1612
1613         if (DEBUGLEVEL >= 10) {
1614                 NDR_PRINT_IN_DEBUG(NetLocalGroupGetInfo, &r);
1615         }
1616
1617         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1618                 werr = NetLocalGroupGetInfo_l(ctx, &r);
1619         } else {
1620                 werr = NetLocalGroupGetInfo_r(ctx, &r);
1621         }
1622
1623         r.out.result = W_ERROR_V(werr);
1624
1625         if (DEBUGLEVEL >= 10) {
1626                 NDR_PRINT_OUT_DEBUG(NetLocalGroupGetInfo, &r);
1627         }
1628
1629         return r.out.result;
1630 }
1631
1632 /****************************************************************
1633  NetLocalGroupSetInfo
1634 ****************************************************************/
1635
1636 NET_API_STATUS NetLocalGroupSetInfo(const char * server_name /* [in] */,
1637                                     const char * group_name /* [in] */,
1638                                     uint32_t level /* [in] */,
1639                                     uint8_t *buffer /* [in] [ref] */,
1640                                     uint32_t *parm_err /* [out] [ref] */)
1641 {
1642         struct NetLocalGroupSetInfo r;
1643         struct libnetapi_ctx *ctx = NULL;
1644         NET_API_STATUS status;
1645         WERROR werr;
1646
1647         status = libnetapi_getctx(&ctx);
1648         if (status != 0) {
1649                 return status;
1650         }
1651
1652         /* In parameters */
1653         r.in.server_name = server_name;
1654         r.in.group_name = group_name;
1655         r.in.level = level;
1656         r.in.buffer = buffer;
1657
1658         /* Out parameters */
1659         r.out.parm_err = parm_err;
1660
1661         if (DEBUGLEVEL >= 10) {
1662                 NDR_PRINT_IN_DEBUG(NetLocalGroupSetInfo, &r);
1663         }
1664
1665         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1666                 werr = NetLocalGroupSetInfo_l(ctx, &r);
1667         } else {
1668                 werr = NetLocalGroupSetInfo_r(ctx, &r);
1669         }
1670
1671         r.out.result = W_ERROR_V(werr);
1672
1673         if (DEBUGLEVEL >= 10) {
1674                 NDR_PRINT_OUT_DEBUG(NetLocalGroupSetInfo, &r);
1675         }
1676
1677         return r.out.result;
1678 }
1679
1680 /****************************************************************
1681  NetLocalGroupEnum
1682 ****************************************************************/
1683
1684 NET_API_STATUS NetLocalGroupEnum(const char * server_name /* [in] */,
1685                                  uint32_t level /* [in] */,
1686                                  uint8_t **buffer /* [out] [ref] */,
1687                                  uint32_t prefmaxlen /* [in] */,
1688                                  uint32_t *entries_read /* [out] [ref] */,
1689                                  uint32_t *total_entries /* [out] [ref] */,
1690                                  uint32_t *resume_handle /* [in,out] [ref] */)
1691 {
1692         struct NetLocalGroupEnum r;
1693         struct libnetapi_ctx *ctx = NULL;
1694         NET_API_STATUS status;
1695         WERROR werr;
1696
1697         status = libnetapi_getctx(&ctx);
1698         if (status != 0) {
1699                 return status;
1700         }
1701
1702         /* In parameters */
1703         r.in.server_name = server_name;
1704         r.in.level = level;
1705         r.in.prefmaxlen = prefmaxlen;
1706         r.in.resume_handle = resume_handle;
1707
1708         /* Out parameters */
1709         r.out.buffer = buffer;
1710         r.out.entries_read = entries_read;
1711         r.out.total_entries = total_entries;
1712         r.out.resume_handle = resume_handle;
1713
1714         if (DEBUGLEVEL >= 10) {
1715                 NDR_PRINT_IN_DEBUG(NetLocalGroupEnum, &r);
1716         }
1717
1718         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1719                 werr = NetLocalGroupEnum_l(ctx, &r);
1720         } else {
1721                 werr = NetLocalGroupEnum_r(ctx, &r);
1722         }
1723
1724         r.out.result = W_ERROR_V(werr);
1725
1726         if (DEBUGLEVEL >= 10) {
1727                 NDR_PRINT_OUT_DEBUG(NetLocalGroupEnum, &r);
1728         }
1729
1730         return r.out.result;
1731 }
1732
1733 /****************************************************************
1734  NetLocalGroupAddMembers
1735 ****************************************************************/
1736
1737 NET_API_STATUS NetLocalGroupAddMembers(const char * server_name /* [in] */,
1738                                        const char * group_name /* [in] */,
1739                                        uint32_t level /* [in] */,
1740                                        uint8_t *buffer /* [in] [ref] */,
1741                                        uint32_t total_entries /* [in] */)
1742 {
1743         struct NetLocalGroupAddMembers r;
1744         struct libnetapi_ctx *ctx = NULL;
1745         NET_API_STATUS status;
1746         WERROR werr;
1747
1748         status = libnetapi_getctx(&ctx);
1749         if (status != 0) {
1750                 return status;
1751         }
1752
1753         /* In parameters */
1754         r.in.server_name = server_name;
1755         r.in.group_name = group_name;
1756         r.in.level = level;
1757         r.in.buffer = buffer;
1758         r.in.total_entries = total_entries;
1759
1760         /* Out parameters */
1761
1762         if (DEBUGLEVEL >= 10) {
1763                 NDR_PRINT_IN_DEBUG(NetLocalGroupAddMembers, &r);
1764         }
1765
1766         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1767                 werr = NetLocalGroupAddMembers_l(ctx, &r);
1768         } else {
1769                 werr = NetLocalGroupAddMembers_r(ctx, &r);
1770         }
1771
1772         r.out.result = W_ERROR_V(werr);
1773
1774         if (DEBUGLEVEL >= 10) {
1775                 NDR_PRINT_OUT_DEBUG(NetLocalGroupAddMembers, &r);
1776         }
1777
1778         return r.out.result;
1779 }
1780
1781 /****************************************************************
1782  NetLocalGroupDelMembers
1783 ****************************************************************/
1784
1785 NET_API_STATUS NetLocalGroupDelMembers(const char * server_name /* [in] */,
1786                                        const char * group_name /* [in] */,
1787                                        uint32_t level /* [in] */,
1788                                        uint8_t *buffer /* [in] [ref] */,
1789                                        uint32_t total_entries /* [in] */)
1790 {
1791         struct NetLocalGroupDelMembers r;
1792         struct libnetapi_ctx *ctx = NULL;
1793         NET_API_STATUS status;
1794         WERROR werr;
1795
1796         status = libnetapi_getctx(&ctx);
1797         if (status != 0) {
1798                 return status;
1799         }
1800
1801         /* In parameters */
1802         r.in.server_name = server_name;
1803         r.in.group_name = group_name;
1804         r.in.level = level;
1805         r.in.buffer = buffer;
1806         r.in.total_entries = total_entries;
1807
1808         /* Out parameters */
1809
1810         if (DEBUGLEVEL >= 10) {
1811                 NDR_PRINT_IN_DEBUG(NetLocalGroupDelMembers, &r);
1812         }
1813
1814         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1815                 werr = NetLocalGroupDelMembers_l(ctx, &r);
1816         } else {
1817                 werr = NetLocalGroupDelMembers_r(ctx, &r);
1818         }
1819
1820         r.out.result = W_ERROR_V(werr);
1821
1822         if (DEBUGLEVEL >= 10) {
1823                 NDR_PRINT_OUT_DEBUG(NetLocalGroupDelMembers, &r);
1824         }
1825
1826         return r.out.result;
1827 }
1828
1829 /****************************************************************
1830  NetLocalGroupGetMembers
1831 ****************************************************************/
1832
1833 NET_API_STATUS NetLocalGroupGetMembers(const char * server_name /* [in] */,
1834                                        const char * local_group_name /* [in] */,
1835                                        uint32_t level /* [in] */,
1836                                        uint8_t **buffer /* [out] [ref] */,
1837                                        uint32_t prefmaxlen /* [in] */,
1838                                        uint32_t *entries_read /* [out] [ref] */,
1839                                        uint32_t *total_entries /* [out] [ref] */,
1840                                        uint32_t *resume_handle /* [in,out] [ref] */)
1841 {
1842         struct NetLocalGroupGetMembers r;
1843         struct libnetapi_ctx *ctx = NULL;
1844         NET_API_STATUS status;
1845         WERROR werr;
1846
1847         status = libnetapi_getctx(&ctx);
1848         if (status != 0) {
1849                 return status;
1850         }
1851
1852         /* In parameters */
1853         r.in.server_name = server_name;
1854         r.in.local_group_name = local_group_name;
1855         r.in.level = level;
1856         r.in.prefmaxlen = prefmaxlen;
1857         r.in.resume_handle = resume_handle;
1858
1859         /* Out parameters */
1860         r.out.buffer = buffer;
1861         r.out.entries_read = entries_read;
1862         r.out.total_entries = total_entries;
1863         r.out.resume_handle = resume_handle;
1864
1865         if (DEBUGLEVEL >= 10) {
1866                 NDR_PRINT_IN_DEBUG(NetLocalGroupGetMembers, &r);
1867         }
1868
1869         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1870                 werr = NetLocalGroupGetMembers_l(ctx, &r);
1871         } else {
1872                 werr = NetLocalGroupGetMembers_r(ctx, &r);
1873         }
1874
1875         r.out.result = W_ERROR_V(werr);
1876
1877         if (DEBUGLEVEL >= 10) {
1878                 NDR_PRINT_OUT_DEBUG(NetLocalGroupGetMembers, &r);
1879         }
1880
1881         return r.out.result;
1882 }
1883
1884 /****************************************************************
1885  NetLocalGroupSetMembers
1886 ****************************************************************/
1887
1888 NET_API_STATUS NetLocalGroupSetMembers(const char * server_name /* [in] */,
1889                                        const char * group_name /* [in] */,
1890                                        uint32_t level /* [in] */,
1891                                        uint8_t *buffer /* [in] [ref] */,
1892                                        uint32_t total_entries /* [in] */)
1893 {
1894         struct NetLocalGroupSetMembers r;
1895         struct libnetapi_ctx *ctx = NULL;
1896         NET_API_STATUS status;
1897         WERROR werr;
1898
1899         status = libnetapi_getctx(&ctx);
1900         if (status != 0) {
1901                 return status;
1902         }
1903
1904         /* In parameters */
1905         r.in.server_name = server_name;
1906         r.in.group_name = group_name;
1907         r.in.level = level;
1908         r.in.buffer = buffer;
1909         r.in.total_entries = total_entries;
1910
1911         /* Out parameters */
1912
1913         if (DEBUGLEVEL >= 10) {
1914                 NDR_PRINT_IN_DEBUG(NetLocalGroupSetMembers, &r);
1915         }
1916
1917         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1918                 werr = NetLocalGroupSetMembers_l(ctx, &r);
1919         } else {
1920                 werr = NetLocalGroupSetMembers_r(ctx, &r);
1921         }
1922
1923         r.out.result = W_ERROR_V(werr);
1924
1925         if (DEBUGLEVEL >= 10) {
1926                 NDR_PRINT_OUT_DEBUG(NetLocalGroupSetMembers, &r);
1927         }
1928
1929         return r.out.result;
1930 }
1931
1932 /****************************************************************
1933  NetRemoteTOD
1934 ****************************************************************/
1935
1936 NET_API_STATUS NetRemoteTOD(const char * server_name /* [in] */,
1937                             uint8_t **buffer /* [out] [ref] */)
1938 {
1939         struct NetRemoteTOD r;
1940         struct libnetapi_ctx *ctx = NULL;
1941         NET_API_STATUS status;
1942         WERROR werr;
1943
1944         status = libnetapi_getctx(&ctx);
1945         if (status != 0) {
1946                 return status;
1947         }
1948
1949         /* In parameters */
1950         r.in.server_name = server_name;
1951
1952         /* Out parameters */
1953         r.out.buffer = buffer;
1954
1955         if (DEBUGLEVEL >= 10) {
1956                 NDR_PRINT_IN_DEBUG(NetRemoteTOD, &r);
1957         }
1958
1959         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
1960                 werr = NetRemoteTOD_l(ctx, &r);
1961         } else {
1962                 werr = NetRemoteTOD_r(ctx, &r);
1963         }
1964
1965         r.out.result = W_ERROR_V(werr);
1966
1967         if (DEBUGLEVEL >= 10) {
1968                 NDR_PRINT_OUT_DEBUG(NetRemoteTOD, &r);
1969         }
1970
1971         return r.out.result;
1972 }
1973
1974 /****************************************************************
1975  NetShareAdd
1976 ****************************************************************/
1977
1978 NET_API_STATUS NetShareAdd(const char * server_name /* [in] */,
1979                            uint32_t level /* [in] */,
1980                            uint8_t *buffer /* [in] [ref] */,
1981                            uint32_t *parm_err /* [out] [ref] */)
1982 {
1983         struct NetShareAdd r;
1984         struct libnetapi_ctx *ctx = NULL;
1985         NET_API_STATUS status;
1986         WERROR werr;
1987
1988         status = libnetapi_getctx(&ctx);
1989         if (status != 0) {
1990                 return status;
1991         }
1992
1993         /* In parameters */
1994         r.in.server_name = server_name;
1995         r.in.level = level;
1996         r.in.buffer = buffer;
1997
1998         /* Out parameters */
1999         r.out.parm_err = parm_err;
2000
2001         if (DEBUGLEVEL >= 10) {
2002                 NDR_PRINT_IN_DEBUG(NetShareAdd, &r);
2003         }
2004
2005         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2006                 werr = NetShareAdd_l(ctx, &r);
2007         } else {
2008                 werr = NetShareAdd_r(ctx, &r);
2009         }
2010
2011         r.out.result = W_ERROR_V(werr);
2012
2013         if (DEBUGLEVEL >= 10) {
2014                 NDR_PRINT_OUT_DEBUG(NetShareAdd, &r);
2015         }
2016
2017         return r.out.result;
2018 }
2019
2020 /****************************************************************
2021  NetShareDel
2022 ****************************************************************/
2023
2024 NET_API_STATUS NetShareDel(const char * server_name /* [in] */,
2025                            const char * net_name /* [in] */,
2026                            uint32_t reserved /* [in] */)
2027 {
2028         struct NetShareDel r;
2029         struct libnetapi_ctx *ctx = NULL;
2030         NET_API_STATUS status;
2031         WERROR werr;
2032
2033         status = libnetapi_getctx(&ctx);
2034         if (status != 0) {
2035                 return status;
2036         }
2037
2038         /* In parameters */
2039         r.in.server_name = server_name;
2040         r.in.net_name = net_name;
2041         r.in.reserved = reserved;
2042
2043         /* Out parameters */
2044
2045         if (DEBUGLEVEL >= 10) {
2046                 NDR_PRINT_IN_DEBUG(NetShareDel, &r);
2047         }
2048
2049         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2050                 werr = NetShareDel_l(ctx, &r);
2051         } else {
2052                 werr = NetShareDel_r(ctx, &r);
2053         }
2054
2055         r.out.result = W_ERROR_V(werr);
2056
2057         if (DEBUGLEVEL >= 10) {
2058                 NDR_PRINT_OUT_DEBUG(NetShareDel, &r);
2059         }
2060
2061         return r.out.result;
2062 }
2063
2064 /****************************************************************
2065  NetShareEnum
2066 ****************************************************************/
2067
2068 NET_API_STATUS NetShareEnum(const char * server_name /* [in] */,
2069                             uint32_t level /* [in] */,
2070                             uint8_t **buffer /* [out] [ref] */,
2071                             uint32_t prefmaxlen /* [in] */,
2072                             uint32_t *entries_read /* [out] [ref] */,
2073                             uint32_t *total_entries /* [out] [ref] */,
2074                             uint32_t *resume_handle /* [in,out] [ref] */)
2075 {
2076         struct NetShareEnum r;
2077         struct libnetapi_ctx *ctx = NULL;
2078         NET_API_STATUS status;
2079         WERROR werr;
2080
2081         status = libnetapi_getctx(&ctx);
2082         if (status != 0) {
2083                 return status;
2084         }
2085
2086         /* In parameters */
2087         r.in.server_name = server_name;
2088         r.in.level = level;
2089         r.in.prefmaxlen = prefmaxlen;
2090         r.in.resume_handle = resume_handle;
2091
2092         /* Out parameters */
2093         r.out.buffer = buffer;
2094         r.out.entries_read = entries_read;
2095         r.out.total_entries = total_entries;
2096         r.out.resume_handle = resume_handle;
2097
2098         if (DEBUGLEVEL >= 10) {
2099                 NDR_PRINT_IN_DEBUG(NetShareEnum, &r);
2100         }
2101
2102         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2103                 werr = NetShareEnum_l(ctx, &r);
2104         } else {
2105                 werr = NetShareEnum_r(ctx, &r);
2106         }
2107
2108         r.out.result = W_ERROR_V(werr);
2109
2110         if (DEBUGLEVEL >= 10) {
2111                 NDR_PRINT_OUT_DEBUG(NetShareEnum, &r);
2112         }
2113
2114         return r.out.result;
2115 }
2116
2117 /****************************************************************
2118  NetShareGetInfo
2119 ****************************************************************/
2120
2121 NET_API_STATUS NetShareGetInfo(const char * server_name /* [in] */,
2122                                const char * net_name /* [in] */,
2123                                uint32_t level /* [in] */,
2124                                uint8_t **buffer /* [out] [ref] */)
2125 {
2126         struct NetShareGetInfo r;
2127         struct libnetapi_ctx *ctx = NULL;
2128         NET_API_STATUS status;
2129         WERROR werr;
2130
2131         status = libnetapi_getctx(&ctx);
2132         if (status != 0) {
2133                 return status;
2134         }
2135
2136         /* In parameters */
2137         r.in.server_name = server_name;
2138         r.in.net_name = net_name;
2139         r.in.level = level;
2140
2141         /* Out parameters */
2142         r.out.buffer = buffer;
2143
2144         if (DEBUGLEVEL >= 10) {
2145                 NDR_PRINT_IN_DEBUG(NetShareGetInfo, &r);
2146         }
2147
2148         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2149                 werr = NetShareGetInfo_l(ctx, &r);
2150         } else {
2151                 werr = NetShareGetInfo_r(ctx, &r);
2152         }
2153
2154         r.out.result = W_ERROR_V(werr);
2155
2156         if (DEBUGLEVEL >= 10) {
2157                 NDR_PRINT_OUT_DEBUG(NetShareGetInfo, &r);
2158         }
2159
2160         return r.out.result;
2161 }
2162
2163 /****************************************************************
2164  NetShareSetInfo
2165 ****************************************************************/
2166
2167 NET_API_STATUS NetShareSetInfo(const char * server_name /* [in] */,
2168                                const char * net_name /* [in] */,
2169                                uint32_t level /* [in] */,
2170                                uint8_t *buffer /* [in] [ref] */,
2171                                uint32_t *parm_err /* [out] [ref] */)
2172 {
2173         struct NetShareSetInfo r;
2174         struct libnetapi_ctx *ctx = NULL;
2175         NET_API_STATUS status;
2176         WERROR werr;
2177
2178         status = libnetapi_getctx(&ctx);
2179         if (status != 0) {
2180                 return status;
2181         }
2182
2183         /* In parameters */
2184         r.in.server_name = server_name;
2185         r.in.net_name = net_name;
2186         r.in.level = level;
2187         r.in.buffer = buffer;
2188
2189         /* Out parameters */
2190         r.out.parm_err = parm_err;
2191
2192         if (DEBUGLEVEL >= 10) {
2193                 NDR_PRINT_IN_DEBUG(NetShareSetInfo, &r);
2194         }
2195
2196         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2197                 werr = NetShareSetInfo_l(ctx, &r);
2198         } else {
2199                 werr = NetShareSetInfo_r(ctx, &r);
2200         }
2201
2202         r.out.result = W_ERROR_V(werr);
2203
2204         if (DEBUGLEVEL >= 10) {
2205                 NDR_PRINT_OUT_DEBUG(NetShareSetInfo, &r);
2206         }
2207
2208         return r.out.result;
2209 }
2210
2211 /****************************************************************
2212  NetFileClose
2213 ****************************************************************/
2214
2215 NET_API_STATUS NetFileClose(const char * server_name /* [in] */,
2216                             uint32_t fileid /* [in] */)
2217 {
2218         struct NetFileClose r;
2219         struct libnetapi_ctx *ctx = NULL;
2220         NET_API_STATUS status;
2221         WERROR werr;
2222
2223         status = libnetapi_getctx(&ctx);
2224         if (status != 0) {
2225                 return status;
2226         }
2227
2228         /* In parameters */
2229         r.in.server_name = server_name;
2230         r.in.fileid = fileid;
2231
2232         /* Out parameters */
2233
2234         if (DEBUGLEVEL >= 10) {
2235                 NDR_PRINT_IN_DEBUG(NetFileClose, &r);
2236         }
2237
2238         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2239                 werr = NetFileClose_l(ctx, &r);
2240         } else {
2241                 werr = NetFileClose_r(ctx, &r);
2242         }
2243
2244         r.out.result = W_ERROR_V(werr);
2245
2246         if (DEBUGLEVEL >= 10) {
2247                 NDR_PRINT_OUT_DEBUG(NetFileClose, &r);
2248         }
2249
2250         return r.out.result;
2251 }
2252
2253 /****************************************************************
2254  NetFileGetInfo
2255 ****************************************************************/
2256
2257 NET_API_STATUS NetFileGetInfo(const char * server_name /* [in] */,
2258                               uint32_t fileid /* [in] */,
2259                               uint32_t level /* [in] */,
2260                               uint8_t **buffer /* [out] [ref] */)
2261 {
2262         struct NetFileGetInfo r;
2263         struct libnetapi_ctx *ctx = NULL;
2264         NET_API_STATUS status;
2265         WERROR werr;
2266
2267         status = libnetapi_getctx(&ctx);
2268         if (status != 0) {
2269                 return status;
2270         }
2271
2272         /* In parameters */
2273         r.in.server_name = server_name;
2274         r.in.fileid = fileid;
2275         r.in.level = level;
2276
2277         /* Out parameters */
2278         r.out.buffer = buffer;
2279
2280         if (DEBUGLEVEL >= 10) {
2281                 NDR_PRINT_IN_DEBUG(NetFileGetInfo, &r);
2282         }
2283
2284         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2285                 werr = NetFileGetInfo_l(ctx, &r);
2286         } else {
2287                 werr = NetFileGetInfo_r(ctx, &r);
2288         }
2289
2290         r.out.result = W_ERROR_V(werr);
2291
2292         if (DEBUGLEVEL >= 10) {
2293                 NDR_PRINT_OUT_DEBUG(NetFileGetInfo, &r);
2294         }
2295
2296         return r.out.result;
2297 }
2298
2299 /****************************************************************
2300  NetFileEnum
2301 ****************************************************************/
2302
2303 NET_API_STATUS NetFileEnum(const char * server_name /* [in] */,
2304                            const char * base_path /* [in] */,
2305                            const char * user_name /* [in] */,
2306                            uint32_t level /* [in] */,
2307                            uint8_t **buffer /* [out] [ref] */,
2308                            uint32_t prefmaxlen /* [in] */,
2309                            uint32_t *entries_read /* [out] [ref] */,
2310                            uint32_t *total_entries /* [out] [ref] */,
2311                            uint32_t *resume_handle /* [in,out] [ref] */)
2312 {
2313         struct NetFileEnum r;
2314         struct libnetapi_ctx *ctx = NULL;
2315         NET_API_STATUS status;
2316         WERROR werr;
2317
2318         status = libnetapi_getctx(&ctx);
2319         if (status != 0) {
2320                 return status;
2321         }
2322
2323         /* In parameters */
2324         r.in.server_name = server_name;
2325         r.in.base_path = base_path;
2326         r.in.user_name = user_name;
2327         r.in.level = level;
2328         r.in.prefmaxlen = prefmaxlen;
2329         r.in.resume_handle = resume_handle;
2330
2331         /* Out parameters */
2332         r.out.buffer = buffer;
2333         r.out.entries_read = entries_read;
2334         r.out.total_entries = total_entries;
2335         r.out.resume_handle = resume_handle;
2336
2337         if (DEBUGLEVEL >= 10) {
2338                 NDR_PRINT_IN_DEBUG(NetFileEnum, &r);
2339         }
2340
2341         if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2342                 werr = NetFileEnum_l(ctx, &r);
2343         } else {
2344                 werr = NetFileEnum_r(ctx, &r);
2345         }
2346
2347         r.out.result = W_ERROR_V(werr);
2348
2349         if (DEBUGLEVEL >= 10) {
2350                 NDR_PRINT_OUT_DEBUG(NetFileEnum, &r);
2351         }
2352
2353         return r.out.result;
2354 }
2355