2 * Unix SMB/CIFS implementation.
4 * Copyright (C) Guenther Deschner 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/>.
22 #include "librpc/gen_ndr/libnetapi.h"
23 #include "lib/netapi/netapi.h"
24 #include "lib/netapi/netapi_private.h"
25 #include "lib/netapi/libnetapi.h"
27 /****************************************************************
28 ****************************************************************/
30 static void convert_USER_INFO_1_to_samr_user_info25(struct USER_INFO_1 *info1,
31 DATA_BLOB *user_session_key,
32 struct samr_UserInfo25 *info25)
34 uint32_t fields_present = SAMR_FIELD_ACCT_FLAGS;
35 struct samr_LogonHours zero_logon_hours;
36 struct lsa_BinaryString zero_parameters;
37 uint32_t acct_flags = 0;
41 ZERO_STRUCT(zero_logon_hours);
42 ZERO_STRUCT(zero_parameters);
44 if (info1->usri1_name) {
45 fields_present |= SAMR_FIELD_FULL_NAME;
47 if (info1->usri1_password) {
48 fields_present |= SAMR_FIELD_PASSWORD;
50 if (info1->usri1_flags) {
51 fields_present |= SAMR_FIELD_ACCT_FLAGS;
53 if (info1->usri1_name) {
54 fields_present |= SAMR_FIELD_FULL_NAME;
56 if (info1->usri1_home_dir) {
57 fields_present |= SAMR_FIELD_HOME_DIRECTORY;
59 if (info1->usri1_script_path) {
60 fields_present |= SAMR_FIELD_LOGON_SCRIPT;
62 if (info1->usri1_comment) {
63 fields_present |= SAMR_FIELD_DESCRIPTION;
65 if (info1->usri1_password_age) {
66 fields_present |= SAMR_FIELD_FORCE_PWD_CHANGE;
69 acct_flags |= info1->usri1_flags | ACB_NORMAL;
71 unix_to_nt_time_abs(&password_age, info1->usri1_password_age);
73 /* TODO: info1->usri1_priv */
74 init_samr_user_info21(&info25->info,
83 info1->usri1_home_dir,
85 info1->usri1_script_path,
104 if (info1->usri1_password) {
106 struct MD5Context ctx;
107 uint8_t confounder[16];
108 DATA_BLOB confounded_session_key = data_blob(NULL, 16);
110 encode_pw_buffer(pwbuf, info1->usri1_password, STR_UNICODE);
112 generate_random_buffer((uint8_t *)confounder, 16);
115 MD5Update(&ctx, confounder, 16);
116 MD5Update(&ctx, user_session_key->data,
117 user_session_key->length);
118 MD5Final(confounded_session_key.data, &ctx);
120 SamOEMhashBlob(pwbuf, 516, &confounded_session_key);
121 memcpy(&pwbuf[516], confounder, 16);
123 memcpy(info25->password.data, pwbuf, sizeof(pwbuf));
124 data_blob_free(&confounded_session_key);
128 /****************************************************************
129 ****************************************************************/
131 WERROR NetUserAdd_r(struct libnetapi_ctx *ctx,
132 struct NetUserAdd *r)
134 struct cli_state *cli = NULL;
135 struct rpc_pipe_client *pipe_cli = NULL;
138 POLICY_HND connect_handle, domain_handle, user_handle;
139 struct lsa_String lsa_account_name;
140 struct dom_sid2 *domain_sid = NULL;
141 struct samr_UserInfo25 info25;
142 union samr_UserInfo *user_info = NULL;
143 struct samr_PwInfo pw_info;
144 uint32_t access_granted = 0;
146 struct USER_INFO_1 *info1;
148 ZERO_STRUCT(connect_handle);
149 ZERO_STRUCT(domain_handle);
150 ZERO_STRUCT(user_handle);
153 return WERR_INVALID_PARAM;
156 switch (r->in.level) {
158 info1 = (struct USER_INFO_1 *)r->in.buffer;
164 werr = WERR_NOT_SUPPORTED;
168 werr = libnetapi_open_ipc_connection(ctx, r->in.server_name, &cli);
169 if (!W_ERROR_IS_OK(werr)) {
173 werr = libnetapi_open_pipe(ctx, cli, PI_SAMR, &pipe_cli);
174 if (!W_ERROR_IS_OK(werr)) {
178 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
179 SAMR_ACCESS_ENUM_DOMAINS |
180 SAMR_ACCESS_OPEN_DOMAIN,
181 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
182 SAMR_DOMAIN_ACCESS_CREATE_USER |
183 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
187 if (!W_ERROR_IS_OK(werr)) {
191 init_lsa_String(&lsa_account_name, info1->usri1_name);
193 status = rpccli_samr_CreateUser2(pipe_cli, ctx,
199 SAMR_USER_ACCESS_SET_PASSWORD |
200 SAMR_USER_ACCESS_SET_ATTRIBUTES |
201 SAMR_USER_ACCESS_GET_ATTRIBUTES,
205 if (!NT_STATUS_IS_OK(status)) {
206 werr = ntstatus_to_werror(status);
210 status = rpccli_samr_QueryUserInfo(pipe_cli, ctx,
214 if (!NT_STATUS_IS_OK(status)) {
215 werr = ntstatus_to_werror(status);
219 if (!(user_info->info16.acct_flags & ACB_NORMAL)) {
220 werr = WERR_INVALID_PARAM;
224 status = rpccli_samr_GetUserPwInfo(pipe_cli, ctx,
227 if (!NT_STATUS_IS_OK(status)) {
228 werr = ntstatus_to_werror(status);
232 ZERO_STRUCTP(user_info);
234 convert_USER_INFO_1_to_samr_user_info25(info1,
235 &cli->user_session_key,
238 if (info1->usri1_password) {
239 user_info->info25 = info25;
240 status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
245 if (NT_STATUS_EQUAL(status, NT_STATUS(DCERPC_FAULT_INVALID_TAG))) {
247 user_info->info23.info = info25.info;
249 encode_pw_buffer(user_info->info23.password.data,
250 info1->usri1_password, STR_UNICODE);
251 SamOEMhashBlob(user_info->info23.password.data, 516,
252 &cli->user_session_key);
254 status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
260 user_info->info21 = info25.info;
261 status = rpccli_samr_SetUserInfo(pipe_cli, ctx,
267 if (!NT_STATUS_IS_OK(status)) {
268 werr = ntstatus_to_werror(status);
276 rpccli_samr_DeleteUser(pipe_cli, ctx,
284 if (is_valid_policy_hnd(&user_handle)) {
285 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
287 if (is_valid_policy_hnd(&domain_handle)) {
288 rpccli_samr_Close(pipe_cli, ctx, &domain_handle);
290 if (is_valid_policy_hnd(&connect_handle)) {
291 rpccli_samr_Close(pipe_cli, ctx, &connect_handle);
297 /****************************************************************
298 ****************************************************************/
300 WERROR NetUserAdd_l(struct libnetapi_ctx *ctx,
301 struct NetUserAdd *r)
303 /* for now just talk to local RPC server */
304 if (!r->in.server_name) {
305 r->in.server_name = "localhost";
308 return NetUserAdd_r(ctx, r);
311 /****************************************************************
312 ****************************************************************/
314 WERROR NetUserDel_r(struct libnetapi_ctx *ctx,
315 struct NetUserDel *r)
317 struct cli_state *cli = NULL;
318 struct rpc_pipe_client *pipe_cli = NULL;
321 POLICY_HND connect_handle, builtin_handle, domain_handle, user_handle;
322 struct lsa_String lsa_account_name;
323 struct samr_Ids user_rids, name_types;
324 struct dom_sid2 *domain_sid = NULL;
325 struct dom_sid2 user_sid;
327 ZERO_STRUCT(connect_handle);
328 ZERO_STRUCT(builtin_handle);
329 ZERO_STRUCT(domain_handle);
330 ZERO_STRUCT(user_handle);
332 werr = libnetapi_open_ipc_connection(ctx, r->in.server_name, &cli);
333 if (!W_ERROR_IS_OK(werr)) {
337 werr = libnetapi_open_pipe(ctx, cli, PI_SAMR, &pipe_cli);
338 if (!W_ERROR_IS_OK(werr)) {
342 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
343 SAMR_ACCESS_ENUM_DOMAINS |
344 SAMR_ACCESS_OPEN_DOMAIN,
345 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
349 if (!W_ERROR_IS_OK(werr)) {
353 status = rpccli_samr_OpenDomain(pipe_cli, ctx,
355 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
356 CONST_DISCARD(DOM_SID *, &global_sid_Builtin),
358 if (!NT_STATUS_IS_OK(status)) {
359 werr = ntstatus_to_werror(status);
363 init_lsa_String(&lsa_account_name, r->in.user_name);
365 status = rpccli_samr_LookupNames(pipe_cli, ctx,
371 if (!NT_STATUS_IS_OK(status)) {
372 werr = ntstatus_to_werror(status);
376 status = rpccli_samr_OpenUser(pipe_cli, ctx,
378 STD_RIGHT_DELETE_ACCESS,
381 if (!NT_STATUS_IS_OK(status)) {
382 werr = ntstatus_to_werror(status);
386 sid_compose(&user_sid, domain_sid, user_rids.ids[0]);
388 status = rpccli_samr_RemoveMemberFromForeignDomain(pipe_cli, ctx,
391 if (!NT_STATUS_IS_OK(status)) {
392 werr = ntstatus_to_werror(status);
396 status = rpccli_samr_DeleteUser(pipe_cli, ctx,
398 if (!NT_STATUS_IS_OK(status)) {
399 werr = ntstatus_to_werror(status);
410 if (is_valid_policy_hnd(&user_handle)) {
411 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
413 if (is_valid_policy_hnd(&builtin_handle)) {
414 rpccli_samr_Close(pipe_cli, ctx, &builtin_handle);
416 if (is_valid_policy_hnd(&domain_handle)) {
417 rpccli_samr_Close(pipe_cli, ctx, &domain_handle);
419 if (is_valid_policy_hnd(&connect_handle)) {
420 rpccli_samr_Close(pipe_cli, ctx, &connect_handle);
426 /****************************************************************
427 ****************************************************************/
429 WERROR NetUserDel_l(struct libnetapi_ctx *ctx,
430 struct NetUserDel *r)
432 /* for now just talk to local RPC server */
433 if (!r->in.server_name) {
434 r->in.server_name = "localhost";
437 return NetUserDel_r(ctx, r);
440 /****************************************************************
441 ****************************************************************/
443 static NTSTATUS libnetapi_samr_lookup_user(TALLOC_CTX *mem_ctx,
444 struct rpc_pipe_client *pipe_cli,
445 struct policy_handle *domain_handle,
446 struct policy_handle *builtin_handle,
447 const char *user_name,
450 struct samr_UserInfo21 **info21,
451 struct sec_desc_buf **sec_desc)
455 struct policy_handle user_handle;
456 union samr_UserInfo *user_info = NULL;
457 struct samr_RidWithAttributeArray *rid_array = NULL;
458 uint32_t access_mask = SEC_STD_READ_CONTROL |
459 SAMR_USER_ACCESS_GET_ATTRIBUTES |
460 SAMR_USER_ACCESS_GET_NAME_ETC;
462 ZERO_STRUCT(user_handle);
475 return NT_STATUS_INVALID_LEVEL;
482 status = rpccli_samr_OpenUser(pipe_cli, mem_ctx,
487 if (!NT_STATUS_IS_OK(status)) {
491 status = rpccli_samr_QueryUserInfo(pipe_cli, mem_ctx,
495 if (!NT_STATUS_IS_OK(status)) {
499 status = rpccli_samr_QuerySecurity(pipe_cli, mem_ctx,
503 if (!NT_STATUS_IS_OK(status)) {
508 status = rpccli_samr_GetGroupsForUser(pipe_cli, mem_ctx,
511 if (!NT_STATUS_IS_OK(status)) {
516 status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
520 if (!NT_STATUS_IS_OK(status)) {
526 *info21 = &user_info->info21;
529 if (is_valid_policy_hnd(&user_handle)) {
530 rpccli_samr_Close(pipe_cli, mem_ctx, &user_handle);
536 /****************************************************************
537 ****************************************************************/
539 static NTSTATUS libnetapi_samr_lookup_user_map_USER_INFO(TALLOC_CTX *mem_ctx,
540 struct rpc_pipe_client *pipe_cli,
541 struct dom_sid *domain_sid,
542 struct policy_handle *domain_handle,
543 struct policy_handle *builtin_handle,
544 const char *user_name,
548 uint32_t *num_entries)
552 struct samr_UserInfo21 *info21 = NULL;
553 struct sec_desc_buf *sec_desc = NULL;
556 struct USER_INFO_0 *info0 = NULL;
557 struct USER_INFO_10 *info10 = NULL;
558 struct USER_INFO_20 *info20 = NULL;
559 struct USER_INFO_23 *info23 = NULL;
572 return NT_STATUS_INVALID_LEVEL;
576 info0 = TALLOC_P(mem_ctx, struct USER_INFO_0);
577 NT_STATUS_HAVE_NO_MEMORY(info0);
579 info0->usri0_name = talloc_strdup(mem_ctx, user_name);
580 NT_STATUS_HAVE_NO_MEMORY(info0->usri0_name);
582 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_0, *info0,
583 (struct USER_INFO_0 **)buffer, num_entries);
588 status = libnetapi_samr_lookup_user(mem_ctx, pipe_cli,
597 if (!NT_STATUS_IS_OK(status)) {
603 info10 = TALLOC_P(mem_ctx, struct USER_INFO_10);
604 NT_STATUS_HAVE_NO_MEMORY(info10);
606 info10->usri10_name = talloc_strdup(mem_ctx, user_name);
607 NT_STATUS_HAVE_NO_MEMORY(info10->usri10_name);
609 info10->usri10_comment = talloc_strdup(mem_ctx,
610 info21->description.string);
612 info10->usri10_full_name = talloc_strdup(mem_ctx,
613 info21->full_name.string);
615 info10->usri10_usr_comment = talloc_strdup(mem_ctx,
616 info21->comment.string);
618 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_10, *info10,
619 (struct USER_INFO_10 **)buffer, num_entries);
624 info20 = TALLOC_P(mem_ctx, struct USER_INFO_20);
625 NT_STATUS_HAVE_NO_MEMORY(info20);
627 info20->usri20_name = talloc_strdup(mem_ctx, user_name);
628 NT_STATUS_HAVE_NO_MEMORY(info20->usri20_name);
630 info20->usri20_comment = talloc_strdup(mem_ctx,
631 info21->description.string);
633 info20->usri20_flags = info21->acct_flags;
634 info20->usri20_user_id = rid;
636 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_20, *info20,
637 (struct USER_INFO_20 **)buffer, num_entries);
641 info23 = TALLOC_P(mem_ctx, struct USER_INFO_23);
642 NT_STATUS_HAVE_NO_MEMORY(info23);
644 info23->usri23_name = talloc_strdup(mem_ctx, user_name);
645 NT_STATUS_HAVE_NO_MEMORY(info23->usri23_name);
647 info23->usri23_comment = talloc_strdup(mem_ctx,
648 info21->description.string);
650 info23->usri23_flags = info21->acct_flags;
652 if (!sid_compose(&sid, domain_sid, rid)) {
653 return NT_STATUS_NO_MEMORY;
656 info23->usri23_user_sid =
657 (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
659 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_23, *info23,
660 (struct USER_INFO_23 **)buffer, num_entries);
668 /****************************************************************
669 ****************************************************************/
671 WERROR NetUserEnum_r(struct libnetapi_ctx *ctx,
672 struct NetUserEnum *r)
674 struct cli_state *cli = NULL;
675 struct rpc_pipe_client *pipe_cli = NULL;
676 struct policy_handle connect_handle;
677 struct dom_sid2 *domain_sid = NULL;
678 struct policy_handle domain_handle;
679 struct samr_SamArray *sam = NULL;
680 uint32_t filter = ACB_NORMAL;
682 uint32_t entries_read = 0;
684 NTSTATUS status = NT_STATUS_OK;
687 ZERO_STRUCT(connect_handle);
688 ZERO_STRUCT(domain_handle);
690 if (!r->out.buffer) {
691 return WERR_INVALID_PARAM;
694 *r->out.buffer = NULL;
695 *r->out.entries_read = 0;
697 switch (r->in.level) {
708 return WERR_NOT_SUPPORTED;
711 werr = libnetapi_open_ipc_connection(ctx, r->in.server_name, &cli);
712 if (!W_ERROR_IS_OK(werr)) {
716 werr = libnetapi_open_pipe(ctx, cli, PI_SAMR, &pipe_cli);
717 if (!W_ERROR_IS_OK(werr)) {
721 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
722 SAMR_ACCESS_ENUM_DOMAINS |
723 SAMR_ACCESS_OPEN_DOMAIN,
724 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
725 SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
726 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
730 if (!W_ERROR_IS_OK(werr)) {
734 switch (r->in.filter) {
735 case FILTER_NORMAL_ACCOUNT:
738 case FILTER_TEMP_DUPLICATE_ACCOUNT:
739 filter = ACB_TEMPDUP;
741 case FILTER_INTERDOMAIN_TRUST_ACCOUNT:
742 filter = ACB_DOMTRUST;
744 case FILTER_WORKSTATION_TRUST_ACCOUNT:
745 filter = ACB_WSTRUST;
747 case FILTER_SERVER_TRUST_ACCOUNT:
748 filter = ACB_SVRTRUST;
754 status = rpccli_samr_EnumDomainUsers(pipe_cli,
762 werr = ntstatus_to_werror(status);
763 if (NT_STATUS_IS_ERR(status)) {
767 for (i=0; i < sam->count; i++) {
769 status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
772 NULL, /*&builtin_handle, */
773 sam->entries[i].name.string,
777 r->out.entries_read);
778 if (!NT_STATUS_IS_OK(status)) {
779 werr = ntstatus_to_werror(status);
789 if (is_valid_policy_hnd(&domain_handle)) {
790 rpccli_samr_Close(pipe_cli, ctx, &domain_handle);
792 if (is_valid_policy_hnd(&connect_handle)) {
793 rpccli_samr_Close(pipe_cli, ctx, &connect_handle);
799 /****************************************************************
800 ****************************************************************/
802 WERROR NetUserEnum_l(struct libnetapi_ctx *ctx,
803 struct NetUserEnum *r)
805 return WERR_NOT_SUPPORTED;
808 /****************************************************************
809 ****************************************************************/
811 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_USER(TALLOC_CTX *mem_ctx,
812 struct samr_DispInfoGeneral *info,
813 uint32_t *entries_read,
816 struct NET_DISPLAY_USER *user = NULL;
819 user = TALLOC_ZERO_ARRAY(mem_ctx,
820 struct NET_DISPLAY_USER,
822 W_ERROR_HAVE_NO_MEMORY(user);
824 for (i = 0; i < info->count; i++) {
825 user[i].usri1_name = talloc_strdup(mem_ctx,
826 info->entries[i].account_name.string);
827 user[i].usri1_comment = talloc_strdup(mem_ctx,
828 info->entries[i].description.string);
829 user[i].usri1_flags =
830 info->entries[i].acct_flags;
831 user[i].usri1_full_name = talloc_strdup(mem_ctx,
832 info->entries[i].full_name.string);
833 user[i].usri1_user_id =
834 info->entries[i].rid;
835 user[i].usri1_next_index =
836 info->entries[i].idx;
838 if (!user[i].usri1_name) {
843 *buffer = talloc_memdup(mem_ctx, user,
844 sizeof(struct NET_DISPLAY_USER) * info->count);
845 W_ERROR_HAVE_NO_MEMORY(*buffer);
847 *entries_read = info->count;
852 /****************************************************************
853 ****************************************************************/
855 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(TALLOC_CTX *mem_ctx,
856 struct samr_DispInfoFull *info,
857 uint32_t *entries_read,
860 struct NET_DISPLAY_MACHINE *machine = NULL;
863 machine = TALLOC_ZERO_ARRAY(mem_ctx,
864 struct NET_DISPLAY_MACHINE,
866 W_ERROR_HAVE_NO_MEMORY(machine);
868 for (i = 0; i < info->count; i++) {
869 machine[i].usri2_name = talloc_strdup(mem_ctx,
870 info->entries[i].account_name.string);
871 machine[i].usri2_comment = talloc_strdup(mem_ctx,
872 info->entries[i].description.string);
873 machine[i].usri2_flags =
874 info->entries[i].acct_flags;
875 machine[i].usri2_user_id =
876 info->entries[i].rid;
877 machine[i].usri2_next_index =
878 info->entries[i].idx;
880 if (!machine[i].usri2_name) {
885 *buffer = talloc_memdup(mem_ctx, machine,
886 sizeof(struct NET_DISPLAY_MACHINE) * info->count);
887 W_ERROR_HAVE_NO_MEMORY(*buffer);
889 *entries_read = info->count;
894 /****************************************************************
895 ****************************************************************/
897 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_GROUP(TALLOC_CTX *mem_ctx,
898 struct samr_DispInfoFullGroups *info,
899 uint32_t *entries_read,
902 struct NET_DISPLAY_GROUP *group = NULL;
905 group = TALLOC_ZERO_ARRAY(mem_ctx,
906 struct NET_DISPLAY_GROUP,
908 W_ERROR_HAVE_NO_MEMORY(group);
910 for (i = 0; i < info->count; i++) {
911 group[i].grpi3_name = talloc_strdup(mem_ctx,
912 info->entries[i].account_name.string);
913 group[i].grpi3_comment = talloc_strdup(mem_ctx,
914 info->entries[i].description.string);
915 group[i].grpi3_group_id =
916 info->entries[i].rid;
917 group[i].grpi3_attributes =
918 info->entries[i].acct_flags;
919 group[i].grpi3_next_index =
920 info->entries[i].idx;
922 if (!group[i].grpi3_name) {
927 *buffer = talloc_memdup(mem_ctx, group,
928 sizeof(struct NET_DISPLAY_GROUP) * info->count);
929 W_ERROR_HAVE_NO_MEMORY(*buffer);
931 *entries_read = info->count;
937 /****************************************************************
938 ****************************************************************/
940 static WERROR convert_samr_dispinfo_to_NET_DISPLAY(TALLOC_CTX *mem_ctx,
941 union samr_DispInfo *info,
943 uint32_t *entries_read,
948 return convert_samr_dispinfo_to_NET_DISPLAY_USER(mem_ctx,
953 return convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(mem_ctx,
958 return convert_samr_dispinfo_to_NET_DISPLAY_GROUP(mem_ctx,
963 return WERR_UNKNOWN_LEVEL;
969 /****************************************************************
970 ****************************************************************/
972 WERROR NetQueryDisplayInformation_r(struct libnetapi_ctx *ctx,
973 struct NetQueryDisplayInformation *r)
975 struct cli_state *cli = NULL;
976 struct rpc_pipe_client *pipe_cli = NULL;
977 struct policy_handle connect_handle;
978 struct dom_sid2 *domain_sid = NULL;
979 struct policy_handle domain_handle;
980 union samr_DispInfo info;
982 uint32_t total_size = 0;
983 uint32_t returned_size = 0;
988 ZERO_STRUCT(connect_handle);
989 ZERO_STRUCT(domain_handle);
991 switch (r->in.level) {
997 return WERR_UNKNOWN_LEVEL;
1000 werr = libnetapi_open_ipc_connection(ctx, r->in.server_name, &cli);
1001 if (!W_ERROR_IS_OK(werr)) {
1005 werr = libnetapi_open_pipe(ctx, cli, PI_SAMR, &pipe_cli);
1006 if (!W_ERROR_IS_OK(werr)) {
1010 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1011 SAMR_ACCESS_ENUM_DOMAINS |
1012 SAMR_ACCESS_OPEN_DOMAIN,
1013 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
1014 SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
1015 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1019 if (!W_ERROR_IS_OK(werr)) {
1023 status = rpccli_samr_QueryDisplayInfo2(pipe_cli,
1028 r->in.entries_requested,
1033 if (!NT_STATUS_IS_OK(status)) {
1034 werr = ntstatus_to_werror(status);
1038 werr = convert_samr_dispinfo_to_NET_DISPLAY(ctx, &info,
1040 r->out.entries_read,
1047 if (is_valid_policy_hnd(&domain_handle)) {
1048 rpccli_samr_Close(pipe_cli, ctx, &domain_handle);
1050 if (is_valid_policy_hnd(&connect_handle)) {
1051 rpccli_samr_Close(pipe_cli, ctx, &connect_handle);
1058 /****************************************************************
1059 ****************************************************************/
1062 WERROR NetQueryDisplayInformation_l(struct libnetapi_ctx *ctx,
1063 struct NetQueryDisplayInformation *r)
1065 return WERR_NOT_SUPPORTED;
1068 /****************************************************************
1069 ****************************************************************/
1071 WERROR NetUserChangePassword_r(struct libnetapi_ctx *ctx,
1072 struct NetUserChangePassword *r)
1074 return WERR_NOT_SUPPORTED;
1077 /****************************************************************
1078 ****************************************************************/
1080 WERROR NetUserChangePassword_l(struct libnetapi_ctx *ctx,
1081 struct NetUserChangePassword *r)
1083 return WERR_NOT_SUPPORTED;
1086 /****************************************************************
1087 ****************************************************************/
1089 WERROR NetUserGetInfo_r(struct libnetapi_ctx *ctx,
1090 struct NetUserGetInfo *r)
1092 struct cli_state *cli = NULL;
1093 struct rpc_pipe_client *pipe_cli = NULL;
1097 struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1098 struct lsa_String lsa_account_name;
1099 struct dom_sid2 *domain_sid = NULL;
1100 struct samr_Ids user_rids, name_types;
1101 uint32_t num_entries = 0;
1103 ZERO_STRUCT(connect_handle);
1104 ZERO_STRUCT(domain_handle);
1105 ZERO_STRUCT(builtin_handle);
1106 ZERO_STRUCT(user_handle);
1108 if (!r->out.buffer) {
1109 return WERR_INVALID_PARAM;
1112 switch (r->in.level) {
1120 werr = WERR_NOT_SUPPORTED;
1124 werr = libnetapi_open_ipc_connection(ctx, r->in.server_name, &cli);
1125 if (!W_ERROR_IS_OK(werr)) {
1129 werr = libnetapi_open_pipe(ctx, cli, PI_SAMR, &pipe_cli);
1130 if (!W_ERROR_IS_OK(werr)) {
1134 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1135 SAMR_ACCESS_ENUM_DOMAINS |
1136 SAMR_ACCESS_OPEN_DOMAIN,
1137 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1141 if (!W_ERROR_IS_OK(werr)) {
1145 werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1146 SAMR_ACCESS_ENUM_DOMAINS |
1147 SAMR_ACCESS_OPEN_DOMAIN,
1148 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1149 SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1152 if (!W_ERROR_IS_OK(werr)) {
1156 init_lsa_String(&lsa_account_name, r->in.user_name);
1158 status = rpccli_samr_LookupNames(pipe_cli, ctx,
1164 if (!NT_STATUS_IS_OK(status)) {
1165 werr = ntstatus_to_werror(status);
1169 status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
1178 if (!NT_STATUS_IS_OK(status)) {
1179 werr = ntstatus_to_werror(status);
1188 if (is_valid_policy_hnd(&user_handle)) {
1189 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1192 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1193 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1198 /****************************************************************
1199 ****************************************************************/
1201 WERROR NetUserGetInfo_l(struct libnetapi_ctx *ctx,
1202 struct NetUserGetInfo *r)
1204 return WERR_NOT_SUPPORTED;