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

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

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