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_X_to_samr_user_info21(struct USER_INFO_X *infoX,
31 struct samr_UserInfo21 *info21)
33 uint32_t fields_present = 0;
34 struct samr_LogonHours zero_logon_hours;
35 struct lsa_BinaryString zero_parameters;
39 ZERO_STRUCT(zero_logon_hours);
40 ZERO_STRUCT(zero_parameters);
42 if (infoX->usriX_flags) {
43 fields_present |= SAMR_FIELD_ACCT_FLAGS;
45 if (infoX->usriX_name) {
46 fields_present |= SAMR_FIELD_ACCOUNT_NAME;
48 if (infoX->usriX_password) {
49 fields_present |= SAMR_FIELD_NT_PASSWORD_PRESENT;
51 if (infoX->usriX_flags) {
52 fields_present |= SAMR_FIELD_ACCT_FLAGS;
54 if (infoX->usriX_name) {
55 fields_present |= SAMR_FIELD_FULL_NAME;
57 if (infoX->usriX_home_dir) {
58 fields_present |= SAMR_FIELD_HOME_DIRECTORY;
60 if (infoX->usriX_script_path) {
61 fields_present |= SAMR_FIELD_LOGON_SCRIPT;
63 if (infoX->usriX_comment) {
64 fields_present |= SAMR_FIELD_DESCRIPTION;
66 if (infoX->usriX_password_age) {
67 fields_present |= SAMR_FIELD_FORCE_PWD_CHANGE;
69 if (infoX->usriX_full_name) {
70 fields_present |= SAMR_FIELD_FULL_NAME;
72 if (infoX->usriX_usr_comment) {
73 fields_present |= SAMR_FIELD_COMMENT;
75 if (infoX->usriX_profile) {
76 fields_present |= SAMR_FIELD_PROFILE_PATH;
78 if (infoX->usriX_home_dir_drive) {
79 fields_present |= SAMR_FIELD_HOME_DRIVE;
81 if (infoX->usriX_primary_group_id) {
82 fields_present |= SAMR_FIELD_PRIMARY_GID;
84 if (infoX->usriX_country_code) {
85 fields_present |= SAMR_FIELD_COUNTRY_CODE;
87 if (infoX->usriX_workstations) {
88 fields_present |= SAMR_FIELD_WORKSTATIONS;
91 unix_to_nt_time_abs(&password_age, infoX->usriX_password_age);
93 /* TODO: infoX->usriX_priv */
94 init_samr_user_info21(info21,
102 infoX->usriX_full_name,
103 infoX->usriX_home_dir,
104 infoX->usriX_home_dir_drive,
105 infoX->usriX_script_path,
106 infoX->usriX_profile,
107 infoX->usriX_comment,
108 infoX->usriX_workstations,
109 infoX->usriX_usr_comment,
111 infoX->usriX_user_id,
112 infoX->usriX_primary_group_id,
116 infoX->usriX_bad_pw_count,
117 infoX->usriX_num_logons,
118 infoX->usriX_country_code,
119 infoX->usriX_code_page,
122 infoX->usriX_password_expired);
125 /****************************************************************
126 ****************************************************************/
128 static NTSTATUS construct_USER_INFO_X(uint32_t level,
130 struct USER_INFO_X *uX)
132 struct USER_INFO_0 *u0 = NULL;
133 struct USER_INFO_1 *u1 = NULL;
134 struct USER_INFO_2 *u2 = NULL;
135 struct USER_INFO_3 *u3 = NULL;
136 struct USER_INFO_1003 *u1003 = NULL;
137 struct USER_INFO_1006 *u1006 = NULL;
138 struct USER_INFO_1007 *u1007 = NULL;
139 struct USER_INFO_1009 *u1009 = NULL;
140 struct USER_INFO_1011 *u1011 = NULL;
141 struct USER_INFO_1012 *u1012 = NULL;
142 struct USER_INFO_1014 *u1014 = NULL;
143 struct USER_INFO_1024 *u1024 = NULL;
144 struct USER_INFO_1051 *u1051 = NULL;
145 struct USER_INFO_1052 *u1052 = NULL;
146 struct USER_INFO_1053 *u1053 = NULL;
148 if (!buffer || !uX) {
149 return NT_STATUS_INVALID_PARAMETER;
156 u0 = (struct USER_INFO_0 *)buffer;
157 uX->usriX_name = u0->usri0_name;
160 u1 = (struct USER_INFO_1 *)buffer;
161 uX->usriX_name = u1->usri1_name;
162 uX->usriX_password = u1->usri1_password;
163 uX->usriX_password_age = u1->usri1_password_age;
164 uX->usriX_priv = u1->usri1_priv;
165 uX->usriX_home_dir = u1->usri1_home_dir;
166 uX->usriX_comment = u1->usri1_comment;
167 uX->usriX_flags = u1->usri1_flags;
168 uX->usriX_script_path = u1->usri1_script_path;
171 u2 = (struct USER_INFO_2 *)buffer;
172 uX->usriX_name = u2->usri2_name;
173 uX->usriX_password = u2->usri2_password;
174 uX->usriX_password_age = u2->usri2_password_age;
175 uX->usriX_priv = u2->usri2_priv;
176 uX->usriX_home_dir = u2->usri2_home_dir;
177 uX->usriX_comment = u2->usri2_comment;
178 uX->usriX_flags = u2->usri2_flags;
179 uX->usriX_script_path = u2->usri2_script_path;
180 uX->usriX_auth_flags = u2->usri2_auth_flags;
181 uX->usriX_full_name = u2->usri2_full_name;
182 uX->usriX_usr_comment = u2->usri2_usr_comment;
183 uX->usriX_parms = u2->usri2_parms;
184 uX->usriX_workstations = u2->usri2_workstations;
185 uX->usriX_last_logon = u2->usri2_last_logon;
186 uX->usriX_last_logoff = u2->usri2_last_logoff;
187 uX->usriX_acct_expires = u2->usri2_acct_expires;
188 uX->usriX_max_storage = u2->usri2_max_storage;
189 uX->usriX_units_per_week= u2->usri2_units_per_week;
190 uX->usriX_logon_hours = u2->usri2_logon_hours;
191 uX->usriX_bad_pw_count = u2->usri2_bad_pw_count;
192 uX->usriX_num_logons = u2->usri2_num_logons;
193 uX->usriX_logon_server = u2->usri2_logon_server;
194 uX->usriX_country_code = u2->usri2_country_code;
195 uX->usriX_code_page = u2->usri2_code_page;
198 u3 = (struct USER_INFO_3 *)buffer;
199 uX->usriX_name = u3->usri3_name;
200 uX->usriX_password_age = u3->usri3_password_age;
201 uX->usriX_priv = u3->usri3_priv;
202 uX->usriX_home_dir = u3->usri3_home_dir;
203 uX->usriX_comment = u3->usri3_comment;
204 uX->usriX_flags = u3->usri3_flags;
205 uX->usriX_script_path = u3->usri3_script_path;
206 uX->usriX_auth_flags = u3->usri3_auth_flags;
207 uX->usriX_full_name = u3->usri3_full_name;
208 uX->usriX_usr_comment = u3->usri3_usr_comment;
209 uX->usriX_parms = u3->usri3_parms;
210 uX->usriX_workstations = u3->usri3_workstations;
211 uX->usriX_last_logon = u3->usri3_last_logon;
212 uX->usriX_last_logoff = u3->usri3_last_logoff;
213 uX->usriX_acct_expires = u3->usri3_acct_expires;
214 uX->usriX_max_storage = u3->usri3_max_storage;
215 uX->usriX_units_per_week= u3->usri3_units_per_week;
216 uX->usriX_logon_hours = u3->usri3_logon_hours;
217 uX->usriX_bad_pw_count = u3->usri3_bad_pw_count;
218 uX->usriX_num_logons = u3->usri3_num_logons;
219 uX->usriX_logon_server = u3->usri3_logon_server;
220 uX->usriX_country_code = u3->usri3_country_code;
221 uX->usriX_code_page = u3->usri3_code_page;
222 uX->usriX_user_id = u3->usri3_user_id;
223 uX->usriX_primary_group_id = u3->usri3_primary_group_id;
224 uX->usriX_profile = u3->usri3_profile;
225 uX->usriX_home_dir_drive = u3->usri3_home_dir_drive;
226 uX->usriX_password_expired = u3->usri3_password_expired;
229 u1003 = (struct USER_INFO_1003 *)buffer;
230 uX->usriX_password = u1003->usri1003_password;
233 u1006 = (struct USER_INFO_1006 *)buffer;
234 uX->usriX_home_dir = u1006->usri1006_home_dir;
237 u1007 = (struct USER_INFO_1007 *)buffer;
238 uX->usriX_comment = u1007->usri1007_comment;
241 u1009 = (struct USER_INFO_1009 *)buffer;
242 uX->usriX_script_path = u1009->usri1009_script_path;
245 u1011 = (struct USER_INFO_1011 *)buffer;
246 uX->usriX_full_name = u1011->usri1011_full_name;
249 u1012 = (struct USER_INFO_1012 *)buffer;
250 uX->usriX_usr_comment = u1012->usri1012_usr_comment;
253 u1014 = (struct USER_INFO_1014 *)buffer;
254 uX->usriX_workstations = u1014->usri1014_workstations;
257 u1024 = (struct USER_INFO_1024 *)buffer;
258 uX->usriX_country_code = u1024->usri1024_country_code;
261 u1051 = (struct USER_INFO_1051 *)buffer;
262 uX->usriX_primary_group_id = u1051->usri1051_primary_group_id;
265 u1052 = (struct USER_INFO_1052 *)buffer;
266 uX->usriX_profile = u1052->usri1052_profile;
269 u1053 = (struct USER_INFO_1053 *)buffer;
270 uX->usriX_home_dir_drive = u1053->usri1053_home_dir_drive;
274 return NT_STATUS_INVALID_INFO_CLASS;
280 /****************************************************************
281 ****************************************************************/
283 static NTSTATUS set_user_info_USER_INFO_X(TALLOC_CTX *ctx,
284 struct rpc_pipe_client *pipe_cli,
285 DATA_BLOB *session_key,
286 struct policy_handle *user_handle,
287 struct USER_INFO_X *uX)
289 union samr_UserInfo user_info;
290 struct samr_UserInfo21 info21;
294 return NT_STATUS_INVALID_PARAMETER;
297 convert_USER_INFO_X_to_samr_user_info21(uX, &info21);
299 ZERO_STRUCT(user_info);
301 if (uX->usriX_password) {
303 user_info.info25.info = info21;
305 init_samr_CryptPasswordEx(uX->usriX_password,
307 &user_info.info25.password);
309 status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
314 if (NT_STATUS_EQUAL(status, NT_STATUS(DCERPC_FAULT_INVALID_TAG))) {
316 user_info.info23.info = info21;
318 init_samr_CryptPassword(uX->usriX_password,
320 &user_info.info23.password);
322 status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
329 user_info.info21 = info21;
331 status = rpccli_samr_SetUserInfo(pipe_cli, ctx,
340 /****************************************************************
341 ****************************************************************/
343 WERROR NetUserAdd_r(struct libnetapi_ctx *ctx,
344 struct NetUserAdd *r)
346 struct cli_state *cli = NULL;
347 struct rpc_pipe_client *pipe_cli = NULL;
350 POLICY_HND connect_handle, domain_handle, user_handle;
351 struct lsa_String lsa_account_name;
352 struct dom_sid2 *domain_sid = NULL;
353 union samr_UserInfo *user_info = NULL;
354 struct samr_PwInfo pw_info;
355 uint32_t access_granted = 0;
357 struct USER_INFO_X uX;
359 ZERO_STRUCT(connect_handle);
360 ZERO_STRUCT(domain_handle);
361 ZERO_STRUCT(user_handle);
364 return WERR_INVALID_PARAM;
367 switch (r->in.level) {
374 werr = WERR_NOT_SUPPORTED;
378 werr = libnetapi_open_pipe(ctx, r->in.server_name,
379 &ndr_table_samr.syntax_id,
382 if (!W_ERROR_IS_OK(werr)) {
386 status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
387 if (!NT_STATUS_IS_OK(status)) {
388 werr = ntstatus_to_werror(status);
392 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
393 SAMR_ACCESS_ENUM_DOMAINS |
394 SAMR_ACCESS_LOOKUP_DOMAIN,
395 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
396 SAMR_DOMAIN_ACCESS_CREATE_USER |
397 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
401 if (!W_ERROR_IS_OK(werr)) {
405 init_lsa_String(&lsa_account_name, uX.usriX_name);
407 status = rpccli_samr_CreateUser2(pipe_cli, ctx,
413 SAMR_USER_ACCESS_SET_PASSWORD |
414 SAMR_USER_ACCESS_SET_ATTRIBUTES |
415 SAMR_USER_ACCESS_GET_ATTRIBUTES,
419 if (!NT_STATUS_IS_OK(status)) {
420 werr = ntstatus_to_werror(status);
424 status = rpccli_samr_QueryUserInfo(pipe_cli, ctx,
428 if (!NT_STATUS_IS_OK(status)) {
429 werr = ntstatus_to_werror(status);
433 if (!(user_info->info16.acct_flags & ACB_NORMAL)) {
434 werr = WERR_INVALID_PARAM;
438 status = rpccli_samr_GetUserPwInfo(pipe_cli, ctx,
441 if (!NT_STATUS_IS_OK(status)) {
442 werr = ntstatus_to_werror(status);
446 uX.usriX_flags |= ACB_NORMAL;
448 status = set_user_info_USER_INFO_X(ctx, pipe_cli,
449 &cli->user_session_key,
452 if (!NT_STATUS_IS_OK(status)) {
453 werr = ntstatus_to_werror(status);
461 rpccli_samr_DeleteUser(pipe_cli, ctx,
469 if (is_valid_policy_hnd(&user_handle)) {
470 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
473 if (ctx->disable_policy_handle_cache) {
474 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
475 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
481 /****************************************************************
482 ****************************************************************/
484 WERROR NetUserAdd_l(struct libnetapi_ctx *ctx,
485 struct NetUserAdd *r)
487 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserAdd);
490 /****************************************************************
491 ****************************************************************/
493 WERROR NetUserDel_r(struct libnetapi_ctx *ctx,
494 struct NetUserDel *r)
496 struct cli_state *cli = NULL;
497 struct rpc_pipe_client *pipe_cli = NULL;
500 POLICY_HND connect_handle, builtin_handle, domain_handle, user_handle;
501 struct lsa_String lsa_account_name;
502 struct samr_Ids user_rids, name_types;
503 struct dom_sid2 *domain_sid = NULL;
504 struct dom_sid2 user_sid;
506 ZERO_STRUCT(connect_handle);
507 ZERO_STRUCT(builtin_handle);
508 ZERO_STRUCT(domain_handle);
509 ZERO_STRUCT(user_handle);
511 werr = libnetapi_open_pipe(ctx, r->in.server_name,
512 &ndr_table_samr.syntax_id,
516 if (!W_ERROR_IS_OK(werr)) {
520 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
521 SAMR_ACCESS_ENUM_DOMAINS |
522 SAMR_ACCESS_LOOKUP_DOMAIN,
523 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
527 if (!W_ERROR_IS_OK(werr)) {
531 status = rpccli_samr_OpenDomain(pipe_cli, ctx,
533 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
534 CONST_DISCARD(DOM_SID *, &global_sid_Builtin),
536 if (!NT_STATUS_IS_OK(status)) {
537 werr = ntstatus_to_werror(status);
541 init_lsa_String(&lsa_account_name, r->in.user_name);
543 status = rpccli_samr_LookupNames(pipe_cli, ctx,
549 if (!NT_STATUS_IS_OK(status)) {
550 werr = ntstatus_to_werror(status);
554 status = rpccli_samr_OpenUser(pipe_cli, ctx,
559 if (!NT_STATUS_IS_OK(status)) {
560 werr = ntstatus_to_werror(status);
564 sid_compose(&user_sid, domain_sid, user_rids.ids[0]);
566 status = rpccli_samr_RemoveMemberFromForeignDomain(pipe_cli, ctx,
569 if (!NT_STATUS_IS_OK(status)) {
570 werr = ntstatus_to_werror(status);
574 status = rpccli_samr_DeleteUser(pipe_cli, ctx,
576 if (!NT_STATUS_IS_OK(status)) {
577 werr = ntstatus_to_werror(status);
588 if (is_valid_policy_hnd(&user_handle)) {
589 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
592 if (ctx->disable_policy_handle_cache) {
593 libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
594 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
595 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
601 /****************************************************************
602 ****************************************************************/
604 WERROR NetUserDel_l(struct libnetapi_ctx *ctx,
605 struct NetUserDel *r)
607 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserDel);
610 /****************************************************************
611 ****************************************************************/
613 static NTSTATUS libnetapi_samr_lookup_user(TALLOC_CTX *mem_ctx,
614 struct rpc_pipe_client *pipe_cli,
615 struct policy_handle *domain_handle,
616 struct policy_handle *builtin_handle,
617 const char *user_name,
618 const struct dom_sid *domain_sid,
621 struct samr_UserInfo21 **info21,
622 struct sec_desc_buf **sec_desc,
623 uint32_t *auth_flag_p)
627 struct policy_handle user_handle;
628 union samr_UserInfo *user_info = NULL;
629 struct samr_RidWithAttributeArray *rid_array = NULL;
630 uint32_t access_mask = SEC_STD_READ_CONTROL |
631 SAMR_USER_ACCESS_GET_ATTRIBUTES |
632 SAMR_USER_ACCESS_GET_NAME_ETC;
634 ZERO_STRUCT(user_handle);
640 access_mask |= SAMR_USER_ACCESS_GET_LOGONINFO |
641 SAMR_USER_ACCESS_GET_GROUPS;
647 access_mask |= SAMR_USER_ACCESS_GET_LOGONINFO |
648 SAMR_USER_ACCESS_GET_GROUPS |
649 SAMR_USER_ACCESS_GET_LOCALE;
656 return NT_STATUS_INVALID_LEVEL;
663 status = rpccli_samr_OpenUser(pipe_cli, mem_ctx,
668 if (!NT_STATUS_IS_OK(status)) {
672 status = rpccli_samr_QueryUserInfo(pipe_cli, mem_ctx,
676 if (!NT_STATUS_IS_OK(status)) {
680 status = rpccli_samr_QuerySecurity(pipe_cli, mem_ctx,
684 if (!NT_STATUS_IS_OK(status)) {
688 if (access_mask & SAMR_USER_ACCESS_GET_GROUPS) {
690 struct lsa_SidArray sid_array;
691 struct samr_Ids alias_rids;
693 uint32_t auth_flag = 0;
696 status = rpccli_samr_GetGroupsForUser(pipe_cli, mem_ctx,
699 if (!NT_STATUS_IS_OK(status)) {
703 sid_array.num_sids = rid_array->count + 1;
704 sid_array.sids = talloc_array(mem_ctx, struct lsa_SidPtr,
706 NT_STATUS_HAVE_NO_MEMORY(sid_array.sids);
708 for (i=0; i<rid_array->count; i++) {
709 sid_compose(&sid, domain_sid, rid_array->rids[i].rid);
710 sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
711 NT_STATUS_HAVE_NO_MEMORY(sid_array.sids[i].sid);
714 sid_compose(&sid, domain_sid, rid);
715 sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
716 NT_STATUS_HAVE_NO_MEMORY(sid_array.sids[i].sid);
718 status = rpccli_samr_GetAliasMembership(pipe_cli, mem_ctx,
722 if (!NT_STATUS_IS_OK(status)) {
726 for (i=0; i<alias_rids.count; i++) {
727 switch (alias_rids.ids[i]) {
728 case 550: /* Print Operators */
729 auth_flag |= AF_OP_PRINT;
731 case 549: /* Server Operators */
732 auth_flag |= AF_OP_SERVER;
734 case 548: /* Account Operators */
735 auth_flag |= AF_OP_ACCOUNTS;
743 *auth_flag_p = auth_flag;
747 *info21 = &user_info->info21;
750 if (is_valid_policy_hnd(&user_handle)) {
751 rpccli_samr_Close(pipe_cli, mem_ctx, &user_handle);
757 /****************************************************************
758 ****************************************************************/
760 static uint32_t samr_rid_to_priv_level(uint32_t rid)
763 case DOMAIN_RID_ADMINISTRATOR:
764 return USER_PRIV_ADMIN;
765 case DOMAIN_RID_GUEST:
766 return USER_PRIV_GUEST;
768 return USER_PRIV_USER;
772 /****************************************************************
773 ****************************************************************/
775 static uint32_t samr_acb_flags_to_netapi_flags(uint32_t acb)
777 uint32_t fl = UF_SCRIPT; /* god knows why */
779 fl |= ads_acb2uf(acb);
784 /****************************************************************
785 ****************************************************************/
787 static NTSTATUS info21_to_USER_INFO_1(TALLOC_CTX *mem_ctx,
788 const struct samr_UserInfo21 *i21,
789 struct USER_INFO_1 *i)
792 i->usri1_name = talloc_strdup(mem_ctx, i21->account_name.string);
793 NT_STATUS_HAVE_NO_MEMORY(i->usri1_name);
794 i->usri1_password = NULL;
795 i->usri1_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
796 i->usri1_priv = samr_rid_to_priv_level(i21->rid);
797 i->usri1_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
798 i->usri1_comment = talloc_strdup(mem_ctx, i21->description.string);
799 i->usri1_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
800 i->usri1_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
805 /****************************************************************
806 ****************************************************************/
808 static NTSTATUS info21_to_USER_INFO_2(TALLOC_CTX *mem_ctx,
809 const struct samr_UserInfo21 *i21,
811 struct USER_INFO_2 *i)
815 i->usri2_name = talloc_strdup(mem_ctx, i21->account_name.string);
816 NT_STATUS_HAVE_NO_MEMORY(i->usri2_name);
817 i->usri2_password = NULL;
818 i->usri2_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
819 i->usri2_priv = samr_rid_to_priv_level(i21->rid);
820 i->usri2_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
821 i->usri2_comment = talloc_strdup(mem_ctx, i21->description.string);
822 i->usri2_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
823 i->usri2_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
824 i->usri2_auth_flags = auth_flag;
825 i->usri2_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
826 i->usri2_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
827 i->usri2_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
828 i->usri2_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
829 i->usri2_last_logon = nt_time_to_unix(i21->last_logon);
830 i->usri2_last_logoff = nt_time_to_unix(i21->last_logoff);
831 i->usri2_acct_expires = nt_time_to_unix(i21->acct_expiry);
832 i->usri2_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
833 i->usri2_units_per_week = i21->logon_hours.units_per_week;
834 i->usri2_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
835 i->usri2_bad_pw_count = i21->bad_password_count;
836 i->usri2_num_logons = i21->logon_count;
837 i->usri2_logon_server = talloc_strdup(mem_ctx, "\\\\*");
838 i->usri2_country_code = i21->country_code;
839 i->usri2_code_page = i21->code_page;
844 /****************************************************************
845 ****************************************************************/
847 static NTSTATUS info21_to_USER_INFO_3(TALLOC_CTX *mem_ctx,
848 const struct samr_UserInfo21 *i21,
850 struct USER_INFO_3 *i)
854 i->usri3_name = talloc_strdup(mem_ctx, i21->account_name.string);
855 NT_STATUS_HAVE_NO_MEMORY(i->usri3_name);
856 i->usri3_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
857 i->usri3_priv = samr_rid_to_priv_level(i21->rid);
858 i->usri3_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
859 i->usri3_comment = talloc_strdup(mem_ctx, i21->description.string);
860 i->usri3_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
861 i->usri3_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
862 i->usri3_auth_flags = auth_flag;
863 i->usri3_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
864 i->usri3_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
865 i->usri3_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
866 i->usri3_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
867 i->usri3_last_logon = nt_time_to_unix(i21->last_logon);
868 i->usri3_last_logoff = nt_time_to_unix(i21->last_logoff);
869 i->usri3_acct_expires = nt_time_to_unix(i21->acct_expiry);
870 i->usri3_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
871 i->usri3_units_per_week = i21->logon_hours.units_per_week;
872 i->usri3_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
873 i->usri3_bad_pw_count = i21->bad_password_count;
874 i->usri3_num_logons = i21->logon_count;
875 i->usri3_logon_server = talloc_strdup(mem_ctx, "\\\\*");
876 i->usri3_country_code = i21->country_code;
877 i->usri3_code_page = i21->code_page;
878 i->usri3_user_id = i21->rid;
879 i->usri3_primary_group_id = i21->primary_gid;
880 i->usri3_profile = talloc_strdup(mem_ctx, i21->profile_path.string);
881 i->usri3_home_dir_drive = talloc_strdup(mem_ctx, i21->home_drive.string);
882 i->usri3_password_expired = i21->password_expired;
887 /****************************************************************
888 ****************************************************************/
890 static NTSTATUS info21_to_USER_INFO_4(TALLOC_CTX *mem_ctx,
891 const struct samr_UserInfo21 *i21,
893 struct dom_sid *domain_sid,
894 struct USER_INFO_4 *i)
900 i->usri4_name = talloc_strdup(mem_ctx, i21->account_name.string);
901 NT_STATUS_HAVE_NO_MEMORY(i->usri4_name);
902 i->usri4_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
903 i->usri4_password = NULL;
904 i->usri4_priv = samr_rid_to_priv_level(i21->rid);
905 i->usri4_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
906 i->usri4_comment = talloc_strdup(mem_ctx, i21->description.string);
907 i->usri4_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
908 i->usri4_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
909 i->usri4_auth_flags = auth_flag;
910 i->usri4_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
911 i->usri4_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
912 i->usri4_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
913 i->usri4_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
914 i->usri4_last_logon = nt_time_to_unix(i21->last_logon);
915 i->usri4_last_logoff = nt_time_to_unix(i21->last_logoff);
916 i->usri4_acct_expires = nt_time_to_unix(i21->acct_expiry);
917 i->usri4_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
918 i->usri4_units_per_week = i21->logon_hours.units_per_week;
919 i->usri4_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
920 i->usri4_bad_pw_count = i21->bad_password_count;
921 i->usri4_num_logons = i21->logon_count;
922 i->usri4_logon_server = talloc_strdup(mem_ctx, "\\\\*");
923 i->usri4_country_code = i21->country_code;
924 i->usri4_code_page = i21->code_page;
925 if (!sid_compose(&sid, domain_sid, i21->rid)) {
926 return NT_STATUS_NO_MEMORY;
928 i->usri4_user_sid = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
929 i->usri4_primary_group_id = i21->primary_gid;
930 i->usri4_profile = talloc_strdup(mem_ctx, i21->profile_path.string);
931 i->usri4_home_dir_drive = talloc_strdup(mem_ctx, i21->home_drive.string);
932 i->usri4_password_expired = i21->password_expired;
937 /****************************************************************
938 ****************************************************************/
940 static NTSTATUS info21_to_USER_INFO_10(TALLOC_CTX *mem_ctx,
941 const struct samr_UserInfo21 *i21,
942 struct USER_INFO_10 *i)
946 i->usri10_name = talloc_strdup(mem_ctx, i21->account_name.string);
947 NT_STATUS_HAVE_NO_MEMORY(i->usri10_name);
948 i->usri10_comment = talloc_strdup(mem_ctx, i21->description.string);
949 i->usri10_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
950 i->usri10_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
955 /****************************************************************
956 ****************************************************************/
958 static NTSTATUS info21_to_USER_INFO_11(TALLOC_CTX *mem_ctx,
959 const struct samr_UserInfo21 *i21,
961 struct USER_INFO_11 *i)
965 i->usri11_name = talloc_strdup(mem_ctx, i21->account_name.string);
966 NT_STATUS_HAVE_NO_MEMORY(i->usri11_name);
967 i->usri11_comment = talloc_strdup(mem_ctx, i21->description.string);
968 i->usri11_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
969 i->usri11_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
970 i->usri11_priv = samr_rid_to_priv_level(i21->rid);
971 i->usri11_auth_flags = auth_flag;
972 i->usri11_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
973 i->usri11_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
974 i->usri11_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
975 i->usri11_last_logon = nt_time_to_unix(i21->last_logon);
976 i->usri11_last_logoff = nt_time_to_unix(i21->last_logoff);
977 i->usri11_bad_pw_count = i21->bad_password_count;
978 i->usri11_num_logons = i21->logon_count;
979 i->usri11_logon_server = talloc_strdup(mem_ctx, "\\\\*");
980 i->usri11_country_code = i21->country_code;
981 i->usri11_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
982 i->usri11_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
983 i->usri11_units_per_week = i21->logon_hours.units_per_week;
984 i->usri11_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
985 i->usri11_code_page = i21->code_page;
990 /****************************************************************
991 ****************************************************************/
993 static NTSTATUS info21_to_USER_INFO_20(TALLOC_CTX *mem_ctx,
994 const struct samr_UserInfo21 *i21,
995 struct USER_INFO_20 *i)
999 i->usri20_name = talloc_strdup(mem_ctx, i21->account_name.string);
1000 NT_STATUS_HAVE_NO_MEMORY(i->usri20_name);
1001 i->usri20_comment = talloc_strdup(mem_ctx, i21->description.string);
1002 i->usri20_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
1003 i->usri20_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
1004 i->usri20_user_id = i21->rid;
1006 return NT_STATUS_OK;
1009 /****************************************************************
1010 ****************************************************************/
1012 static NTSTATUS info21_to_USER_INFO_23(TALLOC_CTX *mem_ctx,
1013 const struct samr_UserInfo21 *i21,
1014 struct dom_sid *domain_sid,
1015 struct USER_INFO_23 *i)
1021 i->usri23_name = talloc_strdup(mem_ctx, i21->account_name.string);
1022 NT_STATUS_HAVE_NO_MEMORY(i->usri23_name);
1023 i->usri23_comment = talloc_strdup(mem_ctx, i21->description.string);
1024 i->usri23_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
1025 i->usri23_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
1026 if (!sid_compose(&sid, domain_sid, i21->rid)) {
1027 return NT_STATUS_NO_MEMORY;
1029 i->usri23_user_sid = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
1031 return NT_STATUS_OK;
1034 /****************************************************************
1035 ****************************************************************/
1037 static NTSTATUS libnetapi_samr_lookup_user_map_USER_INFO(TALLOC_CTX *mem_ctx,
1038 struct rpc_pipe_client *pipe_cli,
1039 struct dom_sid *domain_sid,
1040 struct policy_handle *domain_handle,
1041 struct policy_handle *builtin_handle,
1042 const char *user_name,
1046 uint32_t *num_entries)
1050 struct samr_UserInfo21 *info21 = NULL;
1051 struct sec_desc_buf *sec_desc = NULL;
1052 uint32_t auth_flag = 0;
1054 struct USER_INFO_0 info0;
1055 struct USER_INFO_1 info1;
1056 struct USER_INFO_2 info2;
1057 struct USER_INFO_3 info3;
1058 struct USER_INFO_4 info4;
1059 struct USER_INFO_10 info10;
1060 struct USER_INFO_11 info11;
1061 struct USER_INFO_20 info20;
1062 struct USER_INFO_23 info23;
1076 return NT_STATUS_INVALID_LEVEL;
1080 info0.usri0_name = talloc_strdup(mem_ctx, user_name);
1081 NT_STATUS_HAVE_NO_MEMORY(info0.usri0_name);
1083 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_0, info0,
1084 (struct USER_INFO_0 **)buffer, num_entries);
1086 return NT_STATUS_OK;
1089 status = libnetapi_samr_lookup_user(mem_ctx, pipe_cli,
1100 if (!NT_STATUS_IS_OK(status)) {
1106 /* already returned above */
1109 status = info21_to_USER_INFO_1(mem_ctx, info21, &info1);
1110 NT_STATUS_NOT_OK_RETURN(status);
1112 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_1, info1,
1113 (struct USER_INFO_1 **)buffer, num_entries);
1117 status = info21_to_USER_INFO_2(mem_ctx, info21, auth_flag, &info2);
1118 NT_STATUS_NOT_OK_RETURN(status);
1120 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_2, info2,
1121 (struct USER_INFO_2 **)buffer, num_entries);
1125 status = info21_to_USER_INFO_3(mem_ctx, info21, auth_flag, &info3);
1126 NT_STATUS_NOT_OK_RETURN(status);
1128 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_3, info3,
1129 (struct USER_INFO_3 **)buffer, num_entries);
1133 status = info21_to_USER_INFO_4(mem_ctx, info21, auth_flag, domain_sid, &info4);
1134 NT_STATUS_NOT_OK_RETURN(status);
1136 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_4, info4,
1137 (struct USER_INFO_4 **)buffer, num_entries);
1141 status = info21_to_USER_INFO_10(mem_ctx, info21, &info10);
1142 NT_STATUS_NOT_OK_RETURN(status);
1144 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_10, info10,
1145 (struct USER_INFO_10 **)buffer, num_entries);
1149 status = info21_to_USER_INFO_11(mem_ctx, info21, auth_flag, &info11);
1150 NT_STATUS_NOT_OK_RETURN(status);
1152 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_11, info11,
1153 (struct USER_INFO_11 **)buffer, num_entries);
1157 status = info21_to_USER_INFO_20(mem_ctx, info21, &info20);
1158 NT_STATUS_NOT_OK_RETURN(status);
1160 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_20, info20,
1161 (struct USER_INFO_20 **)buffer, num_entries);
1165 status = info21_to_USER_INFO_23(mem_ctx, info21, domain_sid, &info23);
1166 NT_STATUS_NOT_OK_RETURN(status);
1168 ADD_TO_ARRAY(mem_ctx, struct USER_INFO_23, info23,
1169 (struct USER_INFO_23 **)buffer, num_entries);
1172 return NT_STATUS_INVALID_LEVEL;
1179 /****************************************************************
1180 ****************************************************************/
1182 WERROR NetUserEnum_r(struct libnetapi_ctx *ctx,
1183 struct NetUserEnum *r)
1185 struct cli_state *cli = NULL;
1186 struct rpc_pipe_client *pipe_cli = NULL;
1187 struct policy_handle connect_handle;
1188 struct dom_sid2 *domain_sid = NULL;
1189 struct policy_handle domain_handle, builtin_handle;
1190 struct samr_SamArray *sam = NULL;
1191 uint32_t filter = ACB_NORMAL;
1193 uint32_t entries_read = 0;
1195 NTSTATUS status = NT_STATUS_OK;
1198 ZERO_STRUCT(connect_handle);
1199 ZERO_STRUCT(domain_handle);
1200 ZERO_STRUCT(builtin_handle);
1202 if (!r->out.buffer) {
1203 return WERR_INVALID_PARAM;
1206 *r->out.buffer = NULL;
1207 *r->out.entries_read = 0;
1209 switch (r->in.level) {
1221 return WERR_UNKNOWN_LEVEL;
1224 werr = libnetapi_open_pipe(ctx, r->in.server_name,
1225 &ndr_table_samr.syntax_id,
1228 if (!W_ERROR_IS_OK(werr)) {
1232 werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1233 SAMR_ACCESS_ENUM_DOMAINS |
1234 SAMR_ACCESS_LOOKUP_DOMAIN,
1235 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1236 SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1239 if (!W_ERROR_IS_OK(werr)) {
1243 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1244 SAMR_ACCESS_ENUM_DOMAINS |
1245 SAMR_ACCESS_LOOKUP_DOMAIN,
1246 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
1247 SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
1248 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1252 if (!W_ERROR_IS_OK(werr)) {
1256 switch (r->in.filter) {
1257 case FILTER_NORMAL_ACCOUNT:
1258 filter = ACB_NORMAL;
1260 case FILTER_TEMP_DUPLICATE_ACCOUNT:
1261 filter = ACB_TEMPDUP;
1263 case FILTER_INTERDOMAIN_TRUST_ACCOUNT:
1264 filter = ACB_DOMTRUST;
1266 case FILTER_WORKSTATION_TRUST_ACCOUNT:
1267 filter = ACB_WSTRUST;
1269 case FILTER_SERVER_TRUST_ACCOUNT:
1270 filter = ACB_SVRTRUST;
1276 status = rpccli_samr_EnumDomainUsers(pipe_cli,
1279 r->in.resume_handle,
1284 werr = ntstatus_to_werror(status);
1285 if (NT_STATUS_IS_ERR(status)) {
1289 for (i=0; i < sam->count; i++) {
1291 status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
1295 sam->entries[i].name.string,
1296 sam->entries[i].idx,
1299 r->out.entries_read);
1300 if (!NT_STATUS_IS_OK(status)) {
1301 werr = ntstatus_to_werror(status);
1312 if (NT_STATUS_IS_OK(status) ||
1313 NT_STATUS_IS_ERR(status)) {
1315 if (ctx->disable_policy_handle_cache) {
1316 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1317 libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
1318 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1325 /****************************************************************
1326 ****************************************************************/
1328 WERROR NetUserEnum_l(struct libnetapi_ctx *ctx,
1329 struct NetUserEnum *r)
1331 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserEnum);
1334 /****************************************************************
1335 ****************************************************************/
1337 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_USER(TALLOC_CTX *mem_ctx,
1338 struct samr_DispInfoGeneral *info,
1339 uint32_t *entries_read,
1342 struct NET_DISPLAY_USER *user = NULL;
1345 user = TALLOC_ZERO_ARRAY(mem_ctx,
1346 struct NET_DISPLAY_USER,
1348 W_ERROR_HAVE_NO_MEMORY(user);
1350 for (i = 0; i < info->count; i++) {
1351 user[i].usri1_name = talloc_strdup(mem_ctx,
1352 info->entries[i].account_name.string);
1353 user[i].usri1_comment = talloc_strdup(mem_ctx,
1354 info->entries[i].description.string);
1355 user[i].usri1_flags =
1356 info->entries[i].acct_flags;
1357 user[i].usri1_full_name = talloc_strdup(mem_ctx,
1358 info->entries[i].full_name.string);
1359 user[i].usri1_user_id =
1360 info->entries[i].rid;
1361 user[i].usri1_next_index =
1362 info->entries[i].idx;
1364 if (!user[i].usri1_name) {
1369 *buffer = talloc_memdup(mem_ctx, user,
1370 sizeof(struct NET_DISPLAY_USER) * info->count);
1371 W_ERROR_HAVE_NO_MEMORY(*buffer);
1373 *entries_read = info->count;
1378 /****************************************************************
1379 ****************************************************************/
1381 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(TALLOC_CTX *mem_ctx,
1382 struct samr_DispInfoFull *info,
1383 uint32_t *entries_read,
1386 struct NET_DISPLAY_MACHINE *machine = NULL;
1389 machine = TALLOC_ZERO_ARRAY(mem_ctx,
1390 struct NET_DISPLAY_MACHINE,
1392 W_ERROR_HAVE_NO_MEMORY(machine);
1394 for (i = 0; i < info->count; i++) {
1395 machine[i].usri2_name = talloc_strdup(mem_ctx,
1396 info->entries[i].account_name.string);
1397 machine[i].usri2_comment = talloc_strdup(mem_ctx,
1398 info->entries[i].description.string);
1399 machine[i].usri2_flags =
1400 info->entries[i].acct_flags;
1401 machine[i].usri2_user_id =
1402 info->entries[i].rid;
1403 machine[i].usri2_next_index =
1404 info->entries[i].idx;
1406 if (!machine[i].usri2_name) {
1411 *buffer = talloc_memdup(mem_ctx, machine,
1412 sizeof(struct NET_DISPLAY_MACHINE) * info->count);
1413 W_ERROR_HAVE_NO_MEMORY(*buffer);
1415 *entries_read = info->count;
1420 /****************************************************************
1421 ****************************************************************/
1423 static WERROR convert_samr_dispinfo_to_NET_DISPLAY_GROUP(TALLOC_CTX *mem_ctx,
1424 struct samr_DispInfoFullGroups *info,
1425 uint32_t *entries_read,
1428 struct NET_DISPLAY_GROUP *group = NULL;
1431 group = TALLOC_ZERO_ARRAY(mem_ctx,
1432 struct NET_DISPLAY_GROUP,
1434 W_ERROR_HAVE_NO_MEMORY(group);
1436 for (i = 0; i < info->count; i++) {
1437 group[i].grpi3_name = talloc_strdup(mem_ctx,
1438 info->entries[i].account_name.string);
1439 group[i].grpi3_comment = talloc_strdup(mem_ctx,
1440 info->entries[i].description.string);
1441 group[i].grpi3_group_id =
1442 info->entries[i].rid;
1443 group[i].grpi3_attributes =
1444 info->entries[i].acct_flags;
1445 group[i].grpi3_next_index =
1446 info->entries[i].idx;
1448 if (!group[i].grpi3_name) {
1453 *buffer = talloc_memdup(mem_ctx, group,
1454 sizeof(struct NET_DISPLAY_GROUP) * info->count);
1455 W_ERROR_HAVE_NO_MEMORY(*buffer);
1457 *entries_read = info->count;
1463 /****************************************************************
1464 ****************************************************************/
1466 static WERROR convert_samr_dispinfo_to_NET_DISPLAY(TALLOC_CTX *mem_ctx,
1467 union samr_DispInfo *info,
1469 uint32_t *entries_read,
1474 return convert_samr_dispinfo_to_NET_DISPLAY_USER(mem_ctx,
1479 return convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(mem_ctx,
1484 return convert_samr_dispinfo_to_NET_DISPLAY_GROUP(mem_ctx,
1489 return WERR_UNKNOWN_LEVEL;
1495 /****************************************************************
1496 ****************************************************************/
1498 WERROR NetQueryDisplayInformation_r(struct libnetapi_ctx *ctx,
1499 struct NetQueryDisplayInformation *r)
1501 struct cli_state *cli = NULL;
1502 struct rpc_pipe_client *pipe_cli = NULL;
1503 struct policy_handle connect_handle;
1504 struct dom_sid2 *domain_sid = NULL;
1505 struct policy_handle domain_handle;
1506 union samr_DispInfo info;
1508 uint32_t total_size = 0;
1509 uint32_t returned_size = 0;
1511 NTSTATUS status = NT_STATUS_OK;
1515 *r->out.entries_read = 0;
1517 ZERO_STRUCT(connect_handle);
1518 ZERO_STRUCT(domain_handle);
1520 switch (r->in.level) {
1526 return WERR_UNKNOWN_LEVEL;
1529 werr = libnetapi_open_pipe(ctx, r->in.server_name,
1530 &ndr_table_samr.syntax_id,
1533 if (!W_ERROR_IS_OK(werr)) {
1537 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1538 SAMR_ACCESS_ENUM_DOMAINS |
1539 SAMR_ACCESS_LOOKUP_DOMAIN,
1540 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
1541 SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
1542 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1546 if (!W_ERROR_IS_OK(werr)) {
1550 status = rpccli_samr_QueryDisplayInfo2(pipe_cli,
1555 r->in.entries_requested,
1560 werr = ntstatus_to_werror(status);
1561 if (NT_STATUS_IS_ERR(status)) {
1565 werr_tmp = convert_samr_dispinfo_to_NET_DISPLAY(ctx, &info,
1567 r->out.entries_read,
1569 if (!W_ERROR_IS_OK(werr_tmp)) {
1578 if (NT_STATUS_IS_OK(status) ||
1579 NT_STATUS_IS_ERR(status)) {
1581 if (ctx->disable_policy_handle_cache) {
1582 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1583 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1591 /****************************************************************
1592 ****************************************************************/
1595 WERROR NetQueryDisplayInformation_l(struct libnetapi_ctx *ctx,
1596 struct NetQueryDisplayInformation *r)
1598 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetQueryDisplayInformation);
1601 /****************************************************************
1602 ****************************************************************/
1604 WERROR NetUserChangePassword_r(struct libnetapi_ctx *ctx,
1605 struct NetUserChangePassword *r)
1607 return WERR_NOT_SUPPORTED;
1610 /****************************************************************
1611 ****************************************************************/
1613 WERROR NetUserChangePassword_l(struct libnetapi_ctx *ctx,
1614 struct NetUserChangePassword *r)
1616 return WERR_NOT_SUPPORTED;
1619 /****************************************************************
1620 ****************************************************************/
1622 WERROR NetUserGetInfo_r(struct libnetapi_ctx *ctx,
1623 struct NetUserGetInfo *r)
1625 struct cli_state *cli = NULL;
1626 struct rpc_pipe_client *pipe_cli = NULL;
1630 struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1631 struct lsa_String lsa_account_name;
1632 struct dom_sid2 *domain_sid = NULL;
1633 struct samr_Ids user_rids, name_types;
1634 uint32_t num_entries = 0;
1636 ZERO_STRUCT(connect_handle);
1637 ZERO_STRUCT(domain_handle);
1638 ZERO_STRUCT(builtin_handle);
1639 ZERO_STRUCT(user_handle);
1641 if (!r->out.buffer) {
1642 return WERR_INVALID_PARAM;
1645 switch (r->in.level) {
1657 werr = WERR_UNKNOWN_LEVEL;
1661 werr = libnetapi_open_pipe(ctx, r->in.server_name,
1662 &ndr_table_samr.syntax_id,
1665 if (!W_ERROR_IS_OK(werr)) {
1669 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1670 SAMR_ACCESS_ENUM_DOMAINS |
1671 SAMR_ACCESS_LOOKUP_DOMAIN,
1672 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1676 if (!W_ERROR_IS_OK(werr)) {
1680 werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1681 SAMR_ACCESS_ENUM_DOMAINS |
1682 SAMR_ACCESS_LOOKUP_DOMAIN,
1683 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1684 SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1687 if (!W_ERROR_IS_OK(werr)) {
1691 init_lsa_String(&lsa_account_name, r->in.user_name);
1693 status = rpccli_samr_LookupNames(pipe_cli, ctx,
1699 if (!NT_STATUS_IS_OK(status)) {
1700 werr = ntstatus_to_werror(status);
1704 status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
1713 if (!NT_STATUS_IS_OK(status)) {
1714 werr = ntstatus_to_werror(status);
1723 if (is_valid_policy_hnd(&user_handle)) {
1724 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1727 if (ctx->disable_policy_handle_cache) {
1728 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1729 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1735 /****************************************************************
1736 ****************************************************************/
1738 WERROR NetUserGetInfo_l(struct libnetapi_ctx *ctx,
1739 struct NetUserGetInfo *r)
1741 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetInfo);
1744 /****************************************************************
1745 ****************************************************************/
1747 WERROR NetUserSetInfo_r(struct libnetapi_ctx *ctx,
1748 struct NetUserSetInfo *r)
1750 struct cli_state *cli = NULL;
1751 struct rpc_pipe_client *pipe_cli = NULL;
1755 struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1756 struct lsa_String lsa_account_name;
1757 struct dom_sid2 *domain_sid = NULL;
1758 struct samr_Ids user_rids, name_types;
1759 uint32_t user_mask = 0;
1761 struct USER_INFO_X uX;
1763 ZERO_STRUCT(connect_handle);
1764 ZERO_STRUCT(domain_handle);
1765 ZERO_STRUCT(builtin_handle);
1766 ZERO_STRUCT(user_handle);
1768 if (!r->in.buffer) {
1769 return WERR_INVALID_PARAM;
1772 switch (r->in.level) {
1775 user_mask = SAMR_USER_ACCESS_SET_PASSWORD;
1784 user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES;
1788 user_mask = SAMR_USER_ACCESS_SET_LOC_COM;
1790 user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES |
1791 SAMR_USER_ACCESS_GET_GROUPS;
1794 user_mask = STD_RIGHT_READ_CONTROL_ACCESS |
1795 STD_RIGHT_WRITE_DAC_ACCESS |
1796 SAMR_USER_ACCESS_GET_GROUPS |
1797 SAMR_USER_ACCESS_SET_PASSWORD |
1798 SAMR_USER_ACCESS_SET_ATTRIBUTES |
1799 SAMR_USER_ACCESS_GET_ATTRIBUTES |
1800 SAMR_USER_ACCESS_SET_LOC_COM;
1812 werr = WERR_NOT_SUPPORTED;
1815 werr = WERR_UNKNOWN_LEVEL;
1819 werr = libnetapi_open_pipe(ctx, r->in.server_name,
1820 &ndr_table_samr.syntax_id,
1823 if (!W_ERROR_IS_OK(werr)) {
1827 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1828 SAMR_ACCESS_ENUM_DOMAINS |
1829 SAMR_ACCESS_LOOKUP_DOMAIN,
1830 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
1831 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1835 if (!W_ERROR_IS_OK(werr)) {
1839 werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1840 SAMR_ACCESS_ENUM_DOMAINS |
1841 SAMR_ACCESS_LOOKUP_DOMAIN,
1842 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1843 SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1846 if (!W_ERROR_IS_OK(werr)) {
1850 init_lsa_String(&lsa_account_name, r->in.user_name);
1852 status = rpccli_samr_LookupNames(pipe_cli, ctx,
1858 if (!NT_STATUS_IS_OK(status)) {
1859 werr = ntstatus_to_werror(status);
1863 status = rpccli_samr_OpenUser(pipe_cli, ctx,
1868 if (!NT_STATUS_IS_OK(status)) {
1869 werr = ntstatus_to_werror(status);
1873 status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
1874 if (!NT_STATUS_IS_OK(status)) {
1875 werr = ntstatus_to_werror(status);
1879 status = set_user_info_USER_INFO_X(ctx, pipe_cli,
1880 &cli->user_session_key,
1883 if (!NT_STATUS_IS_OK(status)) {
1884 werr = ntstatus_to_werror(status);
1895 if (is_valid_policy_hnd(&user_handle)) {
1896 rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1899 if (ctx->disable_policy_handle_cache) {
1900 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1901 libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
1902 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1908 /****************************************************************
1909 ****************************************************************/
1911 WERROR NetUserSetInfo_l(struct libnetapi_ctx *ctx,
1912 struct NetUserSetInfo *r)
1914 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserSetInfo);
1917 /****************************************************************
1918 ****************************************************************/
1920 static NTSTATUS query_USER_MODALS_INFO_rpc(TALLOC_CTX *mem_ctx,
1921 struct rpc_pipe_client *pipe_cli,
1922 struct policy_handle *domain_handle,
1923 struct samr_DomInfo1 *info1,
1924 struct samr_DomInfo3 *info3,
1925 struct samr_DomInfo5 *info5,
1926 struct samr_DomInfo6 *info6,
1927 struct samr_DomInfo7 *info7,
1928 struct samr_DomInfo12 *info12)
1931 union samr_DomainInfo *dom_info = NULL;
1934 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1938 NT_STATUS_NOT_OK_RETURN(status);
1940 *info1 = dom_info->info1;
1944 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1948 NT_STATUS_NOT_OK_RETURN(status);
1950 *info3 = dom_info->info3;
1954 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1958 NT_STATUS_NOT_OK_RETURN(status);
1960 *info5 = dom_info->info5;
1964 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1968 NT_STATUS_NOT_OK_RETURN(status);
1970 *info6 = dom_info->info6;
1974 status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1978 NT_STATUS_NOT_OK_RETURN(status);
1980 *info7 = dom_info->info7;
1984 status = rpccli_samr_QueryDomainInfo2(pipe_cli, mem_ctx,
1988 NT_STATUS_NOT_OK_RETURN(status);
1990 *info12 = dom_info->info12;
1993 return NT_STATUS_OK;
1996 /****************************************************************
1997 ****************************************************************/
1999 static NTSTATUS query_USER_MODALS_INFO_0(TALLOC_CTX *mem_ctx,
2000 struct rpc_pipe_client *pipe_cli,
2001 struct policy_handle *domain_handle,
2002 struct USER_MODALS_INFO_0 *info0)
2005 struct samr_DomInfo1 dom_info1;
2006 struct samr_DomInfo3 dom_info3;
2008 ZERO_STRUCTP(info0);
2010 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2019 NT_STATUS_NOT_OK_RETURN(status);
2021 info0->usrmod0_min_passwd_len =
2022 dom_info1.min_password_length;
2023 info0->usrmod0_max_passwd_age =
2024 nt_time_to_unix_abs((NTTIME *)&dom_info1.max_password_age);
2025 info0->usrmod0_min_passwd_age =
2026 nt_time_to_unix_abs((NTTIME *)&dom_info1.min_password_age);
2027 info0->usrmod0_password_hist_len =
2028 dom_info1.password_history_length;
2030 info0->usrmod0_force_logoff =
2031 nt_time_to_unix_abs(&dom_info3.force_logoff_time);
2033 return NT_STATUS_OK;
2036 /****************************************************************
2037 ****************************************************************/
2039 static NTSTATUS query_USER_MODALS_INFO_1(TALLOC_CTX *mem_ctx,
2040 struct rpc_pipe_client *pipe_cli,
2041 struct policy_handle *domain_handle,
2042 struct USER_MODALS_INFO_1 *info1)
2045 struct samr_DomInfo6 dom_info6;
2046 struct samr_DomInfo7 dom_info7;
2048 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2057 NT_STATUS_NOT_OK_RETURN(status);
2059 info1->usrmod1_primary =
2060 talloc_strdup(mem_ctx, dom_info6.primary.string);
2062 info1->usrmod1_role = dom_info7.role;
2064 return NT_STATUS_OK;
2067 /****************************************************************
2068 ****************************************************************/
2070 static NTSTATUS query_USER_MODALS_INFO_2(TALLOC_CTX *mem_ctx,
2071 struct rpc_pipe_client *pipe_cli,
2072 struct policy_handle *domain_handle,
2073 struct dom_sid *domain_sid,
2074 struct USER_MODALS_INFO_2 *info2)
2077 struct samr_DomInfo5 dom_info5;
2079 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2088 NT_STATUS_NOT_OK_RETURN(status);
2090 info2->usrmod2_domain_name =
2091 talloc_strdup(mem_ctx, dom_info5.domain_name.string);
2092 info2->usrmod2_domain_id =
2093 (struct domsid *)sid_dup_talloc(mem_ctx, domain_sid);
2095 NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_name);
2096 NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_id);
2098 return NT_STATUS_OK;
2101 /****************************************************************
2102 ****************************************************************/
2104 static NTSTATUS query_USER_MODALS_INFO_3(TALLOC_CTX *mem_ctx,
2105 struct rpc_pipe_client *pipe_cli,
2106 struct policy_handle *domain_handle,
2107 struct USER_MODALS_INFO_3 *info3)
2110 struct samr_DomInfo12 dom_info12;
2112 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2121 NT_STATUS_NOT_OK_RETURN(status);
2123 info3->usrmod3_lockout_duration =
2124 nt_time_to_unix_abs(&dom_info12.lockout_duration);
2125 info3->usrmod3_lockout_observation_window =
2126 nt_time_to_unix_abs(&dom_info12.lockout_window);
2127 info3->usrmod3_lockout_threshold =
2128 dom_info12.lockout_threshold;
2130 return NT_STATUS_OK;
2133 /****************************************************************
2134 ****************************************************************/
2136 static NTSTATUS query_USER_MODALS_INFO_to_buffer(TALLOC_CTX *mem_ctx,
2137 struct rpc_pipe_client *pipe_cli,
2139 struct policy_handle *domain_handle,
2140 struct dom_sid *domain_sid,
2145 struct USER_MODALS_INFO_0 info0;
2146 struct USER_MODALS_INFO_1 info1;
2147 struct USER_MODALS_INFO_2 info2;
2148 struct USER_MODALS_INFO_3 info3;
2151 return ERROR_INSUFFICIENT_BUFFER;
2156 status = query_USER_MODALS_INFO_0(mem_ctx,
2160 NT_STATUS_NOT_OK_RETURN(status);
2162 *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info0,
2167 status = query_USER_MODALS_INFO_1(mem_ctx,
2171 NT_STATUS_NOT_OK_RETURN(status);
2173 *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info1,
2177 status = query_USER_MODALS_INFO_2(mem_ctx,
2182 NT_STATUS_NOT_OK_RETURN(status);
2184 *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info2,
2188 status = query_USER_MODALS_INFO_3(mem_ctx,
2192 NT_STATUS_NOT_OK_RETURN(status);
2194 *buffer = (uint8_t *)talloc_memdup(mem_ctx, &info3,
2201 NT_STATUS_HAVE_NO_MEMORY(*buffer);
2203 return NT_STATUS_OK;
2206 /****************************************************************
2207 ****************************************************************/
2209 WERROR NetUserModalsGet_r(struct libnetapi_ctx *ctx,
2210 struct NetUserModalsGet *r)
2212 struct cli_state *cli = NULL;
2213 struct rpc_pipe_client *pipe_cli = NULL;
2217 struct policy_handle connect_handle, domain_handle;
2218 struct dom_sid2 *domain_sid = NULL;
2219 uint32_t access_mask = SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT;
2221 ZERO_STRUCT(connect_handle);
2222 ZERO_STRUCT(domain_handle);
2224 if (!r->out.buffer) {
2225 return WERR_INVALID_PARAM;
2228 switch (r->in.level) {
2230 access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
2231 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
2235 access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
2238 access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1;
2241 werr = WERR_UNKNOWN_LEVEL;
2245 werr = libnetapi_open_pipe(ctx, r->in.server_name,
2246 &ndr_table_samr.syntax_id,
2249 if (!W_ERROR_IS_OK(werr)) {
2253 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2254 SAMR_ACCESS_ENUM_DOMAINS |
2255 SAMR_ACCESS_LOOKUP_DOMAIN,
2260 if (!W_ERROR_IS_OK(werr)) {
2267 /* 3: 12 (DomainInfo2) */
2269 status = query_USER_MODALS_INFO_to_buffer(ctx,
2275 if (!NT_STATUS_IS_OK(status)) {
2276 werr = ntstatus_to_werror(status);
2285 if (ctx->disable_policy_handle_cache) {
2286 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2287 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2293 /****************************************************************
2294 ****************************************************************/
2296 WERROR NetUserModalsGet_l(struct libnetapi_ctx *ctx,
2297 struct NetUserModalsGet *r)
2299 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserModalsGet);
2302 /****************************************************************
2303 ****************************************************************/
2305 static NTSTATUS set_USER_MODALS_INFO_rpc(TALLOC_CTX *mem_ctx,
2306 struct rpc_pipe_client *pipe_cli,
2307 struct policy_handle *domain_handle,
2308 struct samr_DomInfo1 *info1,
2309 struct samr_DomInfo3 *info3,
2310 struct samr_DomInfo12 *info12)
2313 union samr_DomainInfo dom_info;
2317 ZERO_STRUCT(dom_info);
2319 dom_info.info1 = *info1;
2321 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2325 NT_STATUS_NOT_OK_RETURN(status);
2330 ZERO_STRUCT(dom_info);
2332 dom_info.info3 = *info3;
2334 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2339 NT_STATUS_NOT_OK_RETURN(status);
2344 ZERO_STRUCT(dom_info);
2346 dom_info.info12 = *info12;
2348 status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2353 NT_STATUS_NOT_OK_RETURN(status);
2356 return NT_STATUS_OK;
2359 /****************************************************************
2360 ****************************************************************/
2362 static NTSTATUS set_USER_MODALS_INFO_0_buffer(TALLOC_CTX *mem_ctx,
2363 struct rpc_pipe_client *pipe_cli,
2364 struct policy_handle *domain_handle,
2365 struct USER_MODALS_INFO_0 *info0)
2368 struct samr_DomInfo1 dom_info_1;
2369 struct samr_DomInfo3 dom_info_3;
2371 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2380 NT_STATUS_NOT_OK_RETURN(status);
2382 dom_info_1.min_password_length =
2383 info0->usrmod0_min_passwd_len;
2384 dom_info_1.password_history_length =
2385 info0->usrmod0_password_hist_len;
2387 unix_to_nt_time_abs((NTTIME *)&dom_info_1.max_password_age,
2388 info0->usrmod0_max_passwd_age);
2389 unix_to_nt_time_abs((NTTIME *)&dom_info_1.min_password_age,
2390 info0->usrmod0_min_passwd_age);
2392 unix_to_nt_time_abs(&dom_info_3.force_logoff_time,
2393 info0->usrmod0_force_logoff);
2395 return set_USER_MODALS_INFO_rpc(mem_ctx,
2403 /****************************************************************
2404 ****************************************************************/
2406 static NTSTATUS set_USER_MODALS_INFO_3_buffer(TALLOC_CTX *mem_ctx,
2407 struct rpc_pipe_client *pipe_cli,
2408 struct policy_handle *domain_handle,
2409 struct USER_MODALS_INFO_3 *info3)
2412 struct samr_DomInfo12 dom_info_12;
2414 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2423 NT_STATUS_NOT_OK_RETURN(status);
2425 unix_to_nt_time_abs((NTTIME *)&dom_info_12.lockout_duration,
2426 info3->usrmod3_lockout_duration);
2427 unix_to_nt_time_abs((NTTIME *)&dom_info_12.lockout_window,
2428 info3->usrmod3_lockout_observation_window);
2429 dom_info_12.lockout_threshold = info3->usrmod3_lockout_threshold;
2431 return set_USER_MODALS_INFO_rpc(mem_ctx,
2439 /****************************************************************
2440 ****************************************************************/
2442 static NTSTATUS set_USER_MODALS_INFO_1001_buffer(TALLOC_CTX *mem_ctx,
2443 struct rpc_pipe_client *pipe_cli,
2444 struct policy_handle *domain_handle,
2445 struct USER_MODALS_INFO_1001 *info1001)
2448 struct samr_DomInfo1 dom_info_1;
2450 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2459 NT_STATUS_NOT_OK_RETURN(status);
2461 dom_info_1.min_password_length =
2462 info1001->usrmod1001_min_passwd_len;
2464 return set_USER_MODALS_INFO_rpc(mem_ctx,
2472 /****************************************************************
2473 ****************************************************************/
2475 static NTSTATUS set_USER_MODALS_INFO_1002_buffer(TALLOC_CTX *mem_ctx,
2476 struct rpc_pipe_client *pipe_cli,
2477 struct policy_handle *domain_handle,
2478 struct USER_MODALS_INFO_1002 *info1002)
2481 struct samr_DomInfo1 dom_info_1;
2483 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2492 NT_STATUS_NOT_OK_RETURN(status);
2494 unix_to_nt_time_abs((NTTIME *)&dom_info_1.max_password_age,
2495 info1002->usrmod1002_max_passwd_age);
2497 return set_USER_MODALS_INFO_rpc(mem_ctx,
2505 /****************************************************************
2506 ****************************************************************/
2508 static NTSTATUS set_USER_MODALS_INFO_1003_buffer(TALLOC_CTX *mem_ctx,
2509 struct rpc_pipe_client *pipe_cli,
2510 struct policy_handle *domain_handle,
2511 struct USER_MODALS_INFO_1003 *info1003)
2514 struct samr_DomInfo1 dom_info_1;
2516 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2525 NT_STATUS_NOT_OK_RETURN(status);
2527 unix_to_nt_time_abs((NTTIME *)&dom_info_1.min_password_age,
2528 info1003->usrmod1003_min_passwd_age);
2530 return set_USER_MODALS_INFO_rpc(mem_ctx,
2538 /****************************************************************
2539 ****************************************************************/
2541 static NTSTATUS set_USER_MODALS_INFO_1004_buffer(TALLOC_CTX *mem_ctx,
2542 struct rpc_pipe_client *pipe_cli,
2543 struct policy_handle *domain_handle,
2544 struct USER_MODALS_INFO_1004 *info1004)
2547 struct samr_DomInfo3 dom_info_3;
2549 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2558 NT_STATUS_NOT_OK_RETURN(status);
2560 unix_to_nt_time_abs(&dom_info_3.force_logoff_time,
2561 info1004->usrmod1004_force_logoff);
2563 return set_USER_MODALS_INFO_rpc(mem_ctx,
2571 /****************************************************************
2572 ****************************************************************/
2574 static NTSTATUS set_USER_MODALS_INFO_1005_buffer(TALLOC_CTX *mem_ctx,
2575 struct rpc_pipe_client *pipe_cli,
2576 struct policy_handle *domain_handle,
2577 struct USER_MODALS_INFO_1005 *info1005)
2580 struct samr_DomInfo1 dom_info_1;
2582 status = query_USER_MODALS_INFO_rpc(mem_ctx,
2591 NT_STATUS_NOT_OK_RETURN(status);
2593 dom_info_1.password_history_length =
2594 info1005->usrmod1005_password_hist_len;
2596 return set_USER_MODALS_INFO_rpc(mem_ctx,
2604 /****************************************************************
2605 ****************************************************************/
2607 static NTSTATUS set_USER_MODALS_INFO_buffer(TALLOC_CTX *mem_ctx,
2608 struct rpc_pipe_client *pipe_cli,
2610 struct policy_handle *domain_handle,
2611 struct dom_sid *domain_sid,
2614 struct USER_MODALS_INFO_0 *info0;
2615 struct USER_MODALS_INFO_3 *info3;
2616 struct USER_MODALS_INFO_1001 *info1001;
2617 struct USER_MODALS_INFO_1002 *info1002;
2618 struct USER_MODALS_INFO_1003 *info1003;
2619 struct USER_MODALS_INFO_1004 *info1004;
2620 struct USER_MODALS_INFO_1005 *info1005;
2623 return ERROR_INSUFFICIENT_BUFFER;
2628 info0 = (struct USER_MODALS_INFO_0 *)buffer;
2629 return set_USER_MODALS_INFO_0_buffer(mem_ctx,
2634 info3 = (struct USER_MODALS_INFO_3 *)buffer;
2635 return set_USER_MODALS_INFO_3_buffer(mem_ctx,
2640 info1001 = (struct USER_MODALS_INFO_1001 *)buffer;
2641 return set_USER_MODALS_INFO_1001_buffer(mem_ctx,
2646 info1002 = (struct USER_MODALS_INFO_1002 *)buffer;
2647 return set_USER_MODALS_INFO_1002_buffer(mem_ctx,
2652 info1003 = (struct USER_MODALS_INFO_1003 *)buffer;
2653 return set_USER_MODALS_INFO_1003_buffer(mem_ctx,
2658 info1004 = (struct USER_MODALS_INFO_1004 *)buffer;
2659 return set_USER_MODALS_INFO_1004_buffer(mem_ctx,
2664 info1005 = (struct USER_MODALS_INFO_1005 *)buffer;
2665 return set_USER_MODALS_INFO_1005_buffer(mem_ctx,
2674 return NT_STATUS_OK;
2677 /****************************************************************
2678 ****************************************************************/
2680 WERROR NetUserModalsSet_r(struct libnetapi_ctx *ctx,
2681 struct NetUserModalsSet *r)
2683 struct cli_state *cli = NULL;
2684 struct rpc_pipe_client *pipe_cli = NULL;
2688 struct policy_handle connect_handle, domain_handle;
2689 struct dom_sid2 *domain_sid = NULL;
2690 uint32_t access_mask = SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT;
2692 ZERO_STRUCT(connect_handle);
2693 ZERO_STRUCT(domain_handle);
2695 if (!r->in.buffer) {
2696 return WERR_INVALID_PARAM;
2699 switch (r->in.level) {
2701 access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
2702 SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
2703 SAMR_DOMAIN_ACCESS_SET_INFO_1 |
2704 SAMR_DOMAIN_ACCESS_SET_INFO_2;
2711 access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
2712 SAMR_DOMAIN_ACCESS_SET_INFO_1;
2715 access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
2716 SAMR_DOMAIN_ACCESS_SET_INFO_2;
2722 werr = WERR_NOT_SUPPORTED;
2725 werr = WERR_UNKNOWN_LEVEL;
2729 werr = libnetapi_open_pipe(ctx, r->in.server_name,
2730 &ndr_table_samr.syntax_id,
2733 if (!W_ERROR_IS_OK(werr)) {
2737 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2738 SAMR_ACCESS_ENUM_DOMAINS |
2739 SAMR_ACCESS_LOOKUP_DOMAIN,
2744 if (!W_ERROR_IS_OK(werr)) {
2748 status = set_USER_MODALS_INFO_buffer(ctx,
2754 if (!NT_STATUS_IS_OK(status)) {
2755 werr = ntstatus_to_werror(status);
2764 if (ctx->disable_policy_handle_cache) {
2765 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2766 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2772 /****************************************************************
2773 ****************************************************************/
2775 WERROR NetUserModalsSet_l(struct libnetapi_ctx *ctx,
2776 struct NetUserModalsSet *r)
2778 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserModalsSet);
2781 /****************************************************************
2782 ****************************************************************/
2784 NTSTATUS add_GROUP_USERS_INFO_X_buffer(TALLOC_CTX *mem_ctx,
2786 const char *group_name,
2787 uint32_t attributes,
2789 uint32_t *num_entries)
2791 struct GROUP_USERS_INFO_0 u0;
2792 struct GROUP_USERS_INFO_1 u1;
2797 u0.grui0_name = talloc_strdup(mem_ctx, group_name);
2798 NT_STATUS_HAVE_NO_MEMORY(u0.grui0_name);
2800 u0.grui0_name = NULL;
2803 ADD_TO_ARRAY(mem_ctx, struct GROUP_USERS_INFO_0, u0,
2804 (struct GROUP_USERS_INFO_0 **)buffer, num_entries);
2808 u1.grui1_name = talloc_strdup(mem_ctx, group_name);
2809 NT_STATUS_HAVE_NO_MEMORY(u1.grui1_name);
2811 u1.grui1_name = NULL;
2814 u1.grui1_attributes = attributes;
2816 ADD_TO_ARRAY(mem_ctx, struct GROUP_USERS_INFO_1, u1,
2817 (struct GROUP_USERS_INFO_1 **)buffer, num_entries);
2820 return NT_STATUS_INVALID_INFO_CLASS;
2823 return NT_STATUS_OK;
2826 /****************************************************************
2827 ****************************************************************/
2829 WERROR NetUserGetGroups_r(struct libnetapi_ctx *ctx,
2830 struct NetUserGetGroups *r)
2832 struct cli_state *cli = NULL;
2833 struct rpc_pipe_client *pipe_cli = NULL;
2834 struct policy_handle connect_handle, domain_handle, user_handle;
2835 struct lsa_String lsa_account_name;
2836 struct dom_sid2 *domain_sid = NULL;
2837 struct samr_Ids user_rids, name_types;
2838 struct samr_RidWithAttributeArray *rid_array = NULL;
2839 struct lsa_Strings names;
2840 struct samr_Ids types;
2841 uint32_t *rids = NULL;
2844 uint32_t entries_read = 0;
2846 NTSTATUS status = NT_STATUS_OK;
2849 ZERO_STRUCT(connect_handle);
2850 ZERO_STRUCT(domain_handle);
2852 if (!r->out.buffer) {
2853 return WERR_INVALID_PARAM;
2856 *r->out.buffer = NULL;
2857 *r->out.entries_read = 0;
2858 *r->out.total_entries = 0;
2860 switch (r->in.level) {
2865 return WERR_UNKNOWN_LEVEL;
2868 werr = libnetapi_open_pipe(ctx, r->in.server_name,
2869 &ndr_table_samr.syntax_id,
2872 if (!W_ERROR_IS_OK(werr)) {
2876 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2877 SAMR_ACCESS_ENUM_DOMAINS |
2878 SAMR_ACCESS_LOOKUP_DOMAIN,
2879 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
2883 if (!W_ERROR_IS_OK(werr)) {
2887 init_lsa_String(&lsa_account_name, r->in.user_name);
2889 status = rpccli_samr_LookupNames(pipe_cli, ctx,
2895 if (!NT_STATUS_IS_OK(status)) {
2896 werr = ntstatus_to_werror(status);
2900 status = rpccli_samr_OpenUser(pipe_cli, ctx,
2902 SAMR_USER_ACCESS_GET_GROUPS,
2905 if (!NT_STATUS_IS_OK(status)) {
2906 werr = ntstatus_to_werror(status);
2910 status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
2913 if (!NT_STATUS_IS_OK(status)) {
2914 werr = ntstatus_to_werror(status);
2918 rids = talloc_array(ctx, uint32_t, rid_array->count);
2924 for (i=0; i < rid_array->count; i++) {
2925 rids[i] = rid_array->rids[i].rid;
2928 status = rpccli_samr_LookupRids(pipe_cli, ctx,
2934 if (!NT_STATUS_IS_OK(status) &&
2935 !NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
2936 werr = ntstatus_to_werror(status);
2940 for (i=0; i < names.count; i++) {
2941 status = add_GROUP_USERS_INFO_X_buffer(ctx,
2943 names.names[i].string,
2944 rid_array->rids[i].attributes,
2947 if (!NT_STATUS_IS_OK(status)) {
2948 werr = ntstatus_to_werror(status);
2953 *r->out.entries_read = entries_read;
2954 *r->out.total_entries = entries_read;
2961 if (ctx->disable_policy_handle_cache) {
2962 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2963 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2969 /****************************************************************
2970 ****************************************************************/
2972 WERROR NetUserGetGroups_l(struct libnetapi_ctx *ctx,
2973 struct NetUserGetGroups *r)
2975 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetGroups);
2978 /****************************************************************
2979 ****************************************************************/
2981 WERROR NetUserSetGroups_r(struct libnetapi_ctx *ctx,
2982 struct NetUserSetGroups *r)
2984 struct cli_state *cli = NULL;
2985 struct rpc_pipe_client *pipe_cli = NULL;
2986 struct policy_handle connect_handle, domain_handle, user_handle, group_handle;
2987 struct lsa_String lsa_account_name;
2988 struct dom_sid2 *domain_sid = NULL;
2989 struct samr_Ids user_rids, name_types;
2990 struct samr_Ids group_rids;
2991 struct samr_RidWithAttributeArray *rid_array = NULL;
2992 struct lsa_String *lsa_names = NULL;
2994 uint32_t *add_rids = NULL;
2995 uint32_t *del_rids = NULL;
2996 size_t num_add_rids = 0;
2997 size_t num_del_rids = 0;
2999 uint32_t *member_rids = NULL;
3000 size_t num_member_rids = 0;
3002 struct GROUP_USERS_INFO_0 *i0 = NULL;
3003 struct GROUP_USERS_INFO_1 *i1 = NULL;
3007 NTSTATUS status = NT_STATUS_OK;
3010 ZERO_STRUCT(connect_handle);
3011 ZERO_STRUCT(domain_handle);
3013 if (!r->in.buffer) {
3014 return WERR_INVALID_PARAM;
3017 switch (r->in.level) {
3022 return WERR_UNKNOWN_LEVEL;
3025 werr = libnetapi_open_pipe(ctx, r->in.server_name,
3026 &ndr_table_samr.syntax_id,
3029 if (!W_ERROR_IS_OK(werr)) {
3033 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
3034 SAMR_ACCESS_ENUM_DOMAINS |
3035 SAMR_ACCESS_LOOKUP_DOMAIN,
3036 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
3040 if (!W_ERROR_IS_OK(werr)) {
3044 init_lsa_String(&lsa_account_name, r->in.user_name);
3046 status = rpccli_samr_LookupNames(pipe_cli, ctx,
3052 if (!NT_STATUS_IS_OK(status)) {
3053 werr = ntstatus_to_werror(status);
3057 status = rpccli_samr_OpenUser(pipe_cli, ctx,
3059 SAMR_USER_ACCESS_GET_GROUPS,
3062 if (!NT_STATUS_IS_OK(status)) {
3063 werr = ntstatus_to_werror(status);
3067 switch (r->in.level) {
3069 i0 = (struct GROUP_USERS_INFO_0 *)r->in.buffer;
3072 i1 = (struct GROUP_USERS_INFO_1 *)r->in.buffer;
3076 lsa_names = talloc_array(ctx, struct lsa_String, r->in.num_entries);
3082 for (i=0; i < r->in.num_entries; i++) {
3084 switch (r->in.level) {
3086 init_lsa_String(&lsa_names[i], i0->grui0_name);
3090 init_lsa_String(&lsa_names[i], i1->grui1_name);
3096 status = rpccli_samr_LookupNames(pipe_cli, ctx,
3102 if (!NT_STATUS_IS_OK(status)) {
3103 werr = ntstatus_to_werror(status);
3107 member_rids = group_rids.ids;
3108 num_member_rids = group_rids.count;
3110 status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
3113 if (!NT_STATUS_IS_OK(status)) {
3114 werr = ntstatus_to_werror(status);
3120 for (i=0; i < r->in.num_entries; i++) {
3121 bool already_member = false;
3122 for (k=0; k < rid_array->count; k++) {
3123 if (member_rids[i] == rid_array->rids[k].rid) {
3124 already_member = true;
3128 if (!already_member) {
3129 if (!add_rid_to_array_unique(ctx,
3131 &add_rids, &num_add_rids)) {
3132 werr = WERR_GENERAL_FAILURE;
3140 for (k=0; k < rid_array->count; k++) {
3141 bool keep_member = false;
3142 for (i=0; i < r->in.num_entries; i++) {
3143 if (member_rids[i] == rid_array->rids[k].rid) {
3149 if (!add_rid_to_array_unique(ctx,
3150 rid_array->rids[k].rid,
3151 &del_rids, &num_del_rids)) {
3152 werr = WERR_GENERAL_FAILURE;
3160 for (i=0; i < num_add_rids; i++) {
3161 status = rpccli_samr_OpenGroup(pipe_cli, ctx,
3163 SAMR_GROUP_ACCESS_ADD_MEMBER,
3166 if (!NT_STATUS_IS_OK(status)) {
3167 werr = ntstatus_to_werror(status);
3171 status = rpccli_samr_AddGroupMember(pipe_cli, ctx,
3175 if (!NT_STATUS_IS_OK(status)) {
3176 werr = ntstatus_to_werror(status);
3180 if (is_valid_policy_hnd(&group_handle)) {
3181 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3187 for (i=0; i < num_del_rids; i++) {
3188 status = rpccli_samr_OpenGroup(pipe_cli, ctx,
3190 SAMR_GROUP_ACCESS_REMOVE_MEMBER,
3193 if (!NT_STATUS_IS_OK(status)) {
3194 werr = ntstatus_to_werror(status);
3198 status = rpccli_samr_DeleteGroupMember(pipe_cli, ctx,
3201 if (!NT_STATUS_IS_OK(status)) {
3202 werr = ntstatus_to_werror(status);
3206 if (is_valid_policy_hnd(&group_handle)) {
3207 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3218 if (is_valid_policy_hnd(&group_handle)) {
3219 rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3222 if (ctx->disable_policy_handle_cache) {
3223 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
3224 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
3230 /****************************************************************
3231 ****************************************************************/
3233 WERROR NetUserSetGroups_l(struct libnetapi_ctx *ctx,
3234 struct NetUserSetGroups *r)
3236 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserSetGroups);
3239 /****************************************************************
3240 ****************************************************************/
3242 static NTSTATUS add_LOCALGROUP_USERS_INFO_X_buffer(TALLOC_CTX *mem_ctx,
3244 const char *group_name,
3246 uint32_t *num_entries)
3248 struct LOCALGROUP_USERS_INFO_0 u0;
3252 u0.lgrui0_name = talloc_strdup(mem_ctx, group_name);
3253 NT_STATUS_HAVE_NO_MEMORY(u0.lgrui0_name);
3255 ADD_TO_ARRAY(mem_ctx, struct LOCALGROUP_USERS_INFO_0, u0,
3256 (struct LOCALGROUP_USERS_INFO_0 **)buffer, num_entries);
3259 return NT_STATUS_INVALID_INFO_CLASS;
3262 return NT_STATUS_OK;
3265 /****************************************************************
3266 ****************************************************************/
3268 WERROR NetUserGetLocalGroups_r(struct libnetapi_ctx *ctx,
3269 struct NetUserGetLocalGroups *r)
3271 struct cli_state *cli = NULL;
3272 struct rpc_pipe_client *pipe_cli = NULL;
3273 struct policy_handle connect_handle, domain_handle, user_handle,
3275 struct lsa_String lsa_account_name;
3276 struct dom_sid2 *domain_sid = NULL;
3277 struct samr_Ids user_rids, name_types;
3278 struct samr_RidWithAttributeArray *rid_array = NULL;
3279 struct lsa_Strings names;
3280 struct samr_Ids types;
3281 uint32_t *rids = NULL;
3282 size_t num_rids = 0;
3283 struct dom_sid user_sid;
3284 struct lsa_SidArray sid_array;
3285 struct samr_Ids domain_rids;
3286 struct samr_Ids builtin_rids;
3289 uint32_t entries_read = 0;
3291 NTSTATUS status = NT_STATUS_OK;
3294 ZERO_STRUCT(connect_handle);
3295 ZERO_STRUCT(domain_handle);
3297 if (!r->out.buffer) {
3298 return WERR_INVALID_PARAM;
3301 *r->out.buffer = NULL;
3302 *r->out.entries_read = 0;
3303 *r->out.total_entries = 0;
3305 switch (r->in.level) {
3310 return WERR_UNKNOWN_LEVEL;
3313 werr = libnetapi_open_pipe(ctx, r->in.server_name,
3314 &ndr_table_samr.syntax_id,
3317 if (!W_ERROR_IS_OK(werr)) {
3321 werr = libnetapi_samr_open_domain(ctx, pipe_cli,
3322 SAMR_ACCESS_ENUM_DOMAINS |
3323 SAMR_ACCESS_LOOKUP_DOMAIN,
3324 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
3325 SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
3329 if (!W_ERROR_IS_OK(werr)) {
3333 werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
3334 SAMR_ACCESS_ENUM_DOMAINS |
3335 SAMR_ACCESS_LOOKUP_DOMAIN,
3336 SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
3337 SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
3340 if (!W_ERROR_IS_OK(werr)) {
3344 init_lsa_String(&lsa_account_name, r->in.user_name);
3346 status = rpccli_samr_LookupNames(pipe_cli, ctx,
3352 if (!NT_STATUS_IS_OK(status)) {
3353 werr = ntstatus_to_werror(status);
3357 status = rpccli_samr_OpenUser(pipe_cli, ctx,
3359 SAMR_USER_ACCESS_GET_GROUPS,
3362 if (!NT_STATUS_IS_OK(status)) {
3363 werr = ntstatus_to_werror(status);
3367 status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
3370 if (!NT_STATUS_IS_OK(status)) {
3371 werr = ntstatus_to_werror(status);
3375 if (!sid_compose(&user_sid, domain_sid, user_rids.ids[0])) {
3380 sid_array.num_sids = rid_array->count + 1;
3381 sid_array.sids = TALLOC_ARRAY(ctx, struct lsa_SidPtr, sid_array.num_sids);
3382 if (!sid_array.sids) {
3387 sid_array.sids[0].sid = sid_dup_talloc(ctx, &user_sid);
3388 if (!sid_array.sids[0].sid) {
3393 for (i=0; i < rid_array->count; i++) {
3396 if (!sid_compose(&sid, domain_sid, rid_array->rids[i].rid)) {
3401 sid_array.sids[i+1].sid = sid_dup_talloc(ctx, &sid);
3402 if (!sid_array.sids[i+1].sid) {
3408 status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
3412 if (!NT_STATUS_IS_OK(status)) {
3413 werr = ntstatus_to_werror(status);
3417 for (i=0; i < domain_rids.count; i++) {
3418 if (!add_rid_to_array_unique(ctx, domain_rids.ids[i],
3419 &rids, &num_rids)) {
3425 status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
3429 if (!NT_STATUS_IS_OK(status)) {
3430 werr = ntstatus_to_werror(status);
3434 for (i=0; i < builtin_rids.count; i++) {
3435 if (!add_rid_to_array_unique(ctx, builtin_rids.ids[i],
3436 &rids, &num_rids)) {
3442 status = rpccli_samr_LookupRids(pipe_cli, ctx,
3448 if (!NT_STATUS_IS_OK(status)) {
3449 werr = ntstatus_to_werror(status);
3453 for (i=0; i < names.count; i++) {
3454 status = add_LOCALGROUP_USERS_INFO_X_buffer(ctx,
3456 names.names[i].string,
3459 if (!NT_STATUS_IS_OK(status)) {
3460 werr = ntstatus_to_werror(status);
3465 *r->out.entries_read = entries_read;
3466 *r->out.total_entries = entries_read;
3473 if (ctx->disable_policy_handle_cache) {
3474 libnetapi_samr_close_domain_handle(ctx, &domain_handle);
3475 libnetapi_samr_close_connect_handle(ctx, &connect_handle);
3481 /****************************************************************
3482 ****************************************************************/
3484 WERROR NetUserGetLocalGroups_l(struct libnetapi_ctx *ctx,
3485 struct NetUserGetLocalGroups *r)
3487 LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetLocalGroups);