2 * Unix SMB/CIFS implementation.
4 * Copyright (C) Guenther Deschner 2007-2008
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.
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.
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/>.
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"
27 /****************************************************************
29 ****************************************************************/
31 NET_API_STATUS NetJoinDomain(const char * server /* [in] [unique] */,
32 const char * domain /* [in] [ref] */,
33 const char * account_ou /* [in] [unique] */,
34 const char * account /* [in] [unique] */,
35 const char * password /* [in] [unique] */,
36 uint32_t join_flags /* [in] */)
38 struct NetJoinDomain r;
39 struct libnetapi_ctx *ctx = NULL;
40 NET_API_STATUS status;
43 status = libnetapi_getctx(&ctx);
51 r.in.account_ou = account_ou;
52 r.in.account = account;
53 r.in.password = password;
54 r.in.join_flags = join_flags;
58 if (DEBUGLEVEL >= 10) {
59 NDR_PRINT_IN_DEBUG(NetJoinDomain, &r);
62 if (LIBNETAPI_LOCAL_SERVER(server)) {
63 werr = NetJoinDomain_l(ctx, &r);
65 werr = NetJoinDomain_r(ctx, &r);
68 r.out.result = W_ERROR_V(werr);
70 if (DEBUGLEVEL >= 10) {
71 NDR_PRINT_OUT_DEBUG(NetJoinDomain, &r);
77 /****************************************************************
79 ****************************************************************/
81 NET_API_STATUS NetUnjoinDomain(const char * server_name /* [in] [unique] */,
82 const char * account /* [in] [unique] */,
83 const char * password /* [in] [unique] */,
84 uint32_t unjoin_flags /* [in] */)
86 struct NetUnjoinDomain r;
87 struct libnetapi_ctx *ctx = NULL;
88 NET_API_STATUS status;
91 status = libnetapi_getctx(&ctx);
97 r.in.server_name = server_name;
98 r.in.account = account;
99 r.in.password = password;
100 r.in.unjoin_flags = unjoin_flags;
104 if (DEBUGLEVEL >= 10) {
105 NDR_PRINT_IN_DEBUG(NetUnjoinDomain, &r);
108 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
109 werr = NetUnjoinDomain_l(ctx, &r);
111 werr = NetUnjoinDomain_r(ctx, &r);
114 r.out.result = W_ERROR_V(werr);
116 if (DEBUGLEVEL >= 10) {
117 NDR_PRINT_OUT_DEBUG(NetUnjoinDomain, &r);
123 /****************************************************************
124 NetGetJoinInformation
125 ****************************************************************/
127 NET_API_STATUS NetGetJoinInformation(const char * server_name /* [in] [unique] */,
128 const char * *name_buffer /* [out] [ref] */,
129 uint16_t *name_type /* [out] [ref] */)
131 struct NetGetJoinInformation r;
132 struct libnetapi_ctx *ctx = NULL;
133 NET_API_STATUS status;
136 status = libnetapi_getctx(&ctx);
142 r.in.server_name = server_name;
145 r.out.name_buffer = name_buffer;
146 r.out.name_type = name_type;
148 if (DEBUGLEVEL >= 10) {
149 NDR_PRINT_IN_DEBUG(NetGetJoinInformation, &r);
152 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
153 werr = NetGetJoinInformation_l(ctx, &r);
155 werr = NetGetJoinInformation_r(ctx, &r);
158 r.out.result = W_ERROR_V(werr);
160 if (DEBUGLEVEL >= 10) {
161 NDR_PRINT_OUT_DEBUG(NetGetJoinInformation, &r);
167 /****************************************************************
169 ****************************************************************/
171 NET_API_STATUS NetGetJoinableOUs(const char * server_name /* [in] [unique] */,
172 const char * domain /* [in] [ref] */,
173 const char * account /* [in] [unique] */,
174 const char * password /* [in] [unique] */,
175 uint32_t *ou_count /* [out] [ref] */,
176 const char * **ous /* [out] [ref] */)
178 struct NetGetJoinableOUs r;
179 struct libnetapi_ctx *ctx = NULL;
180 NET_API_STATUS status;
183 status = libnetapi_getctx(&ctx);
189 r.in.server_name = server_name;
190 r.in.domain = domain;
191 r.in.account = account;
192 r.in.password = password;
195 r.out.ou_count = ou_count;
198 if (DEBUGLEVEL >= 10) {
199 NDR_PRINT_IN_DEBUG(NetGetJoinableOUs, &r);
202 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
203 werr = NetGetJoinableOUs_l(ctx, &r);
205 werr = NetGetJoinableOUs_r(ctx, &r);
208 r.out.result = W_ERROR_V(werr);
210 if (DEBUGLEVEL >= 10) {
211 NDR_PRINT_OUT_DEBUG(NetGetJoinableOUs, &r);
217 /****************************************************************
219 ****************************************************************/
221 NET_API_STATUS NetServerGetInfo(const char * server_name /* [in] [unique] */,
222 uint32_t level /* [in] */,
223 uint8_t **buffer /* [out] [ref] */)
225 struct NetServerGetInfo r;
226 struct libnetapi_ctx *ctx = NULL;
227 NET_API_STATUS status;
230 status = libnetapi_getctx(&ctx);
236 r.in.server_name = server_name;
240 r.out.buffer = buffer;
242 if (DEBUGLEVEL >= 10) {
243 NDR_PRINT_IN_DEBUG(NetServerGetInfo, &r);
246 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
247 werr = NetServerGetInfo_l(ctx, &r);
249 werr = NetServerGetInfo_r(ctx, &r);
252 r.out.result = W_ERROR_V(werr);
254 if (DEBUGLEVEL >= 10) {
255 NDR_PRINT_OUT_DEBUG(NetServerGetInfo, &r);
261 /****************************************************************
263 ****************************************************************/
265 NET_API_STATUS NetServerSetInfo(const char * server_name /* [in] [unique] */,
266 uint32_t level /* [in] */,
267 uint8_t *buffer /* [in] [ref] */,
268 uint32_t *parm_error /* [out] [ref] */)
270 struct NetServerSetInfo r;
271 struct libnetapi_ctx *ctx = NULL;
272 NET_API_STATUS status;
275 status = libnetapi_getctx(&ctx);
281 r.in.server_name = server_name;
283 r.in.buffer = buffer;
286 r.out.parm_error = parm_error;
288 if (DEBUGLEVEL >= 10) {
289 NDR_PRINT_IN_DEBUG(NetServerSetInfo, &r);
292 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
293 werr = NetServerSetInfo_l(ctx, &r);
295 werr = NetServerSetInfo_r(ctx, &r);
298 r.out.result = W_ERROR_V(werr);
300 if (DEBUGLEVEL >= 10) {
301 NDR_PRINT_OUT_DEBUG(NetServerSetInfo, &r);
307 /****************************************************************
309 ****************************************************************/
311 NET_API_STATUS NetGetDCName(const char * server_name /* [in] [unique] */,
312 const char * domain_name /* [in] [unique] */,
313 uint8_t **buffer /* [out] [ref] */)
315 struct NetGetDCName r;
316 struct libnetapi_ctx *ctx = NULL;
317 NET_API_STATUS status;
320 status = libnetapi_getctx(&ctx);
326 r.in.server_name = server_name;
327 r.in.domain_name = domain_name;
330 r.out.buffer = buffer;
332 if (DEBUGLEVEL >= 10) {
333 NDR_PRINT_IN_DEBUG(NetGetDCName, &r);
336 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
337 werr = NetGetDCName_l(ctx, &r);
339 werr = NetGetDCName_r(ctx, &r);
342 r.out.result = W_ERROR_V(werr);
344 if (DEBUGLEVEL >= 10) {
345 NDR_PRINT_OUT_DEBUG(NetGetDCName, &r);
351 /****************************************************************
353 ****************************************************************/
355 NET_API_STATUS NetGetAnyDCName(const char * server_name /* [in] [unique] */,
356 const char * domain_name /* [in] [unique] */,
357 uint8_t **buffer /* [out] [ref] */)
359 struct NetGetAnyDCName r;
360 struct libnetapi_ctx *ctx = NULL;
361 NET_API_STATUS status;
364 status = libnetapi_getctx(&ctx);
370 r.in.server_name = server_name;
371 r.in.domain_name = domain_name;
374 r.out.buffer = buffer;
376 if (DEBUGLEVEL >= 10) {
377 NDR_PRINT_IN_DEBUG(NetGetAnyDCName, &r);
380 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
381 werr = NetGetAnyDCName_l(ctx, &r);
383 werr = NetGetAnyDCName_r(ctx, &r);
386 r.out.result = W_ERROR_V(werr);
388 if (DEBUGLEVEL >= 10) {
389 NDR_PRINT_OUT_DEBUG(NetGetAnyDCName, &r);
395 /****************************************************************
397 ****************************************************************/
399 NET_API_STATUS DsGetDcName(const char * server_name /* [in] [unique] */,
400 const char * domain_name /* [in] [ref] */,
401 struct GUID *domain_guid /* [in] [unique] */,
402 const char * site_name /* [in] [unique] */,
403 uint32_t flags /* [in] */,
404 struct DOMAIN_CONTROLLER_INFO **dc_info /* [out] [ref] */)
406 struct DsGetDcName r;
407 struct libnetapi_ctx *ctx = NULL;
408 NET_API_STATUS status;
411 status = libnetapi_getctx(&ctx);
417 r.in.server_name = server_name;
418 r.in.domain_name = domain_name;
419 r.in.domain_guid = domain_guid;
420 r.in.site_name = site_name;
424 r.out.dc_info = dc_info;
426 if (DEBUGLEVEL >= 10) {
427 NDR_PRINT_IN_DEBUG(DsGetDcName, &r);
430 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
431 werr = DsGetDcName_l(ctx, &r);
433 werr = DsGetDcName_r(ctx, &r);
436 r.out.result = W_ERROR_V(werr);
438 if (DEBUGLEVEL >= 10) {
439 NDR_PRINT_OUT_DEBUG(DsGetDcName, &r);
445 /****************************************************************
447 ****************************************************************/
449 NET_API_STATUS NetUserAdd(const char * server_name /* [in] [unique] */,
450 uint32_t level /* [in] */,
451 uint8_t *buffer /* [in] [ref] */,
452 uint32_t *parm_error /* [out] [ref] */)
455 struct libnetapi_ctx *ctx = NULL;
456 NET_API_STATUS status;
459 status = libnetapi_getctx(&ctx);
465 r.in.server_name = server_name;
467 r.in.buffer = buffer;
470 r.out.parm_error = parm_error;
472 if (DEBUGLEVEL >= 10) {
473 NDR_PRINT_IN_DEBUG(NetUserAdd, &r);
476 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
477 werr = NetUserAdd_l(ctx, &r);
479 werr = NetUserAdd_r(ctx, &r);
482 r.out.result = W_ERROR_V(werr);
484 if (DEBUGLEVEL >= 10) {
485 NDR_PRINT_OUT_DEBUG(NetUserAdd, &r);
491 /****************************************************************
493 ****************************************************************/
495 NET_API_STATUS NetUserDel(const char * server_name /* [in] [unique] */,
496 const char * user_name /* [in] [ref] */)
499 struct libnetapi_ctx *ctx = NULL;
500 NET_API_STATUS status;
503 status = libnetapi_getctx(&ctx);
509 r.in.server_name = server_name;
510 r.in.user_name = user_name;
514 if (DEBUGLEVEL >= 10) {
515 NDR_PRINT_IN_DEBUG(NetUserDel, &r);
518 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
519 werr = NetUserDel_l(ctx, &r);
521 werr = NetUserDel_r(ctx, &r);
524 r.out.result = W_ERROR_V(werr);
526 if (DEBUGLEVEL >= 10) {
527 NDR_PRINT_OUT_DEBUG(NetUserDel, &r);
533 /****************************************************************
535 ****************************************************************/
537 NET_API_STATUS NetUserEnum(const char * server_name /* [in] [unique] */,
538 uint32_t level /* [in] */,
539 uint32_t filter /* [in] */,
540 uint8_t **buffer /* [out] [ref] */,
541 uint32_t prefmaxlen /* [in] */,
542 uint32_t *entries_read /* [out] [ref] */,
543 uint32_t *total_entries /* [out] [ref] */,
544 uint32_t *resume_handle /* [in,out] [ref] */)
546 struct NetUserEnum r;
547 struct libnetapi_ctx *ctx = NULL;
548 NET_API_STATUS status;
551 status = libnetapi_getctx(&ctx);
557 r.in.server_name = server_name;
559 r.in.filter = filter;
560 r.in.prefmaxlen = prefmaxlen;
561 r.in.resume_handle = resume_handle;
564 r.out.buffer = buffer;
565 r.out.entries_read = entries_read;
566 r.out.total_entries = total_entries;
567 r.out.resume_handle = resume_handle;
569 if (DEBUGLEVEL >= 10) {
570 NDR_PRINT_IN_DEBUG(NetUserEnum, &r);
573 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
574 werr = NetUserEnum_l(ctx, &r);
576 werr = NetUserEnum_r(ctx, &r);
579 r.out.result = W_ERROR_V(werr);
581 if (DEBUGLEVEL >= 10) {
582 NDR_PRINT_OUT_DEBUG(NetUserEnum, &r);
588 /****************************************************************
589 NetQueryDisplayInformation
590 ****************************************************************/
592 NET_API_STATUS NetQueryDisplayInformation(const char * server_name /* [in] [unique] */,
593 uint32_t level /* [in] */,
594 uint32_t idx /* [in] */,
595 uint32_t entries_requested /* [in] */,
596 uint32_t prefmaxlen /* [in] */,
597 uint32_t *entries_read /* [out] [ref] */,
598 void **buffer /* [out] [noprint,ref] */)
600 struct NetQueryDisplayInformation r;
601 struct libnetapi_ctx *ctx = NULL;
602 NET_API_STATUS status;
605 status = libnetapi_getctx(&ctx);
611 r.in.server_name = server_name;
614 r.in.entries_requested = entries_requested;
615 r.in.prefmaxlen = prefmaxlen;
618 r.out.entries_read = entries_read;
619 r.out.buffer = buffer;
621 if (DEBUGLEVEL >= 10) {
622 NDR_PRINT_IN_DEBUG(NetQueryDisplayInformation, &r);
625 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
626 werr = NetQueryDisplayInformation_l(ctx, &r);
628 werr = NetQueryDisplayInformation_r(ctx, &r);
631 r.out.result = W_ERROR_V(werr);
633 if (DEBUGLEVEL >= 10) {
634 NDR_PRINT_OUT_DEBUG(NetQueryDisplayInformation, &r);
640 /****************************************************************
642 ****************************************************************/
644 NET_API_STATUS NetGroupAdd(const char * server_name /* [in] */,
645 uint32_t level /* [in] */,
646 uint8_t *buf /* [in] [ref] */,
647 uint32_t *parm_err /* [out] [ref] */)
649 struct NetGroupAdd r;
650 struct libnetapi_ctx *ctx = NULL;
651 NET_API_STATUS status;
654 status = libnetapi_getctx(&ctx);
660 r.in.server_name = server_name;
665 r.out.parm_err = parm_err;
667 if (DEBUGLEVEL >= 10) {
668 NDR_PRINT_IN_DEBUG(NetGroupAdd, &r);
671 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
672 werr = NetGroupAdd_l(ctx, &r);
674 werr = NetGroupAdd_r(ctx, &r);
677 r.out.result = W_ERROR_V(werr);
679 if (DEBUGLEVEL >= 10) {
680 NDR_PRINT_OUT_DEBUG(NetGroupAdd, &r);
686 /****************************************************************
688 ****************************************************************/
690 NET_API_STATUS NetGroupDel(const char * server_name /* [in] */,
691 const char * group_name /* [in] */)
693 struct NetGroupDel r;
694 struct libnetapi_ctx *ctx = NULL;
695 NET_API_STATUS status;
698 status = libnetapi_getctx(&ctx);
704 r.in.server_name = server_name;
705 r.in.group_name = group_name;
709 if (DEBUGLEVEL >= 10) {
710 NDR_PRINT_IN_DEBUG(NetGroupDel, &r);
713 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
714 werr = NetGroupDel_l(ctx, &r);
716 werr = NetGroupDel_r(ctx, &r);
719 r.out.result = W_ERROR_V(werr);
721 if (DEBUGLEVEL >= 10) {
722 NDR_PRINT_OUT_DEBUG(NetGroupDel, &r);
728 /****************************************************************
730 ****************************************************************/
732 NET_API_STATUS NetGroupSetInfo(const char * server_name /* [in] */,
733 const char * group_name /* [in] */,
734 uint32_t level /* [in] */,
735 uint8_t *buf /* [in] [ref] */,
736 uint32_t *parm_err /* [out] [ref] */)
738 struct NetGroupSetInfo r;
739 struct libnetapi_ctx *ctx = NULL;
740 NET_API_STATUS status;
743 status = libnetapi_getctx(&ctx);
749 r.in.server_name = server_name;
750 r.in.group_name = group_name;
755 r.out.parm_err = parm_err;
757 if (DEBUGLEVEL >= 10) {
758 NDR_PRINT_IN_DEBUG(NetGroupSetInfo, &r);
761 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
762 werr = NetGroupSetInfo_l(ctx, &r);
764 werr = NetGroupSetInfo_r(ctx, &r);
767 r.out.result = W_ERROR_V(werr);
769 if (DEBUGLEVEL >= 10) {
770 NDR_PRINT_OUT_DEBUG(NetGroupSetInfo, &r);
776 /****************************************************************
778 ****************************************************************/
780 NET_API_STATUS NetGroupGetInfo(const char * server_name /* [in] */,
781 const char * group_name /* [in] */,
782 uint32_t level /* [in] */,
783 uint8_t **buf /* [out] [ref] */)
785 struct NetGroupGetInfo r;
786 struct libnetapi_ctx *ctx = NULL;
787 NET_API_STATUS status;
790 status = libnetapi_getctx(&ctx);
796 r.in.server_name = server_name;
797 r.in.group_name = group_name;
803 if (DEBUGLEVEL >= 10) {
804 NDR_PRINT_IN_DEBUG(NetGroupGetInfo, &r);
807 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
808 werr = NetGroupGetInfo_l(ctx, &r);
810 werr = NetGroupGetInfo_r(ctx, &r);
813 r.out.result = W_ERROR_V(werr);
815 if (DEBUGLEVEL >= 10) {
816 NDR_PRINT_OUT_DEBUG(NetGroupGetInfo, &r);
822 /****************************************************************
824 ****************************************************************/
826 NET_API_STATUS NetGroupAddUser(const char * server_name /* [in] */,
827 const char * group_name /* [in] */,
828 const char * user_name /* [in] */)
830 struct NetGroupAddUser r;
831 struct libnetapi_ctx *ctx = NULL;
832 NET_API_STATUS status;
835 status = libnetapi_getctx(&ctx);
841 r.in.server_name = server_name;
842 r.in.group_name = group_name;
843 r.in.user_name = user_name;
847 if (DEBUGLEVEL >= 10) {
848 NDR_PRINT_IN_DEBUG(NetGroupAddUser, &r);
851 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
852 werr = NetGroupAddUser_l(ctx, &r);
854 werr = NetGroupAddUser_r(ctx, &r);
857 r.out.result = W_ERROR_V(werr);
859 if (DEBUGLEVEL >= 10) {
860 NDR_PRINT_OUT_DEBUG(NetGroupAddUser, &r);
866 /****************************************************************
868 ****************************************************************/
870 NET_API_STATUS NetGroupDelUser(const char * server_name /* [in] */,
871 const char * group_name /* [in] */,
872 const char * user_name /* [in] */)
874 struct NetGroupDelUser r;
875 struct libnetapi_ctx *ctx = NULL;
876 NET_API_STATUS status;
879 status = libnetapi_getctx(&ctx);
885 r.in.server_name = server_name;
886 r.in.group_name = group_name;
887 r.in.user_name = user_name;
891 if (DEBUGLEVEL >= 10) {
892 NDR_PRINT_IN_DEBUG(NetGroupDelUser, &r);
895 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
896 werr = NetGroupDelUser_l(ctx, &r);
898 werr = NetGroupDelUser_r(ctx, &r);
901 r.out.result = W_ERROR_V(werr);
903 if (DEBUGLEVEL >= 10) {
904 NDR_PRINT_OUT_DEBUG(NetGroupDelUser, &r);
910 /****************************************************************
912 ****************************************************************/
914 NET_API_STATUS NetLocalGroupAdd(const char * server_name /* [in] */,
915 uint32_t level /* [in] */,
916 uint8_t *buf /* [in] [ref] */,
917 uint32_t *parm_err /* [out] [ref] */)
919 struct NetLocalGroupAdd r;
920 struct libnetapi_ctx *ctx = NULL;
921 NET_API_STATUS status;
924 status = libnetapi_getctx(&ctx);
930 r.in.server_name = server_name;
935 r.out.parm_err = parm_err;
937 if (DEBUGLEVEL >= 10) {
938 NDR_PRINT_IN_DEBUG(NetLocalGroupAdd, &r);
941 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
942 werr = NetLocalGroupAdd_l(ctx, &r);
944 werr = NetLocalGroupAdd_r(ctx, &r);
947 r.out.result = W_ERROR_V(werr);
949 if (DEBUGLEVEL >= 10) {
950 NDR_PRINT_OUT_DEBUG(NetLocalGroupAdd, &r);
956 /****************************************************************
958 ****************************************************************/
960 NET_API_STATUS NetLocalGroupDel(const char * server_name /* [in] */,
961 const char * group_name /* [in] */)
963 struct NetLocalGroupDel r;
964 struct libnetapi_ctx *ctx = NULL;
965 NET_API_STATUS status;
968 status = libnetapi_getctx(&ctx);
974 r.in.server_name = server_name;
975 r.in.group_name = group_name;
979 if (DEBUGLEVEL >= 10) {
980 NDR_PRINT_IN_DEBUG(NetLocalGroupDel, &r);
983 if (LIBNETAPI_LOCAL_SERVER(server_name)) {
984 werr = NetLocalGroupDel_l(ctx, &r);
986 werr = NetLocalGroupDel_r(ctx, &r);
989 r.out.result = W_ERROR_V(werr);
991 if (DEBUGLEVEL >= 10) {
992 NDR_PRINT_OUT_DEBUG(NetLocalGroupDel, &r);