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 */
95
info21->last_logon = 0;
96
info21->last_logoff = 0;
97
info21->last_password_change = 0;
98
info21->acct_expiry = 0;
99
info21->allow_password_change = 0;
100
info21->force_password_change = 0;
101
info21->account_name.string = infoX->usriX_name;
102
info21->full_name.string = infoX->usriX_full_name;
103
info21->home_directory.string = infoX->usriX_home_dir;
104
info21->home_drive.string = infoX->usriX_home_dir_drive;
105
info21->logon_script.string = infoX->usriX_script_path;
106
info21->profile_path.string = infoX->usriX_profile;
107
info21->description.string = infoX->usriX_comment;
108
info21->workstations.string = infoX->usriX_workstations;
109
info21->comment.string = infoX->usriX_usr_comment;
110
info21->parameters = zero_parameters;
111
info21->lm_owf_password = zero_parameters;
112
info21->nt_owf_password = zero_parameters;
113
info21->unknown3.string = NULL;
114
info21->buf_count = 0;
115
info21->buffer = NULL;
116
info21->rid = infoX->usriX_user_id;
117
info21->primary_gid = infoX->usriX_primary_group_id;
118
info21->acct_flags = infoX->usriX_flags;
119
info21->fields_present = fields_present;
120
info21->logon_hours = zero_logon_hours;
121
info21->bad_password_count = infoX->usriX_bad_pw_count;
122
info21->logon_count = infoX->usriX_num_logons;
123
info21->country_code = infoX->usriX_country_code;
124
info21->code_page = infoX->usriX_code_page;
125
info21->lm_password_set = 0;
126
info21->nt_password_set = 0;
127
info21->password_expired = infoX->usriX_password_expired;
128
info21->unknown4 = 0;
131
/****************************************************************
132
****************************************************************/
134
static NTSTATUS construct_USER_INFO_X(uint32_t level,
136
struct USER_INFO_X *uX)
138
struct USER_INFO_0 *u0 = NULL;
139
struct USER_INFO_1 *u1 = NULL;
140
struct USER_INFO_2 *u2 = NULL;
141
struct USER_INFO_3 *u3 = NULL;
142
struct USER_INFO_1003 *u1003 = NULL;
143
struct USER_INFO_1006 *u1006 = NULL;
144
struct USER_INFO_1007 *u1007 = NULL;
145
struct USER_INFO_1009 *u1009 = NULL;
146
struct USER_INFO_1011 *u1011 = NULL;
147
struct USER_INFO_1012 *u1012 = NULL;
148
struct USER_INFO_1014 *u1014 = NULL;
149
struct USER_INFO_1024 *u1024 = NULL;
150
struct USER_INFO_1051 *u1051 = NULL;
151
struct USER_INFO_1052 *u1052 = NULL;
152
struct USER_INFO_1053 *u1053 = NULL;
154
if (!buffer || !uX) {
155
return NT_STATUS_INVALID_PARAMETER;
162
u0 = (struct USER_INFO_0 *)buffer;
163
uX->usriX_name = u0->usri0_name;
166
u1 = (struct USER_INFO_1 *)buffer;
167
uX->usriX_name = u1->usri1_name;
168
uX->usriX_password = u1->usri1_password;
169
uX->usriX_password_age = u1->usri1_password_age;
170
uX->usriX_priv = u1->usri1_priv;
171
uX->usriX_home_dir = u1->usri1_home_dir;
172
uX->usriX_comment = u1->usri1_comment;
173
uX->usriX_flags = u1->usri1_flags;
174
uX->usriX_script_path = u1->usri1_script_path;
177
u2 = (struct USER_INFO_2 *)buffer;
178
uX->usriX_name = u2->usri2_name;
179
uX->usriX_password = u2->usri2_password;
180
uX->usriX_password_age = u2->usri2_password_age;
181
uX->usriX_priv = u2->usri2_priv;
182
uX->usriX_home_dir = u2->usri2_home_dir;
183
uX->usriX_comment = u2->usri2_comment;
184
uX->usriX_flags = u2->usri2_flags;
185
uX->usriX_script_path = u2->usri2_script_path;
186
uX->usriX_auth_flags = u2->usri2_auth_flags;
187
uX->usriX_full_name = u2->usri2_full_name;
188
uX->usriX_usr_comment = u2->usri2_usr_comment;
189
uX->usriX_parms = u2->usri2_parms;
190
uX->usriX_workstations = u2->usri2_workstations;
191
uX->usriX_last_logon = u2->usri2_last_logon;
192
uX->usriX_last_logoff = u2->usri2_last_logoff;
193
uX->usriX_acct_expires = u2->usri2_acct_expires;
194
uX->usriX_max_storage = u2->usri2_max_storage;
195
uX->usriX_units_per_week= u2->usri2_units_per_week;
196
uX->usriX_logon_hours = u2->usri2_logon_hours;
197
uX->usriX_bad_pw_count = u2->usri2_bad_pw_count;
198
uX->usriX_num_logons = u2->usri2_num_logons;
199
uX->usriX_logon_server = u2->usri2_logon_server;
200
uX->usriX_country_code = u2->usri2_country_code;
201
uX->usriX_code_page = u2->usri2_code_page;
204
u3 = (struct USER_INFO_3 *)buffer;
205
uX->usriX_name = u3->usri3_name;
206
uX->usriX_password_age = u3->usri3_password_age;
207
uX->usriX_priv = u3->usri3_priv;
208
uX->usriX_home_dir = u3->usri3_home_dir;
209
uX->usriX_comment = u3->usri3_comment;
210
uX->usriX_flags = u3->usri3_flags;
211
uX->usriX_script_path = u3->usri3_script_path;
212
uX->usriX_auth_flags = u3->usri3_auth_flags;
213
uX->usriX_full_name = u3->usri3_full_name;
214
uX->usriX_usr_comment = u3->usri3_usr_comment;
215
uX->usriX_parms = u3->usri3_parms;
216
uX->usriX_workstations = u3->usri3_workstations;
217
uX->usriX_last_logon = u3->usri3_last_logon;
218
uX->usriX_last_logoff = u3->usri3_last_logoff;
219
uX->usriX_acct_expires = u3->usri3_acct_expires;
220
uX->usriX_max_storage = u3->usri3_max_storage;
221
uX->usriX_units_per_week= u3->usri3_units_per_week;
222
uX->usriX_logon_hours = u3->usri3_logon_hours;
223
uX->usriX_bad_pw_count = u3->usri3_bad_pw_count;
224
uX->usriX_num_logons = u3->usri3_num_logons;
225
uX->usriX_logon_server = u3->usri3_logon_server;
226
uX->usriX_country_code = u3->usri3_country_code;
227
uX->usriX_code_page = u3->usri3_code_page;
228
uX->usriX_user_id = u3->usri3_user_id;
229
uX->usriX_primary_group_id = u3->usri3_primary_group_id;
230
uX->usriX_profile = u3->usri3_profile;
231
uX->usriX_home_dir_drive = u3->usri3_home_dir_drive;
232
uX->usriX_password_expired = u3->usri3_password_expired;
235
u1003 = (struct USER_INFO_1003 *)buffer;
236
uX->usriX_password = u1003->usri1003_password;
239
u1006 = (struct USER_INFO_1006 *)buffer;
240
uX->usriX_home_dir = u1006->usri1006_home_dir;
243
u1007 = (struct USER_INFO_1007 *)buffer;
244
uX->usriX_comment = u1007->usri1007_comment;
247
u1009 = (struct USER_INFO_1009 *)buffer;
248
uX->usriX_script_path = u1009->usri1009_script_path;
251
u1011 = (struct USER_INFO_1011 *)buffer;
252
uX->usriX_full_name = u1011->usri1011_full_name;
255
u1012 = (struct USER_INFO_1012 *)buffer;
256
uX->usriX_usr_comment = u1012->usri1012_usr_comment;
259
u1014 = (struct USER_INFO_1014 *)buffer;
260
uX->usriX_workstations = u1014->usri1014_workstations;
263
u1024 = (struct USER_INFO_1024 *)buffer;
264
uX->usriX_country_code = u1024->usri1024_country_code;
267
u1051 = (struct USER_INFO_1051 *)buffer;
268
uX->usriX_primary_group_id = u1051->usri1051_primary_group_id;
271
u1052 = (struct USER_INFO_1052 *)buffer;
272
uX->usriX_profile = u1052->usri1052_profile;
275
u1053 = (struct USER_INFO_1053 *)buffer;
276
uX->usriX_home_dir_drive = u1053->usri1053_home_dir_drive;
280
return NT_STATUS_INVALID_INFO_CLASS;
286
/****************************************************************
287
****************************************************************/
289
static NTSTATUS set_user_info_USER_INFO_X(TALLOC_CTX *ctx,
290
struct rpc_pipe_client *pipe_cli,
291
DATA_BLOB *session_key,
292
struct policy_handle *user_handle,
293
struct USER_INFO_X *uX)
295
union samr_UserInfo user_info;
296
struct samr_UserInfo21 info21;
300
return NT_STATUS_INVALID_PARAMETER;
303
convert_USER_INFO_X_to_samr_user_info21(uX, &info21);
305
ZERO_STRUCT(user_info);
307
if (uX->usriX_password) {
309
user_info.info25.info = info21;
311
init_samr_CryptPasswordEx(uX->usriX_password,
313
&user_info.info25.password);
315
status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
320
if (NT_STATUS_EQUAL(status, NT_STATUS(DCERPC_FAULT_INVALID_TAG))) {
322
user_info.info23.info = info21;
324
init_samr_CryptPassword(uX->usriX_password,
326
&user_info.info23.password);
328
status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
335
user_info.info21 = info21;
337
status = rpccli_samr_SetUserInfo(pipe_cli, ctx,
346
/****************************************************************
347
****************************************************************/
349
WERROR NetUserAdd_r(struct libnetapi_ctx *ctx,
350
struct NetUserAdd *r)
352
struct rpc_pipe_client *pipe_cli = NULL;
355
struct policy_handle connect_handle, domain_handle, user_handle;
356
struct lsa_String lsa_account_name;
357
struct dom_sid2 *domain_sid = NULL;
358
union samr_UserInfo *user_info = NULL;
359
struct samr_PwInfo pw_info;
360
uint32_t access_granted = 0;
362
struct USER_INFO_X uX;
364
ZERO_STRUCT(connect_handle);
365
ZERO_STRUCT(domain_handle);
366
ZERO_STRUCT(user_handle);
369
return WERR_INVALID_PARAM;
372
switch (r->in.level) {
379
werr = WERR_NOT_SUPPORTED;
383
werr = libnetapi_open_pipe(ctx, r->in.server_name,
384
&ndr_table_samr.syntax_id,
386
if (!W_ERROR_IS_OK(werr)) {
390
status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
391
if (!NT_STATUS_IS_OK(status)) {
392
werr = ntstatus_to_werror(status);
396
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
397
SAMR_ACCESS_ENUM_DOMAINS |
398
SAMR_ACCESS_LOOKUP_DOMAIN,
399
SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
400
SAMR_DOMAIN_ACCESS_CREATE_USER |
401
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
405
if (!W_ERROR_IS_OK(werr)) {
409
init_lsa_String(&lsa_account_name, uX.usriX_name);
411
status = rpccli_samr_CreateUser2(pipe_cli, ctx,
417
SAMR_USER_ACCESS_SET_PASSWORD |
418
SAMR_USER_ACCESS_SET_ATTRIBUTES |
419
SAMR_USER_ACCESS_GET_ATTRIBUTES,
423
if (!NT_STATUS_IS_OK(status)) {
424
werr = ntstatus_to_werror(status);
428
status = rpccli_samr_QueryUserInfo(pipe_cli, ctx,
432
if (!NT_STATUS_IS_OK(status)) {
433
werr = ntstatus_to_werror(status);
437
if (!(user_info->info16.acct_flags & ACB_NORMAL)) {
438
werr = WERR_INVALID_PARAM;
442
status = rpccli_samr_GetUserPwInfo(pipe_cli, ctx,
445
if (!NT_STATUS_IS_OK(status)) {
446
werr = ntstatus_to_werror(status);
450
uX.usriX_flags |= ACB_NORMAL;
452
status = set_user_info_USER_INFO_X(ctx, pipe_cli,
453
&pipe_cli->auth->user_session_key,
456
if (!NT_STATUS_IS_OK(status)) {
457
werr = ntstatus_to_werror(status);
465
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 rpc_pipe_client *pipe_cli = NULL;
499
struct policy_handle connect_handle, builtin_handle, domain_handle, user_handle;
500
struct lsa_String lsa_account_name;
501
struct samr_Ids user_rids, name_types;
502
struct dom_sid2 *domain_sid = NULL;
503
struct dom_sid2 user_sid;
505
ZERO_STRUCT(connect_handle);
506
ZERO_STRUCT(builtin_handle);
507
ZERO_STRUCT(domain_handle);
508
ZERO_STRUCT(user_handle);
510
werr = libnetapi_open_pipe(ctx, r->in.server_name,
511
&ndr_table_samr.syntax_id,
514
if (!W_ERROR_IS_OK(werr)) {
518
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
519
SAMR_ACCESS_ENUM_DOMAINS |
520
SAMR_ACCESS_LOOKUP_DOMAIN,
521
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
525
if (!W_ERROR_IS_OK(werr)) {
529
status = rpccli_samr_OpenDomain(pipe_cli, ctx,
531
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
532
CONST_DISCARD(DOM_SID *, &global_sid_Builtin),
534
if (!NT_STATUS_IS_OK(status)) {
535
werr = ntstatus_to_werror(status);
539
init_lsa_String(&lsa_account_name, r->in.user_name);
541
status = rpccli_samr_LookupNames(pipe_cli, ctx,
547
if (!NT_STATUS_IS_OK(status)) {
548
werr = ntstatus_to_werror(status);
552
status = rpccli_samr_OpenUser(pipe_cli, ctx,
557
if (!NT_STATUS_IS_OK(status)) {
558
werr = ntstatus_to_werror(status);
562
sid_compose(&user_sid, domain_sid, user_rids.ids[0]);
564
status = rpccli_samr_RemoveMemberFromForeignDomain(pipe_cli, ctx,
567
if (!NT_STATUS_IS_OK(status)) {
568
werr = ntstatus_to_werror(status);
572
status = rpccli_samr_DeleteUser(pipe_cli, ctx,
574
if (!NT_STATUS_IS_OK(status)) {
575
werr = ntstatus_to_werror(status);
582
if (is_valid_policy_hnd(&user_handle)) {
583
rpccli_samr_Close(pipe_cli, ctx, &user_handle);
586
if (ctx->disable_policy_handle_cache) {
587
libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
588
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
589
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
595
/****************************************************************
596
****************************************************************/
598
WERROR NetUserDel_l(struct libnetapi_ctx *ctx,
599
struct NetUserDel *r)
601
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserDel);
604
/****************************************************************
605
****************************************************************/
607
static NTSTATUS libnetapi_samr_lookup_user(TALLOC_CTX *mem_ctx,
608
struct rpc_pipe_client *pipe_cli,
609
struct policy_handle *domain_handle,
610
struct policy_handle *builtin_handle,
611
const char *user_name,
612
const struct dom_sid *domain_sid,
615
struct samr_UserInfo21 **info21,
616
struct sec_desc_buf **sec_desc,
617
uint32_t *auth_flag_p)
621
struct policy_handle user_handle;
622
union samr_UserInfo *user_info = NULL;
623
struct samr_RidWithAttributeArray *rid_array = NULL;
624
uint32_t access_mask = SEC_STD_READ_CONTROL |
625
SAMR_USER_ACCESS_GET_ATTRIBUTES |
626
SAMR_USER_ACCESS_GET_NAME_ETC;
628
ZERO_STRUCT(user_handle);
634
access_mask |= SAMR_USER_ACCESS_GET_LOGONINFO |
635
SAMR_USER_ACCESS_GET_GROUPS;
641
access_mask |= SAMR_USER_ACCESS_GET_LOGONINFO |
642
SAMR_USER_ACCESS_GET_GROUPS |
643
SAMR_USER_ACCESS_GET_LOCALE;
650
return NT_STATUS_INVALID_LEVEL;
657
status = rpccli_samr_OpenUser(pipe_cli, mem_ctx,
662
if (!NT_STATUS_IS_OK(status)) {
666
status = rpccli_samr_QueryUserInfo(pipe_cli, mem_ctx,
670
if (!NT_STATUS_IS_OK(status)) {
674
status = rpccli_samr_QuerySecurity(pipe_cli, mem_ctx,
678
if (!NT_STATUS_IS_OK(status)) {
682
if (access_mask & SAMR_USER_ACCESS_GET_GROUPS) {
684
struct lsa_SidArray sid_array;
685
struct samr_Ids alias_rids;
687
uint32_t auth_flag = 0;
690
status = rpccli_samr_GetGroupsForUser(pipe_cli, mem_ctx,
693
if (!NT_STATUS_IS_OK(status)) {
697
sid_array.num_sids = rid_array->count + 1;
698
sid_array.sids = talloc_array(mem_ctx, struct lsa_SidPtr,
700
NT_STATUS_HAVE_NO_MEMORY(sid_array.sids);
702
for (i=0; i<rid_array->count; i++) {
703
sid_compose(&sid, domain_sid, rid_array->rids[i].rid);
704
sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
705
NT_STATUS_HAVE_NO_MEMORY(sid_array.sids[i].sid);
708
sid_compose(&sid, domain_sid, rid);
709
sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
710
NT_STATUS_HAVE_NO_MEMORY(sid_array.sids[i].sid);
712
status = rpccli_samr_GetAliasMembership(pipe_cli, mem_ctx,
716
if (!NT_STATUS_IS_OK(status)) {
720
for (i=0; i<alias_rids.count; i++) {
721
switch (alias_rids.ids[i]) {
722
case 550: /* Print Operators */
723
auth_flag |= AF_OP_PRINT;
725
case 549: /* Server Operators */
726
auth_flag |= AF_OP_SERVER;
728
case 548: /* Account Operators */
729
auth_flag |= AF_OP_ACCOUNTS;
737
*auth_flag_p = auth_flag;
741
*info21 = &user_info->info21;
744
if (is_valid_policy_hnd(&user_handle)) {
745
rpccli_samr_Close(pipe_cli, mem_ctx, &user_handle);
751
/****************************************************************
752
****************************************************************/
754
static uint32_t samr_rid_to_priv_level(uint32_t rid)
757
case DOMAIN_RID_ADMINISTRATOR:
758
return USER_PRIV_ADMIN;
759
case DOMAIN_RID_GUEST:
760
return USER_PRIV_GUEST;
762
return USER_PRIV_USER;
766
/****************************************************************
767
****************************************************************/
769
static uint32_t samr_acb_flags_to_netapi_flags(uint32_t acb)
771
uint32_t fl = UF_SCRIPT; /* god knows why */
773
fl |= ads_acb2uf(acb);
778
/****************************************************************
779
****************************************************************/
781
static NTSTATUS info21_to_USER_INFO_1(TALLOC_CTX *mem_ctx,
782
const struct samr_UserInfo21 *i21,
783
struct USER_INFO_1 *i)
786
i->usri1_name = talloc_strdup(mem_ctx, i21->account_name.string);
787
NT_STATUS_HAVE_NO_MEMORY(i->usri1_name);
788
i->usri1_password = NULL;
789
i->usri1_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
790
i->usri1_priv = samr_rid_to_priv_level(i21->rid);
791
i->usri1_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
792
i->usri1_comment = talloc_strdup(mem_ctx, i21->description.string);
793
i->usri1_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
794
i->usri1_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
799
/****************************************************************
800
****************************************************************/
802
static NTSTATUS info21_to_USER_INFO_2(TALLOC_CTX *mem_ctx,
803
const struct samr_UserInfo21 *i21,
805
struct USER_INFO_2 *i)
809
i->usri2_name = talloc_strdup(mem_ctx, i21->account_name.string);
810
NT_STATUS_HAVE_NO_MEMORY(i->usri2_name);
811
i->usri2_password = NULL;
812
i->usri2_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
813
i->usri2_priv = samr_rid_to_priv_level(i21->rid);
814
i->usri2_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
815
i->usri2_comment = talloc_strdup(mem_ctx, i21->description.string);
816
i->usri2_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
817
i->usri2_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
818
i->usri2_auth_flags = auth_flag;
819
i->usri2_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
820
i->usri2_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
821
i->usri2_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
822
i->usri2_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
823
i->usri2_last_logon = nt_time_to_unix(i21->last_logon);
824
i->usri2_last_logoff = nt_time_to_unix(i21->last_logoff);
825
i->usri2_acct_expires = nt_time_to_unix(i21->acct_expiry);
826
i->usri2_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
827
i->usri2_units_per_week = i21->logon_hours.units_per_week;
828
i->usri2_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
829
i->usri2_bad_pw_count = i21->bad_password_count;
830
i->usri2_num_logons = i21->logon_count;
831
i->usri2_logon_server = talloc_strdup(mem_ctx, "\\\\*");
832
i->usri2_country_code = i21->country_code;
833
i->usri2_code_page = i21->code_page;
838
/****************************************************************
839
****************************************************************/
841
static NTSTATUS info21_to_USER_INFO_3(TALLOC_CTX *mem_ctx,
842
const struct samr_UserInfo21 *i21,
844
struct USER_INFO_3 *i)
848
i->usri3_name = talloc_strdup(mem_ctx, i21->account_name.string);
849
NT_STATUS_HAVE_NO_MEMORY(i->usri3_name);
850
i->usri3_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
851
i->usri3_priv = samr_rid_to_priv_level(i21->rid);
852
i->usri3_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
853
i->usri3_comment = talloc_strdup(mem_ctx, i21->description.string);
854
i->usri3_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
855
i->usri3_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
856
i->usri3_auth_flags = auth_flag;
857
i->usri3_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
858
i->usri3_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
859
i->usri3_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
860
i->usri3_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
861
i->usri3_last_logon = nt_time_to_unix(i21->last_logon);
862
i->usri3_last_logoff = nt_time_to_unix(i21->last_logoff);
863
i->usri3_acct_expires = nt_time_to_unix(i21->acct_expiry);
864
i->usri3_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
865
i->usri3_units_per_week = i21->logon_hours.units_per_week;
866
i->usri3_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
867
i->usri3_bad_pw_count = i21->bad_password_count;
868
i->usri3_num_logons = i21->logon_count;
869
i->usri3_logon_server = talloc_strdup(mem_ctx, "\\\\*");
870
i->usri3_country_code = i21->country_code;
871
i->usri3_code_page = i21->code_page;
872
i->usri3_user_id = i21->rid;
873
i->usri3_primary_group_id = i21->primary_gid;
874
i->usri3_profile = talloc_strdup(mem_ctx, i21->profile_path.string);
875
i->usri3_home_dir_drive = talloc_strdup(mem_ctx, i21->home_drive.string);
876
i->usri3_password_expired = i21->password_expired;
881
/****************************************************************
882
****************************************************************/
884
static NTSTATUS info21_to_USER_INFO_4(TALLOC_CTX *mem_ctx,
885
const struct samr_UserInfo21 *i21,
887
struct dom_sid *domain_sid,
888
struct USER_INFO_4 *i)
894
i->usri4_name = talloc_strdup(mem_ctx, i21->account_name.string);
895
NT_STATUS_HAVE_NO_MEMORY(i->usri4_name);
896
i->usri4_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
897
i->usri4_password = NULL;
898
i->usri4_priv = samr_rid_to_priv_level(i21->rid);
899
i->usri4_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
900
i->usri4_comment = talloc_strdup(mem_ctx, i21->description.string);
901
i->usri4_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
902
i->usri4_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
903
i->usri4_auth_flags = auth_flag;
904
i->usri4_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
905
i->usri4_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
906
i->usri4_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
907
i->usri4_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
908
i->usri4_last_logon = nt_time_to_unix(i21->last_logon);
909
i->usri4_last_logoff = nt_time_to_unix(i21->last_logoff);
910
i->usri4_acct_expires = nt_time_to_unix(i21->acct_expiry);
911
i->usri4_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
912
i->usri4_units_per_week = i21->logon_hours.units_per_week;
913
i->usri4_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
914
i->usri4_bad_pw_count = i21->bad_password_count;
915
i->usri4_num_logons = i21->logon_count;
916
i->usri4_logon_server = talloc_strdup(mem_ctx, "\\\\*");
917
i->usri4_country_code = i21->country_code;
918
i->usri4_code_page = i21->code_page;
919
if (!sid_compose(&sid, domain_sid, i21->rid)) {
920
return NT_STATUS_NO_MEMORY;
922
i->usri4_user_sid = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
923
i->usri4_primary_group_id = i21->primary_gid;
924
i->usri4_profile = talloc_strdup(mem_ctx, i21->profile_path.string);
925
i->usri4_home_dir_drive = talloc_strdup(mem_ctx, i21->home_drive.string);
926
i->usri4_password_expired = i21->password_expired;
931
/****************************************************************
932
****************************************************************/
934
static NTSTATUS info21_to_USER_INFO_10(TALLOC_CTX *mem_ctx,
935
const struct samr_UserInfo21 *i21,
936
struct USER_INFO_10 *i)
940
i->usri10_name = talloc_strdup(mem_ctx, i21->account_name.string);
941
NT_STATUS_HAVE_NO_MEMORY(i->usri10_name);
942
i->usri10_comment = talloc_strdup(mem_ctx, i21->description.string);
943
i->usri10_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
944
i->usri10_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
949
/****************************************************************
950
****************************************************************/
952
static NTSTATUS info21_to_USER_INFO_11(TALLOC_CTX *mem_ctx,
953
const struct samr_UserInfo21 *i21,
955
struct USER_INFO_11 *i)
959
i->usri11_name = talloc_strdup(mem_ctx, i21->account_name.string);
960
NT_STATUS_HAVE_NO_MEMORY(i->usri11_name);
961
i->usri11_comment = talloc_strdup(mem_ctx, i21->description.string);
962
i->usri11_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
963
i->usri11_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
964
i->usri11_priv = samr_rid_to_priv_level(i21->rid);
965
i->usri11_auth_flags = auth_flag;
966
i->usri11_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
967
i->usri11_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
968
i->usri11_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
969
i->usri11_last_logon = nt_time_to_unix(i21->last_logon);
970
i->usri11_last_logoff = nt_time_to_unix(i21->last_logoff);
971
i->usri11_bad_pw_count = i21->bad_password_count;
972
i->usri11_num_logons = i21->logon_count;
973
i->usri11_logon_server = talloc_strdup(mem_ctx, "\\\\*");
974
i->usri11_country_code = i21->country_code;
975
i->usri11_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
976
i->usri11_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
977
i->usri11_units_per_week = i21->logon_hours.units_per_week;
978
i->usri11_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
979
i->usri11_code_page = i21->code_page;
984
/****************************************************************
985
****************************************************************/
987
static NTSTATUS info21_to_USER_INFO_20(TALLOC_CTX *mem_ctx,
988
const struct samr_UserInfo21 *i21,
989
struct USER_INFO_20 *i)
993
i->usri20_name = talloc_strdup(mem_ctx, i21->account_name.string);
994
NT_STATUS_HAVE_NO_MEMORY(i->usri20_name);
995
i->usri20_comment = talloc_strdup(mem_ctx, i21->description.string);
996
i->usri20_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
997
i->usri20_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
998
i->usri20_user_id = i21->rid;
1000
return NT_STATUS_OK;
1003
/****************************************************************
1004
****************************************************************/
1006
static NTSTATUS info21_to_USER_INFO_23(TALLOC_CTX *mem_ctx,
1007
const struct samr_UserInfo21 *i21,
1008
struct dom_sid *domain_sid,
1009
struct USER_INFO_23 *i)
1015
i->usri23_name = talloc_strdup(mem_ctx, i21->account_name.string);
1016
NT_STATUS_HAVE_NO_MEMORY(i->usri23_name);
1017
i->usri23_comment = talloc_strdup(mem_ctx, i21->description.string);
1018
i->usri23_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
1019
i->usri23_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
1020
if (!sid_compose(&sid, domain_sid, i21->rid)) {
1021
return NT_STATUS_NO_MEMORY;
1023
i->usri23_user_sid = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
1025
return NT_STATUS_OK;
1028
/****************************************************************
1029
****************************************************************/
1031
static NTSTATUS libnetapi_samr_lookup_user_map_USER_INFO(TALLOC_CTX *mem_ctx,
1032
struct rpc_pipe_client *pipe_cli,
1033
struct dom_sid *domain_sid,
1034
struct policy_handle *domain_handle,
1035
struct policy_handle *builtin_handle,
1036
const char *user_name,
1040
uint32_t *num_entries)
1044
struct samr_UserInfo21 *info21 = NULL;
1045
struct sec_desc_buf *sec_desc = NULL;
1046
uint32_t auth_flag = 0;
1048
struct USER_INFO_0 info0;
1049
struct USER_INFO_1 info1;
1050
struct USER_INFO_2 info2;
1051
struct USER_INFO_3 info3;
1052
struct USER_INFO_4 info4;
1053
struct USER_INFO_10 info10;
1054
struct USER_INFO_11 info11;
1055
struct USER_INFO_20 info20;
1056
struct USER_INFO_23 info23;
1070
return NT_STATUS_INVALID_LEVEL;
1074
info0.usri0_name = talloc_strdup(mem_ctx, user_name);
1075
NT_STATUS_HAVE_NO_MEMORY(info0.usri0_name);
1077
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_0, info0,
1078
(struct USER_INFO_0 **)buffer, num_entries);
1080
return NT_STATUS_OK;
1083
status = libnetapi_samr_lookup_user(mem_ctx, pipe_cli,
1094
if (!NT_STATUS_IS_OK(status)) {
1100
/* already returned above */
1103
status = info21_to_USER_INFO_1(mem_ctx, info21, &info1);
1104
NT_STATUS_NOT_OK_RETURN(status);
1106
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_1, info1,
1107
(struct USER_INFO_1 **)buffer, num_entries);
1111
status = info21_to_USER_INFO_2(mem_ctx, info21, auth_flag, &info2);
1112
NT_STATUS_NOT_OK_RETURN(status);
1114
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_2, info2,
1115
(struct USER_INFO_2 **)buffer, num_entries);
1119
status = info21_to_USER_INFO_3(mem_ctx, info21, auth_flag, &info3);
1120
NT_STATUS_NOT_OK_RETURN(status);
1122
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_3, info3,
1123
(struct USER_INFO_3 **)buffer, num_entries);
1127
status = info21_to_USER_INFO_4(mem_ctx, info21, auth_flag, domain_sid, &info4);
1128
NT_STATUS_NOT_OK_RETURN(status);
1130
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_4, info4,
1131
(struct USER_INFO_4 **)buffer, num_entries);
1135
status = info21_to_USER_INFO_10(mem_ctx, info21, &info10);
1136
NT_STATUS_NOT_OK_RETURN(status);
1138
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_10, info10,
1139
(struct USER_INFO_10 **)buffer, num_entries);
1143
status = info21_to_USER_INFO_11(mem_ctx, info21, auth_flag, &info11);
1144
NT_STATUS_NOT_OK_RETURN(status);
1146
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_11, info11,
1147
(struct USER_INFO_11 **)buffer, num_entries);
1151
status = info21_to_USER_INFO_20(mem_ctx, info21, &info20);
1152
NT_STATUS_NOT_OK_RETURN(status);
1154
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_20, info20,
1155
(struct USER_INFO_20 **)buffer, num_entries);
1159
status = info21_to_USER_INFO_23(mem_ctx, info21, domain_sid, &info23);
1160
NT_STATUS_NOT_OK_RETURN(status);
1162
ADD_TO_ARRAY(mem_ctx, struct USER_INFO_23, info23,
1163
(struct USER_INFO_23 **)buffer, num_entries);
1166
return NT_STATUS_INVALID_LEVEL;
1173
/****************************************************************
1174
****************************************************************/
1176
WERROR NetUserEnum_r(struct libnetapi_ctx *ctx,
1177
struct NetUserEnum *r)
1179
struct rpc_pipe_client *pipe_cli = NULL;
1180
struct policy_handle connect_handle;
1181
struct dom_sid2 *domain_sid = NULL;
1182
struct policy_handle domain_handle, builtin_handle;
1183
struct samr_SamArray *sam = NULL;
1184
uint32_t filter = ACB_NORMAL;
1186
uint32_t entries_read = 0;
1188
NTSTATUS status = NT_STATUS_OK;
1191
ZERO_STRUCT(connect_handle);
1192
ZERO_STRUCT(domain_handle);
1193
ZERO_STRUCT(builtin_handle);
1195
if (!r->out.buffer) {
1196
return WERR_INVALID_PARAM;
1199
*r->out.buffer = NULL;
1200
*r->out.entries_read = 0;
1202
switch (r->in.level) {
1214
return WERR_UNKNOWN_LEVEL;
1217
werr = libnetapi_open_pipe(ctx, r->in.server_name,
1218
&ndr_table_samr.syntax_id,
1220
if (!W_ERROR_IS_OK(werr)) {
1224
werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1225
SAMR_ACCESS_ENUM_DOMAINS |
1226
SAMR_ACCESS_LOOKUP_DOMAIN,
1227
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1228
SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1231
if (!W_ERROR_IS_OK(werr)) {
1235
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1236
SAMR_ACCESS_ENUM_DOMAINS |
1237
SAMR_ACCESS_LOOKUP_DOMAIN,
1238
SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
1239
SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
1240
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1244
if (!W_ERROR_IS_OK(werr)) {
1248
switch (r->in.filter) {
1249
case FILTER_NORMAL_ACCOUNT:
1250
filter = ACB_NORMAL;
1252
case FILTER_TEMP_DUPLICATE_ACCOUNT:
1253
filter = ACB_TEMPDUP;
1255
case FILTER_INTERDOMAIN_TRUST_ACCOUNT:
1256
filter = ACB_DOMTRUST;
1258
case FILTER_WORKSTATION_TRUST_ACCOUNT:
1259
filter = ACB_WSTRUST;
1261
case FILTER_SERVER_TRUST_ACCOUNT:
1262
filter = ACB_SVRTRUST;
1268
status = rpccli_samr_EnumDomainUsers(pipe_cli,
1271
r->in.resume_handle,
1276
werr = ntstatus_to_werror(status);
1277
if (NT_STATUS_IS_ERR(status)) {
1281
for (i=0; i < sam->count; i++) {
1283
status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
1287
sam->entries[i].name.string,
1288
sam->entries[i].idx,
1291
r->out.entries_read);
1292
if (!NT_STATUS_IS_OK(status)) {
1293
werr = ntstatus_to_werror(status);
1300
if (NT_STATUS_IS_OK(status) ||
1301
NT_STATUS_IS_ERR(status)) {
1303
if (ctx->disable_policy_handle_cache) {
1304
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1305
libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
1306
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1313
/****************************************************************
1314
****************************************************************/
1316
WERROR NetUserEnum_l(struct libnetapi_ctx *ctx,
1317
struct NetUserEnum *r)
1319
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserEnum);
1322
/****************************************************************
1323
****************************************************************/
1325
static WERROR convert_samr_dispinfo_to_NET_DISPLAY_USER(TALLOC_CTX *mem_ctx,
1326
struct samr_DispInfoGeneral *info,
1327
uint32_t *entries_read,
1330
struct NET_DISPLAY_USER *user = NULL;
1333
user = TALLOC_ZERO_ARRAY(mem_ctx,
1334
struct NET_DISPLAY_USER,
1336
W_ERROR_HAVE_NO_MEMORY(user);
1338
for (i = 0; i < info->count; i++) {
1339
user[i].usri1_name = talloc_strdup(mem_ctx,
1340
info->entries[i].account_name.string);
1341
user[i].usri1_comment = talloc_strdup(mem_ctx,
1342
info->entries[i].description.string);
1343
user[i].usri1_flags =
1344
info->entries[i].acct_flags;
1345
user[i].usri1_full_name = talloc_strdup(mem_ctx,
1346
info->entries[i].full_name.string);
1347
user[i].usri1_user_id =
1348
info->entries[i].rid;
1349
user[i].usri1_next_index =
1350
info->entries[i].idx;
1352
if (!user[i].usri1_name) {
1357
*buffer = talloc_memdup(mem_ctx, user,
1358
sizeof(struct NET_DISPLAY_USER) * info->count);
1359
W_ERROR_HAVE_NO_MEMORY(*buffer);
1361
*entries_read = info->count;
1366
/****************************************************************
1367
****************************************************************/
1369
static WERROR convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(TALLOC_CTX *mem_ctx,
1370
struct samr_DispInfoFull *info,
1371
uint32_t *entries_read,
1374
struct NET_DISPLAY_MACHINE *machine = NULL;
1377
machine = TALLOC_ZERO_ARRAY(mem_ctx,
1378
struct NET_DISPLAY_MACHINE,
1380
W_ERROR_HAVE_NO_MEMORY(machine);
1382
for (i = 0; i < info->count; i++) {
1383
machine[i].usri2_name = talloc_strdup(mem_ctx,
1384
info->entries[i].account_name.string);
1385
machine[i].usri2_comment = talloc_strdup(mem_ctx,
1386
info->entries[i].description.string);
1387
machine[i].usri2_flags =
1388
info->entries[i].acct_flags;
1389
machine[i].usri2_user_id =
1390
info->entries[i].rid;
1391
machine[i].usri2_next_index =
1392
info->entries[i].idx;
1394
if (!machine[i].usri2_name) {
1399
*buffer = talloc_memdup(mem_ctx, machine,
1400
sizeof(struct NET_DISPLAY_MACHINE) * info->count);
1401
W_ERROR_HAVE_NO_MEMORY(*buffer);
1403
*entries_read = info->count;
1408
/****************************************************************
1409
****************************************************************/
1411
static WERROR convert_samr_dispinfo_to_NET_DISPLAY_GROUP(TALLOC_CTX *mem_ctx,
1412
struct samr_DispInfoFullGroups *info,
1413
uint32_t *entries_read,
1416
struct NET_DISPLAY_GROUP *group = NULL;
1419
group = TALLOC_ZERO_ARRAY(mem_ctx,
1420
struct NET_DISPLAY_GROUP,
1422
W_ERROR_HAVE_NO_MEMORY(group);
1424
for (i = 0; i < info->count; i++) {
1425
group[i].grpi3_name = talloc_strdup(mem_ctx,
1426
info->entries[i].account_name.string);
1427
group[i].grpi3_comment = talloc_strdup(mem_ctx,
1428
info->entries[i].description.string);
1429
group[i].grpi3_group_id =
1430
info->entries[i].rid;
1431
group[i].grpi3_attributes =
1432
info->entries[i].acct_flags;
1433
group[i].grpi3_next_index =
1434
info->entries[i].idx;
1436
if (!group[i].grpi3_name) {
1441
*buffer = talloc_memdup(mem_ctx, group,
1442
sizeof(struct NET_DISPLAY_GROUP) * info->count);
1443
W_ERROR_HAVE_NO_MEMORY(*buffer);
1445
*entries_read = info->count;
1451
/****************************************************************
1452
****************************************************************/
1454
static WERROR convert_samr_dispinfo_to_NET_DISPLAY(TALLOC_CTX *mem_ctx,
1455
union samr_DispInfo *info,
1457
uint32_t *entries_read,
1462
return convert_samr_dispinfo_to_NET_DISPLAY_USER(mem_ctx,
1467
return convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(mem_ctx,
1472
return convert_samr_dispinfo_to_NET_DISPLAY_GROUP(mem_ctx,
1477
return WERR_UNKNOWN_LEVEL;
1483
/****************************************************************
1484
****************************************************************/
1486
WERROR NetQueryDisplayInformation_r(struct libnetapi_ctx *ctx,
1487
struct NetQueryDisplayInformation *r)
1489
struct rpc_pipe_client *pipe_cli = NULL;
1490
struct policy_handle connect_handle;
1491
struct dom_sid2 *domain_sid = NULL;
1492
struct policy_handle domain_handle;
1493
union samr_DispInfo info;
1495
uint32_t total_size = 0;
1496
uint32_t returned_size = 0;
1498
NTSTATUS status = NT_STATUS_OK;
1502
*r->out.entries_read = 0;
1504
ZERO_STRUCT(connect_handle);
1505
ZERO_STRUCT(domain_handle);
1507
switch (r->in.level) {
1513
return WERR_UNKNOWN_LEVEL;
1516
werr = libnetapi_open_pipe(ctx, r->in.server_name,
1517
&ndr_table_samr.syntax_id,
1519
if (!W_ERROR_IS_OK(werr)) {
1523
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1524
SAMR_ACCESS_ENUM_DOMAINS |
1525
SAMR_ACCESS_LOOKUP_DOMAIN,
1526
SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
1527
SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS |
1528
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1532
if (!W_ERROR_IS_OK(werr)) {
1536
status = rpccli_samr_QueryDisplayInfo2(pipe_cli,
1541
r->in.entries_requested,
1546
werr = ntstatus_to_werror(status);
1547
if (NT_STATUS_IS_ERR(status)) {
1551
werr_tmp = convert_samr_dispinfo_to_NET_DISPLAY(ctx, &info,
1553
r->out.entries_read,
1555
if (!W_ERROR_IS_OK(werr_tmp)) {
1560
if (NT_STATUS_IS_OK(status) ||
1561
NT_STATUS_IS_ERR(status)) {
1563
if (ctx->disable_policy_handle_cache) {
1564
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1565
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1573
/****************************************************************
1574
****************************************************************/
1577
WERROR NetQueryDisplayInformation_l(struct libnetapi_ctx *ctx,
1578
struct NetQueryDisplayInformation *r)
1580
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetQueryDisplayInformation);
1583
/****************************************************************
1584
****************************************************************/
1586
WERROR NetUserChangePassword_r(struct libnetapi_ctx *ctx,
1587
struct NetUserChangePassword *r)
1589
return WERR_NOT_SUPPORTED;
1592
/****************************************************************
1593
****************************************************************/
1595
WERROR NetUserChangePassword_l(struct libnetapi_ctx *ctx,
1596
struct NetUserChangePassword *r)
1598
return WERR_NOT_SUPPORTED;
1601
/****************************************************************
1602
****************************************************************/
1604
WERROR NetUserGetInfo_r(struct libnetapi_ctx *ctx,
1605
struct NetUserGetInfo *r)
1607
struct rpc_pipe_client *pipe_cli = NULL;
1611
struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1612
struct lsa_String lsa_account_name;
1613
struct dom_sid2 *domain_sid = NULL;
1614
struct samr_Ids user_rids, name_types;
1615
uint32_t num_entries = 0;
1617
ZERO_STRUCT(connect_handle);
1618
ZERO_STRUCT(domain_handle);
1619
ZERO_STRUCT(builtin_handle);
1620
ZERO_STRUCT(user_handle);
1622
if (!r->out.buffer) {
1623
return WERR_INVALID_PARAM;
1626
switch (r->in.level) {
1638
werr = WERR_UNKNOWN_LEVEL;
1642
werr = libnetapi_open_pipe(ctx, r->in.server_name,
1643
&ndr_table_samr.syntax_id,
1645
if (!W_ERROR_IS_OK(werr)) {
1649
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1650
SAMR_ACCESS_ENUM_DOMAINS |
1651
SAMR_ACCESS_LOOKUP_DOMAIN,
1652
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1656
if (!W_ERROR_IS_OK(werr)) {
1660
werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1661
SAMR_ACCESS_ENUM_DOMAINS |
1662
SAMR_ACCESS_LOOKUP_DOMAIN,
1663
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1664
SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1667
if (!W_ERROR_IS_OK(werr)) {
1671
init_lsa_String(&lsa_account_name, r->in.user_name);
1673
status = rpccli_samr_LookupNames(pipe_cli, ctx,
1679
if (!NT_STATUS_IS_OK(status)) {
1680
werr = ntstatus_to_werror(status);
1684
status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
1693
if (!NT_STATUS_IS_OK(status)) {
1694
werr = ntstatus_to_werror(status);
1699
if (is_valid_policy_hnd(&user_handle)) {
1700
rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1703
if (ctx->disable_policy_handle_cache) {
1704
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1705
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1711
/****************************************************************
1712
****************************************************************/
1714
WERROR NetUserGetInfo_l(struct libnetapi_ctx *ctx,
1715
struct NetUserGetInfo *r)
1717
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetInfo);
1720
/****************************************************************
1721
****************************************************************/
1723
WERROR NetUserSetInfo_r(struct libnetapi_ctx *ctx,
1724
struct NetUserSetInfo *r)
1726
struct rpc_pipe_client *pipe_cli = NULL;
1730
struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1731
struct lsa_String lsa_account_name;
1732
struct dom_sid2 *domain_sid = NULL;
1733
struct samr_Ids user_rids, name_types;
1734
uint32_t user_mask = 0;
1736
struct USER_INFO_X uX;
1738
ZERO_STRUCT(connect_handle);
1739
ZERO_STRUCT(domain_handle);
1740
ZERO_STRUCT(builtin_handle);
1741
ZERO_STRUCT(user_handle);
1743
if (!r->in.buffer) {
1744
return WERR_INVALID_PARAM;
1747
switch (r->in.level) {
1749
user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES;
1752
user_mask = SAMR_USER_ACCESS_SET_PASSWORD;
1761
user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES;
1765
user_mask = SAMR_USER_ACCESS_SET_LOC_COM;
1767
user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES |
1768
SAMR_USER_ACCESS_GET_GROUPS;
1771
user_mask = STD_RIGHT_READ_CONTROL_ACCESS |
1772
STD_RIGHT_WRITE_DAC_ACCESS |
1773
SAMR_USER_ACCESS_GET_GROUPS |
1774
SAMR_USER_ACCESS_SET_PASSWORD |
1775
SAMR_USER_ACCESS_SET_ATTRIBUTES |
1776
SAMR_USER_ACCESS_GET_ATTRIBUTES |
1777
SAMR_USER_ACCESS_SET_LOC_COM;
1789
werr = WERR_NOT_SUPPORTED;
1792
werr = WERR_UNKNOWN_LEVEL;
1796
werr = libnetapi_open_pipe(ctx, r->in.server_name,
1797
&ndr_table_samr.syntax_id,
1799
if (!W_ERROR_IS_OK(werr)) {
1803
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1804
SAMR_ACCESS_ENUM_DOMAINS |
1805
SAMR_ACCESS_LOOKUP_DOMAIN,
1806
SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
1807
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1811
if (!W_ERROR_IS_OK(werr)) {
1815
werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1816
SAMR_ACCESS_ENUM_DOMAINS |
1817
SAMR_ACCESS_LOOKUP_DOMAIN,
1818
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
1819
SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1822
if (!W_ERROR_IS_OK(werr)) {
1826
init_lsa_String(&lsa_account_name, r->in.user_name);
1828
status = rpccli_samr_LookupNames(pipe_cli, ctx,
1834
if (!NT_STATUS_IS_OK(status)) {
1835
werr = ntstatus_to_werror(status);
1839
status = rpccli_samr_OpenUser(pipe_cli, ctx,
1844
if (!NT_STATUS_IS_OK(status)) {
1845
werr = ntstatus_to_werror(status);
1849
status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
1850
if (!NT_STATUS_IS_OK(status)) {
1851
werr = ntstatus_to_werror(status);
1855
status = set_user_info_USER_INFO_X(ctx, pipe_cli,
1856
&pipe_cli->auth->user_session_key,
1859
if (!NT_STATUS_IS_OK(status)) {
1860
werr = ntstatus_to_werror(status);
1867
if (is_valid_policy_hnd(&user_handle)) {
1868
rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1871
if (ctx->disable_policy_handle_cache) {
1872
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1873
libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
1874
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1880
/****************************************************************
1881
****************************************************************/
1883
WERROR NetUserSetInfo_l(struct libnetapi_ctx *ctx,
1884
struct NetUserSetInfo *r)
1886
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserSetInfo);
1889
/****************************************************************
1890
****************************************************************/
1892
static NTSTATUS query_USER_MODALS_INFO_rpc(TALLOC_CTX *mem_ctx,
1893
struct rpc_pipe_client *pipe_cli,
1894
struct policy_handle *domain_handle,
1895
struct samr_DomInfo1 *info1,
1896
struct samr_DomInfo3 *info3,
1897
struct samr_DomInfo5 *info5,
1898
struct samr_DomInfo6 *info6,
1899
struct samr_DomInfo7 *info7,
1900
struct samr_DomInfo12 *info12)
1903
union samr_DomainInfo *dom_info = NULL;
1906
status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1910
NT_STATUS_NOT_OK_RETURN(status);
1912
*info1 = dom_info->info1;
1916
status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1920
NT_STATUS_NOT_OK_RETURN(status);
1922
*info3 = dom_info->info3;
1926
status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1930
NT_STATUS_NOT_OK_RETURN(status);
1932
*info5 = dom_info->info5;
1936
status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1940
NT_STATUS_NOT_OK_RETURN(status);
1942
*info6 = dom_info->info6;
1946
status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1950
NT_STATUS_NOT_OK_RETURN(status);
1952
*info7 = dom_info->info7;
1956
status = rpccli_samr_QueryDomainInfo2(pipe_cli, mem_ctx,
1960
NT_STATUS_NOT_OK_RETURN(status);
1962
*info12 = dom_info->info12;
1965
return NT_STATUS_OK;
1968
/****************************************************************
1969
****************************************************************/
1971
static NTSTATUS query_USER_MODALS_INFO_0(TALLOC_CTX *mem_ctx,
1972
struct rpc_pipe_client *pipe_cli,
1973
struct policy_handle *domain_handle,
1974
struct USER_MODALS_INFO_0 *info0)
1977
struct samr_DomInfo1 dom_info1;
1978
struct samr_DomInfo3 dom_info3;
1980
ZERO_STRUCTP(info0);
1982
status = query_USER_MODALS_INFO_rpc(mem_ctx,
1991
NT_STATUS_NOT_OK_RETURN(status);
1993
info0->usrmod0_min_passwd_len =
1994
dom_info1.min_password_length;
1995
info0->usrmod0_max_passwd_age =
1996
nt_time_to_unix_abs((NTTIME *)&dom_info1.max_password_age);
1997
info0->usrmod0_min_passwd_age =
1998
nt_time_to_unix_abs((NTTIME *)&dom_info1.min_password_age);
1999
info0->usrmod0_password_hist_len =
2000
dom_info1.password_history_length;
2002
info0->usrmod0_force_logoff =
2003
nt_time_to_unix_abs(&dom_info3.force_logoff_time);
2005
return NT_STATUS_OK;
2008
/****************************************************************
2009
****************************************************************/
2011
static NTSTATUS query_USER_MODALS_INFO_1(TALLOC_CTX *mem_ctx,
2012
struct rpc_pipe_client *pipe_cli,
2013
struct policy_handle *domain_handle,
2014
struct USER_MODALS_INFO_1 *info1)
2017
struct samr_DomInfo6 dom_info6;
2018
struct samr_DomInfo7 dom_info7;
2020
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2029
NT_STATUS_NOT_OK_RETURN(status);
2031
info1->usrmod1_primary =
2032
talloc_strdup(mem_ctx, dom_info6.primary.string);
2034
info1->usrmod1_role = dom_info7.role;
2036
return NT_STATUS_OK;
2039
/****************************************************************
2040
****************************************************************/
2042
static NTSTATUS query_USER_MODALS_INFO_2(TALLOC_CTX *mem_ctx,
2043
struct rpc_pipe_client *pipe_cli,
2044
struct policy_handle *domain_handle,
2045
struct dom_sid *domain_sid,
2046
struct USER_MODALS_INFO_2 *info2)
2049
struct samr_DomInfo5 dom_info5;
2051
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2060
NT_STATUS_NOT_OK_RETURN(status);
2062
info2->usrmod2_domain_name =
2063
talloc_strdup(mem_ctx, dom_info5.domain_name.string);
2064
info2->usrmod2_domain_id =
2065
(struct domsid *)sid_dup_talloc(mem_ctx, domain_sid);
2067
NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_name);
2068
NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_id);
2070
return NT_STATUS_OK;
2073
/****************************************************************
2074
****************************************************************/
2076
static NTSTATUS query_USER_MODALS_INFO_3(TALLOC_CTX *mem_ctx,
2077
struct rpc_pipe_client *pipe_cli,
2078
struct policy_handle *domain_handle,
2079
struct USER_MODALS_INFO_3 *info3)
2082
struct samr_DomInfo12 dom_info12;
2084
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2093
NT_STATUS_NOT_OK_RETURN(status);
2095
info3->usrmod3_lockout_duration =
2096
nt_time_to_unix_abs(&dom_info12.lockout_duration);
2097
info3->usrmod3_lockout_observation_window =
2098
nt_time_to_unix_abs(&dom_info12.lockout_window);
2099
info3->usrmod3_lockout_threshold =
2100
dom_info12.lockout_threshold;
2102
return NT_STATUS_OK;
2105
/****************************************************************
2106
****************************************************************/
2108
static NTSTATUS query_USER_MODALS_INFO_to_buffer(TALLOC_CTX *mem_ctx,
2109
struct rpc_pipe_client *pipe_cli,
2111
struct policy_handle *domain_handle,
2112
struct dom_sid *domain_sid,
2117
struct USER_MODALS_INFO_0 info0;
2118
struct USER_MODALS_INFO_1 info1;
2119
struct USER_MODALS_INFO_2 info2;
2120
struct USER_MODALS_INFO_3 info3;
2123
return ERROR_INSUFFICIENT_BUFFER;
2128
status = query_USER_MODALS_INFO_0(mem_ctx,
2132
NT_STATUS_NOT_OK_RETURN(status);
2134
*buffer = (uint8_t *)talloc_memdup(mem_ctx, &info0,
2139
status = query_USER_MODALS_INFO_1(mem_ctx,
2143
NT_STATUS_NOT_OK_RETURN(status);
2145
*buffer = (uint8_t *)talloc_memdup(mem_ctx, &info1,
2149
status = query_USER_MODALS_INFO_2(mem_ctx,
2154
NT_STATUS_NOT_OK_RETURN(status);
2156
*buffer = (uint8_t *)talloc_memdup(mem_ctx, &info2,
2160
status = query_USER_MODALS_INFO_3(mem_ctx,
2164
NT_STATUS_NOT_OK_RETURN(status);
2166
*buffer = (uint8_t *)talloc_memdup(mem_ctx, &info3,
2173
NT_STATUS_HAVE_NO_MEMORY(*buffer);
2175
return NT_STATUS_OK;
2178
/****************************************************************
2179
****************************************************************/
2181
WERROR NetUserModalsGet_r(struct libnetapi_ctx *ctx,
2182
struct NetUserModalsGet *r)
2184
struct rpc_pipe_client *pipe_cli = NULL;
2188
struct policy_handle connect_handle, domain_handle;
2189
struct dom_sid2 *domain_sid = NULL;
2190
uint32_t access_mask = SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT;
2192
ZERO_STRUCT(connect_handle);
2193
ZERO_STRUCT(domain_handle);
2195
if (!r->out.buffer) {
2196
return WERR_INVALID_PARAM;
2199
switch (r->in.level) {
2201
access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
2202
SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
2206
access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
2209
access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1;
2212
werr = WERR_UNKNOWN_LEVEL;
2216
werr = libnetapi_open_pipe(ctx, r->in.server_name,
2217
&ndr_table_samr.syntax_id,
2219
if (!W_ERROR_IS_OK(werr)) {
2223
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2224
SAMR_ACCESS_ENUM_DOMAINS |
2225
SAMR_ACCESS_LOOKUP_DOMAIN,
2230
if (!W_ERROR_IS_OK(werr)) {
2237
/* 3: 12 (DomainInfo2) */
2239
status = query_USER_MODALS_INFO_to_buffer(ctx,
2245
if (!NT_STATUS_IS_OK(status)) {
2246
werr = ntstatus_to_werror(status);
2251
if (ctx->disable_policy_handle_cache) {
2252
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2253
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2259
/****************************************************************
2260
****************************************************************/
2262
WERROR NetUserModalsGet_l(struct libnetapi_ctx *ctx,
2263
struct NetUserModalsGet *r)
2265
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserModalsGet);
2268
/****************************************************************
2269
****************************************************************/
2271
static NTSTATUS set_USER_MODALS_INFO_rpc(TALLOC_CTX *mem_ctx,
2272
struct rpc_pipe_client *pipe_cli,
2273
struct policy_handle *domain_handle,
2274
struct samr_DomInfo1 *info1,
2275
struct samr_DomInfo3 *info3,
2276
struct samr_DomInfo12 *info12)
2279
union samr_DomainInfo dom_info;
2283
ZERO_STRUCT(dom_info);
2285
dom_info.info1 = *info1;
2287
status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2291
NT_STATUS_NOT_OK_RETURN(status);
2296
ZERO_STRUCT(dom_info);
2298
dom_info.info3 = *info3;
2300
status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2305
NT_STATUS_NOT_OK_RETURN(status);
2310
ZERO_STRUCT(dom_info);
2312
dom_info.info12 = *info12;
2314
status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2319
NT_STATUS_NOT_OK_RETURN(status);
2322
return NT_STATUS_OK;
2325
/****************************************************************
2326
****************************************************************/
2328
static NTSTATUS set_USER_MODALS_INFO_0_buffer(TALLOC_CTX *mem_ctx,
2329
struct rpc_pipe_client *pipe_cli,
2330
struct policy_handle *domain_handle,
2331
struct USER_MODALS_INFO_0 *info0)
2334
struct samr_DomInfo1 dom_info_1;
2335
struct samr_DomInfo3 dom_info_3;
2337
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2346
NT_STATUS_NOT_OK_RETURN(status);
2348
dom_info_1.min_password_length =
2349
info0->usrmod0_min_passwd_len;
2350
dom_info_1.password_history_length =
2351
info0->usrmod0_password_hist_len;
2353
unix_to_nt_time_abs((NTTIME *)&dom_info_1.max_password_age,
2354
info0->usrmod0_max_passwd_age);
2355
unix_to_nt_time_abs((NTTIME *)&dom_info_1.min_password_age,
2356
info0->usrmod0_min_passwd_age);
2358
unix_to_nt_time_abs(&dom_info_3.force_logoff_time,
2359
info0->usrmod0_force_logoff);
2361
return set_USER_MODALS_INFO_rpc(mem_ctx,
2369
/****************************************************************
2370
****************************************************************/
2372
static NTSTATUS set_USER_MODALS_INFO_3_buffer(TALLOC_CTX *mem_ctx,
2373
struct rpc_pipe_client *pipe_cli,
2374
struct policy_handle *domain_handle,
2375
struct USER_MODALS_INFO_3 *info3)
2378
struct samr_DomInfo12 dom_info_12;
2380
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2389
NT_STATUS_NOT_OK_RETURN(status);
2391
unix_to_nt_time_abs((NTTIME *)&dom_info_12.lockout_duration,
2392
info3->usrmod3_lockout_duration);
2393
unix_to_nt_time_abs((NTTIME *)&dom_info_12.lockout_window,
2394
info3->usrmod3_lockout_observation_window);
2395
dom_info_12.lockout_threshold = info3->usrmod3_lockout_threshold;
2397
return set_USER_MODALS_INFO_rpc(mem_ctx,
2405
/****************************************************************
2406
****************************************************************/
2408
static NTSTATUS set_USER_MODALS_INFO_1001_buffer(TALLOC_CTX *mem_ctx,
2409
struct rpc_pipe_client *pipe_cli,
2410
struct policy_handle *domain_handle,
2411
struct USER_MODALS_INFO_1001 *info1001)
2414
struct samr_DomInfo1 dom_info_1;
2416
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2425
NT_STATUS_NOT_OK_RETURN(status);
2427
dom_info_1.min_password_length =
2428
info1001->usrmod1001_min_passwd_len;
2430
return set_USER_MODALS_INFO_rpc(mem_ctx,
2438
/****************************************************************
2439
****************************************************************/
2441
static NTSTATUS set_USER_MODALS_INFO_1002_buffer(TALLOC_CTX *mem_ctx,
2442
struct rpc_pipe_client *pipe_cli,
2443
struct policy_handle *domain_handle,
2444
struct USER_MODALS_INFO_1002 *info1002)
2447
struct samr_DomInfo1 dom_info_1;
2449
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2458
NT_STATUS_NOT_OK_RETURN(status);
2460
unix_to_nt_time_abs((NTTIME *)&dom_info_1.max_password_age,
2461
info1002->usrmod1002_max_passwd_age);
2463
return set_USER_MODALS_INFO_rpc(mem_ctx,
2471
/****************************************************************
2472
****************************************************************/
2474
static NTSTATUS set_USER_MODALS_INFO_1003_buffer(TALLOC_CTX *mem_ctx,
2475
struct rpc_pipe_client *pipe_cli,
2476
struct policy_handle *domain_handle,
2477
struct USER_MODALS_INFO_1003 *info1003)
2480
struct samr_DomInfo1 dom_info_1;
2482
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2491
NT_STATUS_NOT_OK_RETURN(status);
2493
unix_to_nt_time_abs((NTTIME *)&dom_info_1.min_password_age,
2494
info1003->usrmod1003_min_passwd_age);
2496
return set_USER_MODALS_INFO_rpc(mem_ctx,
2504
/****************************************************************
2505
****************************************************************/
2507
static NTSTATUS set_USER_MODALS_INFO_1004_buffer(TALLOC_CTX *mem_ctx,
2508
struct rpc_pipe_client *pipe_cli,
2509
struct policy_handle *domain_handle,
2510
struct USER_MODALS_INFO_1004 *info1004)
2513
struct samr_DomInfo3 dom_info_3;
2515
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2524
NT_STATUS_NOT_OK_RETURN(status);
2526
unix_to_nt_time_abs(&dom_info_3.force_logoff_time,
2527
info1004->usrmod1004_force_logoff);
2529
return set_USER_MODALS_INFO_rpc(mem_ctx,
2537
/****************************************************************
2538
****************************************************************/
2540
static NTSTATUS set_USER_MODALS_INFO_1005_buffer(TALLOC_CTX *mem_ctx,
2541
struct rpc_pipe_client *pipe_cli,
2542
struct policy_handle *domain_handle,
2543
struct USER_MODALS_INFO_1005 *info1005)
2546
struct samr_DomInfo1 dom_info_1;
2548
status = query_USER_MODALS_INFO_rpc(mem_ctx,
2557
NT_STATUS_NOT_OK_RETURN(status);
2559
dom_info_1.password_history_length =
2560
info1005->usrmod1005_password_hist_len;
2562
return set_USER_MODALS_INFO_rpc(mem_ctx,
2570
/****************************************************************
2571
****************************************************************/
2573
static NTSTATUS set_USER_MODALS_INFO_buffer(TALLOC_CTX *mem_ctx,
2574
struct rpc_pipe_client *pipe_cli,
2576
struct policy_handle *domain_handle,
2577
struct dom_sid *domain_sid,
2580
struct USER_MODALS_INFO_0 *info0;
2581
struct USER_MODALS_INFO_3 *info3;
2582
struct USER_MODALS_INFO_1001 *info1001;
2583
struct USER_MODALS_INFO_1002 *info1002;
2584
struct USER_MODALS_INFO_1003 *info1003;
2585
struct USER_MODALS_INFO_1004 *info1004;
2586
struct USER_MODALS_INFO_1005 *info1005;
2589
return ERROR_INSUFFICIENT_BUFFER;
2594
info0 = (struct USER_MODALS_INFO_0 *)buffer;
2595
return set_USER_MODALS_INFO_0_buffer(mem_ctx,
2600
info3 = (struct USER_MODALS_INFO_3 *)buffer;
2601
return set_USER_MODALS_INFO_3_buffer(mem_ctx,
2606
info1001 = (struct USER_MODALS_INFO_1001 *)buffer;
2607
return set_USER_MODALS_INFO_1001_buffer(mem_ctx,
2612
info1002 = (struct USER_MODALS_INFO_1002 *)buffer;
2613
return set_USER_MODALS_INFO_1002_buffer(mem_ctx,
2618
info1003 = (struct USER_MODALS_INFO_1003 *)buffer;
2619
return set_USER_MODALS_INFO_1003_buffer(mem_ctx,
2624
info1004 = (struct USER_MODALS_INFO_1004 *)buffer;
2625
return set_USER_MODALS_INFO_1004_buffer(mem_ctx,
2630
info1005 = (struct USER_MODALS_INFO_1005 *)buffer;
2631
return set_USER_MODALS_INFO_1005_buffer(mem_ctx,
2640
return NT_STATUS_OK;
2643
/****************************************************************
2644
****************************************************************/
2646
WERROR NetUserModalsSet_r(struct libnetapi_ctx *ctx,
2647
struct NetUserModalsSet *r)
2649
struct rpc_pipe_client *pipe_cli = NULL;
2653
struct policy_handle connect_handle, domain_handle;
2654
struct dom_sid2 *domain_sid = NULL;
2655
uint32_t access_mask = SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT;
2657
ZERO_STRUCT(connect_handle);
2658
ZERO_STRUCT(domain_handle);
2660
if (!r->in.buffer) {
2661
return WERR_INVALID_PARAM;
2664
switch (r->in.level) {
2666
access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
2667
SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
2668
SAMR_DOMAIN_ACCESS_SET_INFO_1 |
2669
SAMR_DOMAIN_ACCESS_SET_INFO_2;
2676
access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 |
2677
SAMR_DOMAIN_ACCESS_SET_INFO_1;
2680
access_mask |= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 |
2681
SAMR_DOMAIN_ACCESS_SET_INFO_2;
2687
werr = WERR_NOT_SUPPORTED;
2690
werr = WERR_UNKNOWN_LEVEL;
2694
werr = libnetapi_open_pipe(ctx, r->in.server_name,
2695
&ndr_table_samr.syntax_id,
2697
if (!W_ERROR_IS_OK(werr)) {
2701
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2702
SAMR_ACCESS_ENUM_DOMAINS |
2703
SAMR_ACCESS_LOOKUP_DOMAIN,
2708
if (!W_ERROR_IS_OK(werr)) {
2712
status = set_USER_MODALS_INFO_buffer(ctx,
2718
if (!NT_STATUS_IS_OK(status)) {
2719
werr = ntstatus_to_werror(status);
2724
if (ctx->disable_policy_handle_cache) {
2725
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2726
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2732
/****************************************************************
2733
****************************************************************/
2735
WERROR NetUserModalsSet_l(struct libnetapi_ctx *ctx,
2736
struct NetUserModalsSet *r)
2738
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserModalsSet);
2741
/****************************************************************
2742
****************************************************************/
2744
NTSTATUS add_GROUP_USERS_INFO_X_buffer(TALLOC_CTX *mem_ctx,
2746
const char *group_name,
2747
uint32_t attributes,
2749
uint32_t *num_entries)
2751
struct GROUP_USERS_INFO_0 u0;
2752
struct GROUP_USERS_INFO_1 u1;
2757
u0.grui0_name = talloc_strdup(mem_ctx, group_name);
2758
NT_STATUS_HAVE_NO_MEMORY(u0.grui0_name);
2760
u0.grui0_name = NULL;
2763
ADD_TO_ARRAY(mem_ctx, struct GROUP_USERS_INFO_0, u0,
2764
(struct GROUP_USERS_INFO_0 **)buffer, num_entries);
2768
u1.grui1_name = talloc_strdup(mem_ctx, group_name);
2769
NT_STATUS_HAVE_NO_MEMORY(u1.grui1_name);
2771
u1.grui1_name = NULL;
2774
u1.grui1_attributes = attributes;
2776
ADD_TO_ARRAY(mem_ctx, struct GROUP_USERS_INFO_1, u1,
2777
(struct GROUP_USERS_INFO_1 **)buffer, num_entries);
2780
return NT_STATUS_INVALID_INFO_CLASS;
2783
return NT_STATUS_OK;
2786
/****************************************************************
2787
****************************************************************/
2789
WERROR NetUserGetGroups_r(struct libnetapi_ctx *ctx,
2790
struct NetUserGetGroups *r)
2792
struct rpc_pipe_client *pipe_cli = NULL;
2793
struct policy_handle connect_handle, domain_handle, user_handle;
2794
struct lsa_String lsa_account_name;
2795
struct dom_sid2 *domain_sid = NULL;
2796
struct samr_Ids user_rids, name_types;
2797
struct samr_RidWithAttributeArray *rid_array = NULL;
2798
struct lsa_Strings names;
2799
struct samr_Ids types;
2800
uint32_t *rids = NULL;
2803
uint32_t entries_read = 0;
2805
NTSTATUS status = NT_STATUS_OK;
2808
ZERO_STRUCT(connect_handle);
2809
ZERO_STRUCT(domain_handle);
2811
if (!r->out.buffer) {
2812
return WERR_INVALID_PARAM;
2815
*r->out.buffer = NULL;
2816
*r->out.entries_read = 0;
2817
*r->out.total_entries = 0;
2819
switch (r->in.level) {
2824
return WERR_UNKNOWN_LEVEL;
2827
werr = libnetapi_open_pipe(ctx, r->in.server_name,
2828
&ndr_table_samr.syntax_id,
2830
if (!W_ERROR_IS_OK(werr)) {
2834
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2835
SAMR_ACCESS_ENUM_DOMAINS |
2836
SAMR_ACCESS_LOOKUP_DOMAIN,
2837
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
2841
if (!W_ERROR_IS_OK(werr)) {
2845
init_lsa_String(&lsa_account_name, r->in.user_name);
2847
status = rpccli_samr_LookupNames(pipe_cli, ctx,
2853
if (!NT_STATUS_IS_OK(status)) {
2854
werr = ntstatus_to_werror(status);
2858
status = rpccli_samr_OpenUser(pipe_cli, ctx,
2860
SAMR_USER_ACCESS_GET_GROUPS,
2863
if (!NT_STATUS_IS_OK(status)) {
2864
werr = ntstatus_to_werror(status);
2868
status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
2871
if (!NT_STATUS_IS_OK(status)) {
2872
werr = ntstatus_to_werror(status);
2876
rids = talloc_array(ctx, uint32_t, rid_array->count);
2882
for (i=0; i < rid_array->count; i++) {
2883
rids[i] = rid_array->rids[i].rid;
2886
status = rpccli_samr_LookupRids(pipe_cli, ctx,
2892
if (!NT_STATUS_IS_OK(status) &&
2893
!NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
2894
werr = ntstatus_to_werror(status);
2898
for (i=0; i < names.count; i++) {
2899
status = add_GROUP_USERS_INFO_X_buffer(ctx,
2901
names.names[i].string,
2902
rid_array->rids[i].attributes,
2905
if (!NT_STATUS_IS_OK(status)) {
2906
werr = ntstatus_to_werror(status);
2911
*r->out.entries_read = entries_read;
2912
*r->out.total_entries = entries_read;
2915
if (ctx->disable_policy_handle_cache) {
2916
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2917
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2923
/****************************************************************
2924
****************************************************************/
2926
WERROR NetUserGetGroups_l(struct libnetapi_ctx *ctx,
2927
struct NetUserGetGroups *r)
2929
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetGroups);
2932
/****************************************************************
2933
****************************************************************/
2935
WERROR NetUserSetGroups_r(struct libnetapi_ctx *ctx,
2936
struct NetUserSetGroups *r)
2938
struct rpc_pipe_client *pipe_cli = NULL;
2939
struct policy_handle connect_handle, domain_handle, user_handle, group_handle;
2940
struct lsa_String lsa_account_name;
2941
struct dom_sid2 *domain_sid = NULL;
2942
struct samr_Ids user_rids, name_types;
2943
struct samr_Ids group_rids;
2944
struct samr_RidWithAttributeArray *rid_array = NULL;
2945
struct lsa_String *lsa_names = NULL;
2947
uint32_t *add_rids = NULL;
2948
uint32_t *del_rids = NULL;
2949
size_t num_add_rids = 0;
2950
size_t num_del_rids = 0;
2952
uint32_t *member_rids = NULL;
2953
size_t num_member_rids = 0;
2955
struct GROUP_USERS_INFO_0 *i0 = NULL;
2956
struct GROUP_USERS_INFO_1 *i1 = NULL;
2960
NTSTATUS status = NT_STATUS_OK;
2963
ZERO_STRUCT(connect_handle);
2964
ZERO_STRUCT(domain_handle);
2966
if (!r->in.buffer) {
2967
return WERR_INVALID_PARAM;
2970
switch (r->in.level) {
2975
return WERR_UNKNOWN_LEVEL;
2978
werr = libnetapi_open_pipe(ctx, r->in.server_name,
2979
&ndr_table_samr.syntax_id,
2981
if (!W_ERROR_IS_OK(werr)) {
2985
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2986
SAMR_ACCESS_ENUM_DOMAINS |
2987
SAMR_ACCESS_LOOKUP_DOMAIN,
2988
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
2992
if (!W_ERROR_IS_OK(werr)) {
2996
init_lsa_String(&lsa_account_name, r->in.user_name);
2998
status = rpccli_samr_LookupNames(pipe_cli, ctx,
3004
if (!NT_STATUS_IS_OK(status)) {
3005
werr = ntstatus_to_werror(status);
3009
status = rpccli_samr_OpenUser(pipe_cli, ctx,
3011
SAMR_USER_ACCESS_GET_GROUPS,
3014
if (!NT_STATUS_IS_OK(status)) {
3015
werr = ntstatus_to_werror(status);
3019
switch (r->in.level) {
3021
i0 = (struct GROUP_USERS_INFO_0 *)r->in.buffer;
3024
i1 = (struct GROUP_USERS_INFO_1 *)r->in.buffer;
3028
lsa_names = talloc_array(ctx, struct lsa_String, r->in.num_entries);
3034
for (i=0; i < r->in.num_entries; i++) {
3036
switch (r->in.level) {
3038
init_lsa_String(&lsa_names[i], i0->grui0_name);
3042
init_lsa_String(&lsa_names[i], i1->grui1_name);
3048
status = rpccli_samr_LookupNames(pipe_cli, ctx,
3054
if (!NT_STATUS_IS_OK(status)) {
3055
werr = ntstatus_to_werror(status);
3059
member_rids = group_rids.ids;
3060
num_member_rids = group_rids.count;
3062
status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
3065
if (!NT_STATUS_IS_OK(status)) {
3066
werr = ntstatus_to_werror(status);
3072
for (i=0; i < r->in.num_entries; i++) {
3073
bool already_member = false;
3074
for (k=0; k < rid_array->count; k++) {
3075
if (member_rids[i] == rid_array->rids[k].rid) {
3076
already_member = true;
3080
if (!already_member) {
3081
if (!add_rid_to_array_unique(ctx,
3083
&add_rids, &num_add_rids)) {
3084
werr = WERR_GENERAL_FAILURE;
3092
for (k=0; k < rid_array->count; k++) {
3093
bool keep_member = false;
3094
for (i=0; i < r->in.num_entries; i++) {
3095
if (member_rids[i] == rid_array->rids[k].rid) {
3101
if (!add_rid_to_array_unique(ctx,
3102
rid_array->rids[k].rid,
3103
&del_rids, &num_del_rids)) {
3104
werr = WERR_GENERAL_FAILURE;
3112
for (i=0; i < num_add_rids; i++) {
3113
status = rpccli_samr_OpenGroup(pipe_cli, ctx,
3115
SAMR_GROUP_ACCESS_ADD_MEMBER,
3118
if (!NT_STATUS_IS_OK(status)) {
3119
werr = ntstatus_to_werror(status);
3123
status = rpccli_samr_AddGroupMember(pipe_cli, ctx,
3127
if (!NT_STATUS_IS_OK(status)) {
3128
werr = ntstatus_to_werror(status);
3132
if (is_valid_policy_hnd(&group_handle)) {
3133
rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3139
for (i=0; i < num_del_rids; i++) {
3140
status = rpccli_samr_OpenGroup(pipe_cli, ctx,
3142
SAMR_GROUP_ACCESS_REMOVE_MEMBER,
3145
if (!NT_STATUS_IS_OK(status)) {
3146
werr = ntstatus_to_werror(status);
3150
status = rpccli_samr_DeleteGroupMember(pipe_cli, ctx,
3153
if (!NT_STATUS_IS_OK(status)) {
3154
werr = ntstatus_to_werror(status);
3158
if (is_valid_policy_hnd(&group_handle)) {
3159
rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3166
if (is_valid_policy_hnd(&group_handle)) {
3167
rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3170
if (ctx->disable_policy_handle_cache) {
3171
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
3172
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
3178
/****************************************************************
3179
****************************************************************/
3181
WERROR NetUserSetGroups_l(struct libnetapi_ctx *ctx,
3182
struct NetUserSetGroups *r)
3184
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserSetGroups);
3187
/****************************************************************
3188
****************************************************************/
3190
static NTSTATUS add_LOCALGROUP_USERS_INFO_X_buffer(TALLOC_CTX *mem_ctx,
3192
const char *group_name,
3194
uint32_t *num_entries)
3196
struct LOCALGROUP_USERS_INFO_0 u0;
3200
u0.lgrui0_name = talloc_strdup(mem_ctx, group_name);
3201
NT_STATUS_HAVE_NO_MEMORY(u0.lgrui0_name);
3203
ADD_TO_ARRAY(mem_ctx, struct LOCALGROUP_USERS_INFO_0, u0,
3204
(struct LOCALGROUP_USERS_INFO_0 **)buffer, num_entries);
3207
return NT_STATUS_INVALID_INFO_CLASS;
3210
return NT_STATUS_OK;
3213
/****************************************************************
3214
****************************************************************/
3216
WERROR NetUserGetLocalGroups_r(struct libnetapi_ctx *ctx,
3217
struct NetUserGetLocalGroups *r)
3219
struct rpc_pipe_client *pipe_cli = NULL;
3220
struct policy_handle connect_handle, domain_handle, user_handle,
3222
struct lsa_String lsa_account_name;
3223
struct dom_sid2 *domain_sid = NULL;
3224
struct samr_Ids user_rids, name_types;
3225
struct samr_RidWithAttributeArray *rid_array = NULL;
3226
struct lsa_Strings names;
3227
struct samr_Ids types;
3228
uint32_t *rids = NULL;
3229
size_t num_rids = 0;
3230
struct dom_sid user_sid;
3231
struct lsa_SidArray sid_array;
3232
struct samr_Ids domain_rids;
3233
struct samr_Ids builtin_rids;
3236
uint32_t entries_read = 0;
3238
NTSTATUS status = NT_STATUS_OK;
3241
ZERO_STRUCT(connect_handle);
3242
ZERO_STRUCT(domain_handle);
3244
if (!r->out.buffer) {
3245
return WERR_INVALID_PARAM;
3248
*r->out.buffer = NULL;
3249
*r->out.entries_read = 0;
3250
*r->out.total_entries = 0;
3252
switch (r->in.level) {
3257
return WERR_UNKNOWN_LEVEL;
3260
werr = libnetapi_open_pipe(ctx, r->in.server_name,
3261
&ndr_table_samr.syntax_id,
3263
if (!W_ERROR_IS_OK(werr)) {
3267
werr = libnetapi_samr_open_domain(ctx, pipe_cli,
3268
SAMR_ACCESS_ENUM_DOMAINS |
3269
SAMR_ACCESS_LOOKUP_DOMAIN,
3270
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
3271
SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
3275
if (!W_ERROR_IS_OK(werr)) {
3279
werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
3280
SAMR_ACCESS_ENUM_DOMAINS |
3281
SAMR_ACCESS_LOOKUP_DOMAIN,
3282
SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT |
3283
SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
3286
if (!W_ERROR_IS_OK(werr)) {
3290
init_lsa_String(&lsa_account_name, r->in.user_name);
3292
status = rpccli_samr_LookupNames(pipe_cli, ctx,
3298
if (!NT_STATUS_IS_OK(status)) {
3299
werr = ntstatus_to_werror(status);
3303
status = rpccli_samr_OpenUser(pipe_cli, ctx,
3305
SAMR_USER_ACCESS_GET_GROUPS,
3308
if (!NT_STATUS_IS_OK(status)) {
3309
werr = ntstatus_to_werror(status);
3313
status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
3316
if (!NT_STATUS_IS_OK(status)) {
3317
werr = ntstatus_to_werror(status);
3321
if (!sid_compose(&user_sid, domain_sid, user_rids.ids[0])) {
3326
sid_array.num_sids = rid_array->count + 1;
3327
sid_array.sids = TALLOC_ARRAY(ctx, struct lsa_SidPtr, sid_array.num_sids);
3328
if (!sid_array.sids) {
3333
sid_array.sids[0].sid = sid_dup_talloc(ctx, &user_sid);
3334
if (!sid_array.sids[0].sid) {
3339
for (i=0; i < rid_array->count; i++) {
3342
if (!sid_compose(&sid, domain_sid, rid_array->rids[i].rid)) {
3347
sid_array.sids[i+1].sid = sid_dup_talloc(ctx, &sid);
3348
if (!sid_array.sids[i+1].sid) {
3354
status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
3358
if (!NT_STATUS_IS_OK(status)) {
3359
werr = ntstatus_to_werror(status);
3363
for (i=0; i < domain_rids.count; i++) {
3364
if (!add_rid_to_array_unique(ctx, domain_rids.ids[i],
3365
&rids, &num_rids)) {
3371
status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
3375
if (!NT_STATUS_IS_OK(status)) {
3376
werr = ntstatus_to_werror(status);
3380
for (i=0; i < builtin_rids.count; i++) {
3381
if (!add_rid_to_array_unique(ctx, builtin_rids.ids[i],
3382
&rids, &num_rids)) {
3388
status = rpccli_samr_LookupRids(pipe_cli, ctx,
3394
if (!NT_STATUS_IS_OK(status)) {
3395
werr = ntstatus_to_werror(status);
3399
for (i=0; i < names.count; i++) {
3400
status = add_LOCALGROUP_USERS_INFO_X_buffer(ctx,
3402
names.names[i].string,
3405
if (!NT_STATUS_IS_OK(status)) {
3406
werr = ntstatus_to_werror(status);
3411
*r->out.entries_read = entries_read;
3412
*r->out.total_entries = entries_read;
3415
if (ctx->disable_policy_handle_cache) {
3416
libnetapi_samr_close_domain_handle(ctx, &domain_handle);
3417
libnetapi_samr_close_connect_handle(ctx, &connect_handle);
3423
/****************************************************************
3424
****************************************************************/
3426
WERROR NetUserGetLocalGroups_l(struct libnetapi_ctx *ctx,
3427
struct NetUserGetLocalGroups *r)
3429
LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetLocalGroups);
added
removed
source3/lib/netapi/user.c
