source: vendor/3.5.0/source3/lib/netapi/libnetapi.c

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago

Samba 3.5.0: Initial import
File size: 56.8 KB
Line 
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
31NET_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
81NET_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
127NET_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
171NET_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
221NET_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
269NET_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
313NET_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
359NET_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
403NET_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
447NET_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
497NET_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
543NET_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
585NET_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
640NET_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
686NET_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
732NET_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
780NET_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
832NET_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
880NET_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
934NET_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
978NET_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
1024NET_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
1076NET_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
1122NET_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
1164NET_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
1217NET_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
1265NET_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
1311NET_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
1355NET_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
1399NET_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
1454NET_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
1502NET_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
1548NET_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
1590NET_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
1636NET_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
1684NET_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
1737NET_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
1785NET_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
1833NET_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
1888NET_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
1936NET_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
1978NET_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
2024NET_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
2068NET_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
2121NET_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
2167NET_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
2215NET_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
2257NET_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
2303NET_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
2356/****************************************************************
2357 NetShutdownInit
2358****************************************************************/
2359
2360NET_API_STATUS NetShutdownInit(const char * server_name /* [in] */,
2361 const char * message /* [in] */,
2362 uint32_t timeout /* [in] */,
2363 uint8_t force_apps /* [in] */,
2364 uint8_t do_reboot /* [in] */)
2365{
2366 struct NetShutdownInit r;
2367 struct libnetapi_ctx *ctx = NULL;
2368 NET_API_STATUS status;
2369 WERROR werr;
2370
2371 status = libnetapi_getctx(&ctx);
2372 if (status != 0) {
2373 return status;
2374 }
2375
2376 /* In parameters */
2377 r.in.server_name = server_name;
2378 r.in.message = message;
2379 r.in.timeout = timeout;
2380 r.in.force_apps = force_apps;
2381 r.in.do_reboot = do_reboot;
2382
2383 /* Out parameters */
2384
2385 if (DEBUGLEVEL >= 10) {
2386 NDR_PRINT_IN_DEBUG(NetShutdownInit, &r);
2387 }
2388
2389 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2390 werr = NetShutdownInit_l(ctx, &r);
2391 } else {
2392 werr = NetShutdownInit_r(ctx, &r);
2393 }
2394
2395 r.out.result = W_ERROR_V(werr);
2396
2397 if (DEBUGLEVEL >= 10) {
2398 NDR_PRINT_OUT_DEBUG(NetShutdownInit, &r);
2399 }
2400
2401 return r.out.result;
2402}
2403
2404/****************************************************************
2405 NetShutdownAbort
2406****************************************************************/
2407
2408NET_API_STATUS NetShutdownAbort(const char * server_name /* [in] */)
2409{
2410 struct NetShutdownAbort r;
2411 struct libnetapi_ctx *ctx = NULL;
2412 NET_API_STATUS status;
2413 WERROR werr;
2414
2415 status = libnetapi_getctx(&ctx);
2416 if (status != 0) {
2417 return status;
2418 }
2419
2420 /* In parameters */
2421 r.in.server_name = server_name;
2422
2423 /* Out parameters */
2424
2425 if (DEBUGLEVEL >= 10) {
2426 NDR_PRINT_IN_DEBUG(NetShutdownAbort, &r);
2427 }
2428
2429 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2430 werr = NetShutdownAbort_l(ctx, &r);
2431 } else {
2432 werr = NetShutdownAbort_r(ctx, &r);
2433 }
2434
2435 r.out.result = W_ERROR_V(werr);
2436
2437 if (DEBUGLEVEL >= 10) {
2438 NDR_PRINT_OUT_DEBUG(NetShutdownAbort, &r);
2439 }
2440
2441 return r.out.result;
2442}
2443
2444/****************************************************************
2445 I_NetLogonControl
2446****************************************************************/
2447
2448NET_API_STATUS I_NetLogonControl(const char * server_name /* [in] */,
2449 uint32_t function_code /* [in] */,
2450 uint32_t query_level /* [in] */,
2451 uint8_t **buffer /* [out] [ref] */)
2452{
2453 struct I_NetLogonControl r;
2454 struct libnetapi_ctx *ctx = NULL;
2455 NET_API_STATUS status;
2456 WERROR werr;
2457
2458 status = libnetapi_getctx(&ctx);
2459 if (status != 0) {
2460 return status;
2461 }
2462
2463 /* In parameters */
2464 r.in.server_name = server_name;
2465 r.in.function_code = function_code;
2466 r.in.query_level = query_level;
2467
2468 /* Out parameters */
2469 r.out.buffer = buffer;
2470
2471 if (DEBUGLEVEL >= 10) {
2472 NDR_PRINT_IN_DEBUG(I_NetLogonControl, &r);
2473 }
2474
2475 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2476 werr = I_NetLogonControl_l(ctx, &r);
2477 } else {
2478 werr = I_NetLogonControl_r(ctx, &r);
2479 }
2480
2481 r.out.result = W_ERROR_V(werr);
2482
2483 if (DEBUGLEVEL >= 10) {
2484 NDR_PRINT_OUT_DEBUG(I_NetLogonControl, &r);
2485 }
2486
2487 return r.out.result;
2488}
2489
2490/****************************************************************
2491 I_NetLogonControl2
2492****************************************************************/
2493
2494NET_API_STATUS I_NetLogonControl2(const char * server_name /* [in] */,
2495 uint32_t function_code /* [in] */,
2496 uint32_t query_level /* [in] */,
2497 uint8_t *data /* [in] [ref] */,
2498 uint8_t **buffer /* [out] [ref] */)
2499{
2500 struct I_NetLogonControl2 r;
2501 struct libnetapi_ctx *ctx = NULL;
2502 NET_API_STATUS status;
2503 WERROR werr;
2504
2505 status = libnetapi_getctx(&ctx);
2506 if (status != 0) {
2507 return status;
2508 }
2509
2510 /* In parameters */
2511 r.in.server_name = server_name;
2512 r.in.function_code = function_code;
2513 r.in.query_level = query_level;
2514 r.in.data = data;
2515
2516 /* Out parameters */
2517 r.out.buffer = buffer;
2518
2519 if (DEBUGLEVEL >= 10) {
2520 NDR_PRINT_IN_DEBUG(I_NetLogonControl2, &r);
2521 }
2522
2523 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
2524 werr = I_NetLogonControl2_l(ctx, &r);
2525 } else {
2526 werr = I_NetLogonControl2_r(ctx, &r);
2527 }
2528
2529 r.out.result = W_ERROR_V(werr);
2530
2531 if (DEBUGLEVEL >= 10) {
2532 NDR_PRINT_OUT_DEBUG(I_NetLogonControl2, &r);
2533 }
2534
2535 return r.out.result;
2536}
2537
Note: See TracBrowser for help on using the repository browser.