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

Last change on this file was 740, checked in by Silvan Scherrer, 13 years ago

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