Context Navigation

← Previous Revision
Next Revision →
Blame
Revision Log

source: vendor/3.5.0/source3/lib/netapi/user.c

Visit:

Last change on this file was 414, checked in by Herwig Bauernfeind, 15 years ago
Samba 3.5.0: Initial import
File size: 88.8 KB

Line
1	/*
2	* Unix SMB/CIFS implementation.
3	* NetApi User Support
4	* Copyright (C) Guenther Deschner 2008
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 3 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, see <http://www.gnu.org/licenses/>.
18	*/
19
20	#include "includes.h"
21
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"
26	#include "../librpc/gen_ndr/cli_samr.h"
27
28	/****************************************************************
29	****************************************************************/
30
31	static void convert_USER_INFO_X_to_samr_user_info21(struct USER_INFO_X *infoX,
32	struct samr_UserInfo21 *info21)
33	{
34	uint32_t fields_present = 0;
35	struct samr_LogonHours zero_logon_hours;
36	struct lsa_BinaryString zero_parameters;
37	NTTIME password_age;
38
39	ZERO_STRUCTP(info21);
40	ZERO_STRUCT(zero_logon_hours);
41	ZERO_STRUCT(zero_parameters);
42
43	if (infoX->usriX_flags) {
44	fields_present \|= SAMR_FIELD_ACCT_FLAGS;
45	}
46	if (infoX->usriX_name) {
47	fields_present \|= SAMR_FIELD_ACCOUNT_NAME;
48	}
49	if (infoX->usriX_password) {
50	fields_present \|= SAMR_FIELD_NT_PASSWORD_PRESENT;
51	}
52	if (infoX->usriX_flags) {
53	fields_present \|= SAMR_FIELD_ACCT_FLAGS;
54	}
55	if (infoX->usriX_name) {
56	fields_present \|= SAMR_FIELD_FULL_NAME;
57	}
58	if (infoX->usriX_home_dir) {
59	fields_present \|= SAMR_FIELD_HOME_DIRECTORY;
60	}
61	if (infoX->usriX_script_path) {
62	fields_present \|= SAMR_FIELD_LOGON_SCRIPT;
63	}
64	if (infoX->usriX_comment) {
65	fields_present \|= SAMR_FIELD_DESCRIPTION;
66	}
67	if (infoX->usriX_password_age) {
68	fields_present \|= SAMR_FIELD_FORCE_PWD_CHANGE;
69	}
70	if (infoX->usriX_full_name) {
71	fields_present \|= SAMR_FIELD_FULL_NAME;
72	}
73	if (infoX->usriX_usr_comment) {
74	fields_present \|= SAMR_FIELD_COMMENT;
75	}
76	if (infoX->usriX_profile) {
77	fields_present \|= SAMR_FIELD_PROFILE_PATH;
78	}
79	if (infoX->usriX_home_dir_drive) {
80	fields_present \|= SAMR_FIELD_HOME_DRIVE;
81	}
82	if (infoX->usriX_primary_group_id) {
83	fields_present \|= SAMR_FIELD_PRIMARY_GID;
84	}
85	if (infoX->usriX_country_code) {
86	fields_present \|= SAMR_FIELD_COUNTRY_CODE;
87	}
88	if (infoX->usriX_workstations) {
89	fields_present \|= SAMR_FIELD_WORKSTATIONS;
90	}
91
92	unix_to_nt_time_abs(&password_age, infoX->usriX_password_age);
93
94	/* TODO: infoX->usriX_priv */
95
96	info21->last_logon = 0;
97	info21->last_logoff = 0;
98	info21->last_password_change = 0;
99	info21->acct_expiry = 0;
100	info21->allow_password_change = 0;
101	info21->force_password_change = 0;
102	info21->account_name.string = infoX->usriX_name;
103	info21->full_name.string = infoX->usriX_full_name;
104	info21->home_directory.string = infoX->usriX_home_dir;
105	info21->home_drive.string = infoX->usriX_home_dir_drive;
106	info21->logon_script.string = infoX->usriX_script_path;
107	info21->profile_path.string = infoX->usriX_profile;
108	info21->description.string = infoX->usriX_comment;
109	info21->workstations.string = infoX->usriX_workstations;
110	info21->comment.string = infoX->usriX_usr_comment;
111	info21->parameters = zero_parameters;
112	info21->lm_owf_password = zero_parameters;
113	info21->nt_owf_password = zero_parameters;
114	info21->unknown3.string = NULL;
115	info21->buf_count = 0;
116	info21->buffer = NULL;
117	info21->rid = infoX->usriX_user_id;
118	info21->primary_gid = infoX->usriX_primary_group_id;
119	info21->acct_flags = infoX->usriX_flags;
120	info21->fields_present = fields_present;
121	info21->logon_hours = zero_logon_hours;
122	info21->bad_password_count = infoX->usriX_bad_pw_count;
123	info21->logon_count = infoX->usriX_num_logons;
124	info21->country_code = infoX->usriX_country_code;
125	info21->code_page = infoX->usriX_code_page;
126	info21->lm_password_set = 0;
127	info21->nt_password_set = 0;
128	info21->password_expired = infoX->usriX_password_expired;
129	info21->unknown4 = 0;
130	}
131
132	/****************************************************************
133	****************************************************************/
134
135	static NTSTATUS construct_USER_INFO_X(uint32_t level,
136	uint8_t *buffer,
137	struct USER_INFO_X *uX)
138	{
139	struct USER_INFO_0 *u0 = NULL;
140	struct USER_INFO_1 *u1 = NULL;
141	struct USER_INFO_2 *u2 = NULL;
142	struct USER_INFO_3 *u3 = NULL;
143	struct USER_INFO_1003 *u1003 = NULL;
144	struct USER_INFO_1006 *u1006 = NULL;
145	struct USER_INFO_1007 *u1007 = NULL;
146	struct USER_INFO_1009 *u1009 = NULL;
147	struct USER_INFO_1011 *u1011 = NULL;
148	struct USER_INFO_1012 *u1012 = NULL;
149	struct USER_INFO_1014 *u1014 = NULL;
150	struct USER_INFO_1024 *u1024 = NULL;
151	struct USER_INFO_1051 *u1051 = NULL;
152	struct USER_INFO_1052 *u1052 = NULL;
153	struct USER_INFO_1053 *u1053 = NULL;
154
155	if (!buffer \|\| !uX) {
156	return NT_STATUS_INVALID_PARAMETER;
157	}
158
159	ZERO_STRUCTP(uX);
160
161	switch (level) {
162	case 0:
163	u0 = (struct USER_INFO_0 *)buffer;
164	uX->usriX_name = u0->usri0_name;
165	break;
166	case 1:
167	u1 = (struct USER_INFO_1 *)buffer;
168	uX->usriX_name = u1->usri1_name;
169	uX->usriX_password = u1->usri1_password;
170	uX->usriX_password_age = u1->usri1_password_age;
171	uX->usriX_priv = u1->usri1_priv;
172	uX->usriX_home_dir = u1->usri1_home_dir;
173	uX->usriX_comment = u1->usri1_comment;
174	uX->usriX_flags = u1->usri1_flags;
175	uX->usriX_script_path = u1->usri1_script_path;
176	break;
177	case 2:
178	u2 = (struct USER_INFO_2 *)buffer;
179	uX->usriX_name = u2->usri2_name;
180	uX->usriX_password = u2->usri2_password;
181	uX->usriX_password_age = u2->usri2_password_age;
182	uX->usriX_priv = u2->usri2_priv;
183	uX->usriX_home_dir = u2->usri2_home_dir;
184	uX->usriX_comment = u2->usri2_comment;
185	uX->usriX_flags = u2->usri2_flags;
186	uX->usriX_script_path = u2->usri2_script_path;
187	uX->usriX_auth_flags = u2->usri2_auth_flags;
188	uX->usriX_full_name = u2->usri2_full_name;
189	uX->usriX_usr_comment = u2->usri2_usr_comment;
190	uX->usriX_parms = u2->usri2_parms;
191	uX->usriX_workstations = u2->usri2_workstations;
192	uX->usriX_last_logon = u2->usri2_last_logon;
193	uX->usriX_last_logoff = u2->usri2_last_logoff;
194	uX->usriX_acct_expires = u2->usri2_acct_expires;
195	uX->usriX_max_storage = u2->usri2_max_storage;
196	uX->usriX_units_per_week= u2->usri2_units_per_week;
197	uX->usriX_logon_hours = u2->usri2_logon_hours;
198	uX->usriX_bad_pw_count = u2->usri2_bad_pw_count;
199	uX->usriX_num_logons = u2->usri2_num_logons;
200	uX->usriX_logon_server = u2->usri2_logon_server;
201	uX->usriX_country_code = u2->usri2_country_code;
202	uX->usriX_code_page = u2->usri2_code_page;
203	break;
204	case 3:
205	u3 = (struct USER_INFO_3 *)buffer;
206	uX->usriX_name = u3->usri3_name;
207	uX->usriX_password_age = u3->usri3_password_age;
208	uX->usriX_priv = u3->usri3_priv;
209	uX->usriX_home_dir = u3->usri3_home_dir;
210	uX->usriX_comment = u3->usri3_comment;
211	uX->usriX_flags = u3->usri3_flags;
212	uX->usriX_script_path = u3->usri3_script_path;
213	uX->usriX_auth_flags = u3->usri3_auth_flags;
214	uX->usriX_full_name = u3->usri3_full_name;
215	uX->usriX_usr_comment = u3->usri3_usr_comment;
216	uX->usriX_parms = u3->usri3_parms;
217	uX->usriX_workstations = u3->usri3_workstations;
218	uX->usriX_last_logon = u3->usri3_last_logon;
219	uX->usriX_last_logoff = u3->usri3_last_logoff;
220	uX->usriX_acct_expires = u3->usri3_acct_expires;
221	uX->usriX_max_storage = u3->usri3_max_storage;
222	uX->usriX_units_per_week= u3->usri3_units_per_week;
223	uX->usriX_logon_hours = u3->usri3_logon_hours;
224	uX->usriX_bad_pw_count = u3->usri3_bad_pw_count;
225	uX->usriX_num_logons = u3->usri3_num_logons;
226	uX->usriX_logon_server = u3->usri3_logon_server;
227	uX->usriX_country_code = u3->usri3_country_code;
228	uX->usriX_code_page = u3->usri3_code_page;
229	uX->usriX_user_id = u3->usri3_user_id;
230	uX->usriX_primary_group_id = u3->usri3_primary_group_id;
231	uX->usriX_profile = u3->usri3_profile;
232	uX->usriX_home_dir_drive = u3->usri3_home_dir_drive;
233	uX->usriX_password_expired = u3->usri3_password_expired;
234	break;
235	case 1003:
236	u1003 = (struct USER_INFO_1003 *)buffer;
237	uX->usriX_password = u1003->usri1003_password;
238	break;
239	case 1006:
240	u1006 = (struct USER_INFO_1006 *)buffer;
241	uX->usriX_home_dir = u1006->usri1006_home_dir;
242	break;
243	case 1007:
244	u1007 = (struct USER_INFO_1007 *)buffer;
245	uX->usriX_comment = u1007->usri1007_comment;
246	break;
247	case 1009:
248	u1009 = (struct USER_INFO_1009 *)buffer;
249	uX->usriX_script_path = u1009->usri1009_script_path;
250	break;
251	case 1011:
252	u1011 = (struct USER_INFO_1011 *)buffer;
253	uX->usriX_full_name = u1011->usri1011_full_name;
254	break;
255	case 1012:
256	u1012 = (struct USER_INFO_1012 *)buffer;
257	uX->usriX_usr_comment = u1012->usri1012_usr_comment;
258	break;
259	case 1014:
260	u1014 = (struct USER_INFO_1014 *)buffer;
261	uX->usriX_workstations = u1014->usri1014_workstations;
262	break;
263	case 1024:
264	u1024 = (struct USER_INFO_1024 *)buffer;
265	uX->usriX_country_code = u1024->usri1024_country_code;
266	break;
267	case 1051:
268	u1051 = (struct USER_INFO_1051 *)buffer;
269	uX->usriX_primary_group_id = u1051->usri1051_primary_group_id;
270	break;
271	case 1052:
272	u1052 = (struct USER_INFO_1052 *)buffer;
273	uX->usriX_profile = u1052->usri1052_profile;
274	break;
275	case 1053:
276	u1053 = (struct USER_INFO_1053 *)buffer;
277	uX->usriX_home_dir_drive = u1053->usri1053_home_dir_drive;
278	break;
279	case 4:
280	default:
281	return NT_STATUS_INVALID_INFO_CLASS;
282	}
283
284	return NT_STATUS_OK;
285	}
286
287	/****************************************************************
288	****************************************************************/
289
290	static NTSTATUS set_user_info_USER_INFO_X(TALLOC_CTX *ctx,
291	struct rpc_pipe_client *pipe_cli,
292	DATA_BLOB *session_key,
293	struct policy_handle *user_handle,
294	struct USER_INFO_X *uX)
295	{
296	union samr_UserInfo user_info;
297	struct samr_UserInfo21 info21;
298	NTSTATUS status;
299
300	if (!uX) {
301	return NT_STATUS_INVALID_PARAMETER;
302	}
303
304	convert_USER_INFO_X_to_samr_user_info21(uX, &info21);
305
306	ZERO_STRUCT(user_info);
307
308	if (uX->usriX_password) {
309
310	user_info.info25.info = info21;
311
312	init_samr_CryptPasswordEx(uX->usriX_password,
313	session_key,
314	&user_info.info25.password);
315
316	status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
317	user_handle,
318	25,
319	&user_info);
320
321	if (NT_STATUS_EQUAL(status, NT_STATUS(DCERPC_FAULT_INVALID_TAG))) {
322
323	user_info.info23.info = info21;
324
325	init_samr_CryptPassword(uX->usriX_password,
326	session_key,
327	&user_info.info23.password);
328
329	status = rpccli_samr_SetUserInfo2(pipe_cli, ctx,
330	user_handle,
331	23,
332	&user_info);
333	}
334	} else {
335
336	user_info.info21 = info21;
337
338	status = rpccli_samr_SetUserInfo(pipe_cli, ctx,
339	user_handle,
340	21,
341	&user_info);
342	}
343
344	return status;
345	}
346
347	/****************************************************************
348	****************************************************************/
349
350	WERROR NetUserAdd_r(struct libnetapi_ctx *ctx,
351	struct NetUserAdd *r)
352	{
353	struct rpc_pipe_client *pipe_cli = NULL;
354	NTSTATUS status;
355	WERROR werr;
356	struct policy_handle connect_handle, domain_handle, user_handle;
357	struct lsa_String lsa_account_name;
358	struct dom_sid2 *domain_sid = NULL;
359	union samr_UserInfo *user_info = NULL;
360	struct samr_PwInfo pw_info;
361	uint32_t access_granted = 0;
362	uint32_t rid = 0;
363	struct USER_INFO_X uX;
364
365	ZERO_STRUCT(connect_handle);
366	ZERO_STRUCT(domain_handle);
367	ZERO_STRUCT(user_handle);
368
369	if (!r->in.buffer) {
370	return WERR_INVALID_PARAM;
371	}
372
373	switch (r->in.level) {
374	case 1:
375	break;
376	case 2:
377	case 3:
378	case 4:
379	default:
380	werr = WERR_NOT_SUPPORTED;
381	goto done;
382	}
383
384	werr = libnetapi_open_pipe(ctx, r->in.server_name,
385	&ndr_table_samr.syntax_id,
386	&pipe_cli);
387	if (!W_ERROR_IS_OK(werr)) {
388	goto done;
389	}
390
391	status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
392	if (!NT_STATUS_IS_OK(status)) {
393	werr = ntstatus_to_werror(status);
394	goto done;
395	}
396
397	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
398	SAMR_ACCESS_ENUM_DOMAINS \|
399	SAMR_ACCESS_LOOKUP_DOMAIN,
400	SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 \|
401	SAMR_DOMAIN_ACCESS_CREATE_USER \|
402	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
403	&connect_handle,
404	&domain_handle,
405	&domain_sid);
406	if (!W_ERROR_IS_OK(werr)) {
407	goto done;
408	}
409
410	init_lsa_String(&lsa_account_name, uX.usriX_name);
411
412	status = rpccli_samr_CreateUser2(pipe_cli, ctx,
413	&domain_handle,
414	&lsa_account_name,
415	ACB_NORMAL,
416	SEC_STD_WRITE_DAC \|
417	SEC_STD_DELETE \|
418	SAMR_USER_ACCESS_SET_PASSWORD \|
419	SAMR_USER_ACCESS_SET_ATTRIBUTES \|
420	SAMR_USER_ACCESS_GET_ATTRIBUTES,
421	&user_handle,
422	&access_granted,
423	&rid);
424	if (!NT_STATUS_IS_OK(status)) {
425	werr = ntstatus_to_werror(status);
426	goto done;
427	}
428
429	status = rpccli_samr_QueryUserInfo(pipe_cli, ctx,
430	&user_handle,
431	16,
432	&user_info);
433	if (!NT_STATUS_IS_OK(status)) {
434	werr = ntstatus_to_werror(status);
435	goto done;
436	}
437
438	if (!(user_info->info16.acct_flags & ACB_NORMAL)) {
439	werr = WERR_INVALID_PARAM;
440	goto done;
441	}
442
443	status = rpccli_samr_GetUserPwInfo(pipe_cli, ctx,
444	&user_handle,
445	&pw_info);
446	if (!NT_STATUS_IS_OK(status)) {
447	werr = ntstatus_to_werror(status);
448	goto done;
449	}
450
451	uX.usriX_flags \|= ACB_NORMAL;
452
453	status = set_user_info_USER_INFO_X(ctx, pipe_cli,
454	&pipe_cli->auth->user_session_key,
455	&user_handle,
456	&uX);
457	if (!NT_STATUS_IS_OK(status)) {
458	werr = ntstatus_to_werror(status);
459	goto failed;
460	}
461
462	werr = WERR_OK;
463	goto done;
464
465	failed:
466	rpccli_samr_DeleteUser(pipe_cli, ctx,
467	&user_handle);
468
469	done:
470	if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
471	rpccli_samr_Close(pipe_cli, ctx, &user_handle);
472	}
473
474	if (ctx->disable_policy_handle_cache) {
475	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
476	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
477	}
478
479	return werr;
480	}
481
482	/****************************************************************
483	****************************************************************/
484
485	WERROR NetUserAdd_l(struct libnetapi_ctx *ctx,
486	struct NetUserAdd *r)
487	{
488	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserAdd);
489	}
490
491	/****************************************************************
492	****************************************************************/
493
494	WERROR NetUserDel_r(struct libnetapi_ctx *ctx,
495	struct NetUserDel *r)
496	{
497	struct rpc_pipe_client *pipe_cli = NULL;
498	NTSTATUS status;
499	WERROR werr;
500	struct policy_handle 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;
505
506	ZERO_STRUCT(connect_handle);
507	ZERO_STRUCT(builtin_handle);
508	ZERO_STRUCT(domain_handle);
509	ZERO_STRUCT(user_handle);
510
511	werr = libnetapi_open_pipe(ctx, r->in.server_name,
512	&ndr_table_samr.syntax_id,
513	&pipe_cli);
514
515	if (!W_ERROR_IS_OK(werr)) {
516	goto done;
517	}
518
519	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
520	SAMR_ACCESS_ENUM_DOMAINS \|
521	SAMR_ACCESS_LOOKUP_DOMAIN,
522	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
523	&connect_handle,
524	&domain_handle,
525	&domain_sid);
526	if (!W_ERROR_IS_OK(werr)) {
527	goto done;
528	}
529
530	status = rpccli_samr_OpenDomain(pipe_cli, ctx,
531	&connect_handle,
532	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
533	CONST_DISCARD(DOM_SID *, &global_sid_Builtin),
534	&builtin_handle);
535	if (!NT_STATUS_IS_OK(status)) {
536	werr = ntstatus_to_werror(status);
537	goto done;
538	}
539
540	init_lsa_String(&lsa_account_name, r->in.user_name);
541
542	status = rpccli_samr_LookupNames(pipe_cli, ctx,
543	&domain_handle,
544	1,
545	&lsa_account_name,
546	&user_rids,
547	&name_types);
548	if (!NT_STATUS_IS_OK(status)) {
549	werr = ntstatus_to_werror(status);
550	goto done;
551	}
552
553	status = rpccli_samr_OpenUser(pipe_cli, ctx,
554	&domain_handle,
555	SEC_STD_DELETE,
556	user_rids.ids[0],
557	&user_handle);
558	if (!NT_STATUS_IS_OK(status)) {
559	werr = ntstatus_to_werror(status);
560	goto done;
561	}
562
563	sid_compose(&user_sid, domain_sid, user_rids.ids[0]);
564
565	status = rpccli_samr_RemoveMemberFromForeignDomain(pipe_cli, ctx,
566	&builtin_handle,
567	&user_sid);
568	if (!NT_STATUS_IS_OK(status)) {
569	werr = ntstatus_to_werror(status);
570	goto done;
571	}
572
573	status = rpccli_samr_DeleteUser(pipe_cli, ctx,
574	&user_handle);
575	if (!NT_STATUS_IS_OK(status)) {
576	werr = ntstatus_to_werror(status);
577	goto done;
578	}
579
580	werr = WERR_OK;
581
582	done:
583	if (is_valid_policy_hnd(&user_handle)) {
584	rpccli_samr_Close(pipe_cli, ctx, &user_handle);
585	}
586
587	if (ctx->disable_policy_handle_cache) {
588	libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
589	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
590	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
591	}
592
593	return werr;
594	}
595
596	/****************************************************************
597	****************************************************************/
598
599	WERROR NetUserDel_l(struct libnetapi_ctx *ctx,
600	struct NetUserDel *r)
601	{
602	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserDel);
603	}
604
605	/****************************************************************
606	****************************************************************/
607
608	static NTSTATUS libnetapi_samr_lookup_user(TALLOC_CTX *mem_ctx,
609	struct rpc_pipe_client *pipe_cli,
610	struct policy_handle *domain_handle,
611	struct policy_handle *builtin_handle,
612	const char *user_name,
613	const struct dom_sid *domain_sid,
614	uint32_t rid,
615	uint32_t level,
616	struct samr_UserInfo21 **info21,
617	struct sec_desc_buf **sec_desc,
618	uint32_t *auth_flag_p)
619	{
620	NTSTATUS status;
621
622	struct policy_handle user_handle;
623	union samr_UserInfo *user_info = NULL;
624	struct samr_RidWithAttributeArray *rid_array = NULL;
625	uint32_t access_mask = SEC_STD_READ_CONTROL \|
626	SAMR_USER_ACCESS_GET_ATTRIBUTES \|
627	SAMR_USER_ACCESS_GET_NAME_ETC;
628
629	ZERO_STRUCT(user_handle);
630
631	switch (level) {
632	case 0:
633	break;
634	case 1:
635	access_mask \|= SAMR_USER_ACCESS_GET_LOGONINFO \|
636	SAMR_USER_ACCESS_GET_GROUPS;
637	break;
638	case 2:
639	case 3:
640	case 4:
641	case 11:
642	access_mask \|= SAMR_USER_ACCESS_GET_LOGONINFO \|
643	SAMR_USER_ACCESS_GET_GROUPS \|
644	SAMR_USER_ACCESS_GET_LOCALE;
645	break;
646	case 10:
647	case 20:
648	case 23:
649	break;
650	default:
651	return NT_STATUS_INVALID_LEVEL;
652	}
653
654	if (level == 0) {
655	return NT_STATUS_OK;
656	}
657
658	status = rpccli_samr_OpenUser(pipe_cli, mem_ctx,
659	domain_handle,
660	access_mask,
661	rid,
662	&user_handle);
663	if (!NT_STATUS_IS_OK(status)) {
664	goto done;
665	}
666
667	status = rpccli_samr_QueryUserInfo(pipe_cli, mem_ctx,
668	&user_handle,
669	21,
670	&user_info);
671	if (!NT_STATUS_IS_OK(status)) {
672	goto done;
673	}
674
675	status = rpccli_samr_QuerySecurity(pipe_cli, mem_ctx,
676	&user_handle,
677	SECINFO_DACL,
678	sec_desc);
679	if (!NT_STATUS_IS_OK(status)) {
680	goto done;
681	}
682
683	if (access_mask & SAMR_USER_ACCESS_GET_GROUPS) {
684
685	struct lsa_SidArray sid_array;
686	struct samr_Ids alias_rids;
687	int i;
688	uint32_t auth_flag = 0;
689	struct dom_sid sid;
690
691	status = rpccli_samr_GetGroupsForUser(pipe_cli, mem_ctx,
692	&user_handle,
693	&rid_array);
694	if (!NT_STATUS_IS_OK(status)) {
695	goto done;
696	}
697
698	sid_array.num_sids = rid_array->count + 1;
699	sid_array.sids = talloc_array(mem_ctx, struct lsa_SidPtr,
700	sid_array.num_sids);
701	NT_STATUS_HAVE_NO_MEMORY(sid_array.sids);
702
703	for (i=0; i<rid_array->count; i++) {
704	sid_compose(&sid, domain_sid, rid_array->rids[i].rid);
705	sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
706	NT_STATUS_HAVE_NO_MEMORY(sid_array.sids[i].sid);
707	}
708
709	sid_compose(&sid, domain_sid, rid);
710	sid_array.sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
711	NT_STATUS_HAVE_NO_MEMORY(sid_array.sids[i].sid);
712
713	status = rpccli_samr_GetAliasMembership(pipe_cli, mem_ctx,
714	builtin_handle,
715	&sid_array,
716	&alias_rids);
717	if (!NT_STATUS_IS_OK(status)) {
718	goto done;
719	}
720
721	for (i=0; i<alias_rids.count; i++) {
722	switch (alias_rids.ids[i]) {
723	case 550: /* Print Operators */
724	auth_flag \|= AF_OP_PRINT;
725	break;
726	case 549: /* Server Operators */
727	auth_flag \|= AF_OP_SERVER;
728	break;
729	case 548: /* Account Operators */
730	auth_flag \|= AF_OP_ACCOUNTS;
731	break;
732	default:
733	break;
734	}
735	}
736
737	if (auth_flag_p) {
738	*auth_flag_p = auth_flag;
739	}
740	}
741
742	*info21 = &user_info->info21;
743
744	done:
745	if (is_valid_policy_hnd(&user_handle)) {
746	rpccli_samr_Close(pipe_cli, mem_ctx, &user_handle);
747	}
748
749	return status;
750	}
751
752	/****************************************************************
753	****************************************************************/
754
755	static uint32_t samr_rid_to_priv_level(uint32_t rid)
756	{
757	switch (rid) {
758	case DOMAIN_RID_ADMINISTRATOR:
759	return USER_PRIV_ADMIN;
760	case DOMAIN_RID_GUEST:
761	return USER_PRIV_GUEST;
762	default:
763	return USER_PRIV_USER;
764	}
765	}
766
767	/****************************************************************
768	****************************************************************/
769
770	static uint32_t samr_acb_flags_to_netapi_flags(uint32_t acb)
771	{
772	uint32_t fl = UF_SCRIPT; /* god knows why */
773
774	fl \|= ds_acb2uf(acb);
775
776	return fl;
777	}
778
779	/****************************************************************
780	****************************************************************/
781
782	static NTSTATUS info21_to_USER_INFO_1(TALLOC_CTX *mem_ctx,
783	const struct samr_UserInfo21 *i21,
784	struct USER_INFO_1 *i)
785	{
786	ZERO_STRUCTP(i);
787	i->usri1_name = talloc_strdup(mem_ctx, i21->account_name.string);
788	NT_STATUS_HAVE_NO_MEMORY(i->usri1_name);
789	i->usri1_password = NULL;
790	i->usri1_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
791	i->usri1_priv = samr_rid_to_priv_level(i21->rid);
792	i->usri1_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
793	i->usri1_comment = talloc_strdup(mem_ctx, i21->description.string);
794	i->usri1_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
795	i->usri1_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
796
797	return NT_STATUS_OK;
798	}
799
800	/****************************************************************
801	****************************************************************/
802
803	static NTSTATUS info21_to_USER_INFO_2(TALLOC_CTX *mem_ctx,
804	const struct samr_UserInfo21 *i21,
805	uint32_t auth_flag,
806	struct USER_INFO_2 *i)
807	{
808	ZERO_STRUCTP(i);
809
810	i->usri2_name = talloc_strdup(mem_ctx, i21->account_name.string);
811	NT_STATUS_HAVE_NO_MEMORY(i->usri2_name);
812	i->usri2_password = NULL;
813	i->usri2_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
814	i->usri2_priv = samr_rid_to_priv_level(i21->rid);
815	i->usri2_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
816	i->usri2_comment = talloc_strdup(mem_ctx, i21->description.string);
817	i->usri2_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
818	i->usri2_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
819	i->usri2_auth_flags = auth_flag;
820	i->usri2_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
821	i->usri2_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
822	i->usri2_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
823	i->usri2_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
824	i->usri2_last_logon = nt_time_to_unix(i21->last_logon);
825	i->usri2_last_logoff = nt_time_to_unix(i21->last_logoff);
826	i->usri2_acct_expires = nt_time_to_unix(i21->acct_expiry);
827	i->usri2_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
828	i->usri2_units_per_week = i21->logon_hours.units_per_week;
829	i->usri2_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
830	i->usri2_bad_pw_count = i21->bad_password_count;
831	i->usri2_num_logons = i21->logon_count;
832	i->usri2_logon_server = talloc_strdup(mem_ctx, "\\\\*");
833	i->usri2_country_code = i21->country_code;
834	i->usri2_code_page = i21->code_page;
835
836	return NT_STATUS_OK;
837	}
838
839	/****************************************************************
840	****************************************************************/
841
842	static NTSTATUS info21_to_USER_INFO_3(TALLOC_CTX *mem_ctx,
843	const struct samr_UserInfo21 *i21,
844	uint32_t auth_flag,
845	struct USER_INFO_3 *i)
846	{
847	ZERO_STRUCTP(i);
848
849	i->usri3_name = talloc_strdup(mem_ctx, i21->account_name.string);
850	NT_STATUS_HAVE_NO_MEMORY(i->usri3_name);
851	i->usri3_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
852	i->usri3_priv = samr_rid_to_priv_level(i21->rid);
853	i->usri3_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
854	i->usri3_comment = talloc_strdup(mem_ctx, i21->description.string);
855	i->usri3_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
856	i->usri3_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
857	i->usri3_auth_flags = auth_flag;
858	i->usri3_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
859	i->usri3_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
860	i->usri3_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
861	i->usri3_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
862	i->usri3_last_logon = nt_time_to_unix(i21->last_logon);
863	i->usri3_last_logoff = nt_time_to_unix(i21->last_logoff);
864	i->usri3_acct_expires = nt_time_to_unix(i21->acct_expiry);
865	i->usri3_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
866	i->usri3_units_per_week = i21->logon_hours.units_per_week;
867	i->usri3_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
868	i->usri3_bad_pw_count = i21->bad_password_count;
869	i->usri3_num_logons = i21->logon_count;
870	i->usri3_logon_server = talloc_strdup(mem_ctx, "\\\\*");
871	i->usri3_country_code = i21->country_code;
872	i->usri3_code_page = i21->code_page;
873	i->usri3_user_id = i21->rid;
874	i->usri3_primary_group_id = i21->primary_gid;
875	i->usri3_profile = talloc_strdup(mem_ctx, i21->profile_path.string);
876	i->usri3_home_dir_drive = talloc_strdup(mem_ctx, i21->home_drive.string);
877	i->usri3_password_expired = i21->password_expired;
878
879	return NT_STATUS_OK;
880	}
881
882	/****************************************************************
883	****************************************************************/
884
885	static NTSTATUS info21_to_USER_INFO_4(TALLOC_CTX *mem_ctx,
886	const struct samr_UserInfo21 *i21,
887	uint32_t auth_flag,
888	struct dom_sid *domain_sid,
889	struct USER_INFO_4 *i)
890	{
891	struct dom_sid sid;
892
893	ZERO_STRUCTP(i);
894
895	i->usri4_name = talloc_strdup(mem_ctx, i21->account_name.string);
896	NT_STATUS_HAVE_NO_MEMORY(i->usri4_name);
897	i->usri4_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
898	i->usri4_password = NULL;
899	i->usri4_priv = samr_rid_to_priv_level(i21->rid);
900	i->usri4_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
901	i->usri4_comment = talloc_strdup(mem_ctx, i21->description.string);
902	i->usri4_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
903	i->usri4_script_path = talloc_strdup(mem_ctx, i21->logon_script.string);
904	i->usri4_auth_flags = auth_flag;
905	i->usri4_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
906	i->usri4_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
907	i->usri4_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
908	i->usri4_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
909	i->usri4_last_logon = nt_time_to_unix(i21->last_logon);
910	i->usri4_last_logoff = nt_time_to_unix(i21->last_logoff);
911	i->usri4_acct_expires = nt_time_to_unix(i21->acct_expiry);
912	i->usri4_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
913	i->usri4_units_per_week = i21->logon_hours.units_per_week;
914	i->usri4_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
915	i->usri4_bad_pw_count = i21->bad_password_count;
916	i->usri4_num_logons = i21->logon_count;
917	i->usri4_logon_server = talloc_strdup(mem_ctx, "\\\\*");
918	i->usri4_country_code = i21->country_code;
919	i->usri4_code_page = i21->code_page;
920	if (!sid_compose(&sid, domain_sid, i21->rid)) {
921	return NT_STATUS_NO_MEMORY;
922	}
923	i->usri4_user_sid = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
924	i->usri4_primary_group_id = i21->primary_gid;
925	i->usri4_profile = talloc_strdup(mem_ctx, i21->profile_path.string);
926	i->usri4_home_dir_drive = talloc_strdup(mem_ctx, i21->home_drive.string);
927	i->usri4_password_expired = i21->password_expired;
928
929	return NT_STATUS_OK;
930	}
931
932	/****************************************************************
933	****************************************************************/
934
935	static NTSTATUS info21_to_USER_INFO_10(TALLOC_CTX *mem_ctx,
936	const struct samr_UserInfo21 *i21,
937	struct USER_INFO_10 *i)
938	{
939	ZERO_STRUCTP(i);
940
941	i->usri10_name = talloc_strdup(mem_ctx, i21->account_name.string);
942	NT_STATUS_HAVE_NO_MEMORY(i->usri10_name);
943	i->usri10_comment = talloc_strdup(mem_ctx, i21->description.string);
944	i->usri10_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
945	i->usri10_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
946
947	return NT_STATUS_OK;
948	}
949
950	/****************************************************************
951	****************************************************************/
952
953	static NTSTATUS info21_to_USER_INFO_11(TALLOC_CTX *mem_ctx,
954	const struct samr_UserInfo21 *i21,
955	uint32_t auth_flag,
956	struct USER_INFO_11 *i)
957	{
958	ZERO_STRUCTP(i);
959
960	i->usri11_name = talloc_strdup(mem_ctx, i21->account_name.string);
961	NT_STATUS_HAVE_NO_MEMORY(i->usri11_name);
962	i->usri11_comment = talloc_strdup(mem_ctx, i21->description.string);
963	i->usri11_usr_comment = talloc_strdup(mem_ctx, i21->comment.string);
964	i->usri11_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
965	i->usri11_priv = samr_rid_to_priv_level(i21->rid);
966	i->usri11_auth_flags = auth_flag;
967	i->usri11_password_age = time(NULL) - nt_time_to_unix(i21->last_password_change);
968	i->usri11_home_dir = talloc_strdup(mem_ctx, i21->home_directory.string);
969	i->usri11_parms = talloc_strndup(mem_ctx, (const char *)i21->parameters.array, i21->parameters.size/2);
970	i->usri11_last_logon = nt_time_to_unix(i21->last_logon);
971	i->usri11_last_logoff = nt_time_to_unix(i21->last_logoff);
972	i->usri11_bad_pw_count = i21->bad_password_count;
973	i->usri11_num_logons = i21->logon_count;
974	i->usri11_logon_server = talloc_strdup(mem_ctx, "\\\\*");
975	i->usri11_country_code = i21->country_code;
976	i->usri11_workstations = talloc_strdup(mem_ctx, i21->workstations.string);
977	i->usri11_max_storage = USER_MAXSTORAGE_UNLIMITED; /* FIXME */
978	i->usri11_units_per_week = i21->logon_hours.units_per_week;
979	i->usri11_logon_hours = (uint8_t *)talloc_memdup(mem_ctx, i21->logon_hours.bits, 21);
980	i->usri11_code_page = i21->code_page;
981
982	return NT_STATUS_OK;
983	}
984
985	/****************************************************************
986	****************************************************************/
987
988	static NTSTATUS info21_to_USER_INFO_20(TALLOC_CTX *mem_ctx,
989	const struct samr_UserInfo21 *i21,
990	struct USER_INFO_20 *i)
991	{
992	ZERO_STRUCTP(i);
993
994	i->usri20_name = talloc_strdup(mem_ctx, i21->account_name.string);
995	NT_STATUS_HAVE_NO_MEMORY(i->usri20_name);
996	i->usri20_comment = talloc_strdup(mem_ctx, i21->description.string);
997	i->usri20_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
998	i->usri20_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
999	i->usri20_user_id = i21->rid;
1000
1001	return NT_STATUS_OK;
1002	}
1003
1004	/****************************************************************
1005	****************************************************************/
1006
1007	static NTSTATUS info21_to_USER_INFO_23(TALLOC_CTX *mem_ctx,
1008	const struct samr_UserInfo21 *i21,
1009	struct dom_sid *domain_sid,
1010	struct USER_INFO_23 *i)
1011	{
1012	struct dom_sid sid;
1013
1014	ZERO_STRUCTP(i);
1015
1016	i->usri23_name = talloc_strdup(mem_ctx, i21->account_name.string);
1017	NT_STATUS_HAVE_NO_MEMORY(i->usri23_name);
1018	i->usri23_comment = talloc_strdup(mem_ctx, i21->description.string);
1019	i->usri23_full_name = talloc_strdup(mem_ctx, i21->full_name.string);
1020	i->usri23_flags = samr_acb_flags_to_netapi_flags(i21->acct_flags);
1021	if (!sid_compose(&sid, domain_sid, i21->rid)) {
1022	return NT_STATUS_NO_MEMORY;
1023	}
1024	i->usri23_user_sid = (struct domsid *)sid_dup_talloc(mem_ctx, &sid);
1025
1026	return NT_STATUS_OK;
1027	}
1028
1029	/****************************************************************
1030	****************************************************************/
1031
1032	static NTSTATUS libnetapi_samr_lookup_user_map_USER_INFO(TALLOC_CTX *mem_ctx,
1033	struct rpc_pipe_client *pipe_cli,
1034	struct dom_sid *domain_sid,
1035	struct policy_handle *domain_handle,
1036	struct policy_handle *builtin_handle,
1037	const char *user_name,
1038	uint32_t rid,
1039	uint32_t level,
1040	uint8_t **buffer,
1041	uint32_t *num_entries)
1042	{
1043	NTSTATUS status;
1044
1045	struct samr_UserInfo21 *info21 = NULL;
1046	struct sec_desc_buf *sec_desc = NULL;
1047	uint32_t auth_flag = 0;
1048
1049	struct USER_INFO_0 info0;
1050	struct USER_INFO_1 info1;
1051	struct USER_INFO_2 info2;
1052	struct USER_INFO_3 info3;
1053	struct USER_INFO_4 info4;
1054	struct USER_INFO_10 info10;
1055	struct USER_INFO_11 info11;
1056	struct USER_INFO_20 info20;
1057	struct USER_INFO_23 info23;
1058
1059	switch (level) {
1060	case 0:
1061	case 1:
1062	case 2:
1063	case 3:
1064	case 4:
1065	case 10:
1066	case 11:
1067	case 20:
1068	case 23:
1069	break;
1070	default:
1071	return NT_STATUS_INVALID_LEVEL;
1072	}
1073
1074	if (level == 0) {
1075	info0.usri0_name = talloc_strdup(mem_ctx, user_name);
1076	NT_STATUS_HAVE_NO_MEMORY(info0.usri0_name);
1077
1078	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_0, info0,
1079	(struct USER_INFO_0 **)buffer, num_entries);
1080
1081	return NT_STATUS_OK;
1082	}
1083
1084	status = libnetapi_samr_lookup_user(mem_ctx, pipe_cli,
1085	domain_handle,
1086	builtin_handle,
1087	user_name,
1088	domain_sid,
1089	rid,
1090	level,
1091	&info21,
1092	&sec_desc,
1093	&auth_flag);
1094
1095	if (!NT_STATUS_IS_OK(status)) {
1096	goto done;
1097	}
1098
1099	switch (level) {
1100	case 0:
1101	/* already returned above */
1102	break;
1103	case 1:
1104	status = info21_to_USER_INFO_1(mem_ctx, info21, &info1);
1105	NT_STATUS_NOT_OK_RETURN(status);
1106
1107	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_1, info1,
1108	(struct USER_INFO_1 **)buffer, num_entries);
1109
1110	break;
1111	case 2:
1112	status = info21_to_USER_INFO_2(mem_ctx, info21, auth_flag, &info2);
1113	NT_STATUS_NOT_OK_RETURN(status);
1114
1115	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_2, info2,
1116	(struct USER_INFO_2 **)buffer, num_entries);
1117
1118	break;
1119	case 3:
1120	status = info21_to_USER_INFO_3(mem_ctx, info21, auth_flag, &info3);
1121	NT_STATUS_NOT_OK_RETURN(status);
1122
1123	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_3, info3,
1124	(struct USER_INFO_3 **)buffer, num_entries);
1125
1126	break;
1127	case 4:
1128	status = info21_to_USER_INFO_4(mem_ctx, info21, auth_flag, domain_sid, &info4);
1129	NT_STATUS_NOT_OK_RETURN(status);
1130
1131	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_4, info4,
1132	(struct USER_INFO_4 **)buffer, num_entries);
1133
1134	break;
1135	case 10:
1136	status = info21_to_USER_INFO_10(mem_ctx, info21, &info10);
1137	NT_STATUS_NOT_OK_RETURN(status);
1138
1139	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_10, info10,
1140	(struct USER_INFO_10 **)buffer, num_entries);
1141
1142	break;
1143	case 11:
1144	status = info21_to_USER_INFO_11(mem_ctx, info21, auth_flag, &info11);
1145	NT_STATUS_NOT_OK_RETURN(status);
1146
1147	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_11, info11,
1148	(struct USER_INFO_11 **)buffer, num_entries);
1149
1150	break;
1151	case 20:
1152	status = info21_to_USER_INFO_20(mem_ctx, info21, &info20);
1153	NT_STATUS_NOT_OK_RETURN(status);
1154
1155	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_20, info20,
1156	(struct USER_INFO_20 **)buffer, num_entries);
1157
1158	break;
1159	case 23:
1160	status = info21_to_USER_INFO_23(mem_ctx, info21, domain_sid, &info23);
1161	NT_STATUS_NOT_OK_RETURN(status);
1162
1163	ADD_TO_ARRAY(mem_ctx, struct USER_INFO_23, info23,
1164	(struct USER_INFO_23 **)buffer, num_entries);
1165	break;
1166	default:
1167	return NT_STATUS_INVALID_LEVEL;
1168	}
1169
1170	done:
1171	return status;
1172	}
1173
1174	/****************************************************************
1175	****************************************************************/
1176
1177	WERROR NetUserEnum_r(struct libnetapi_ctx *ctx,
1178	struct NetUserEnum *r)
1179	{
1180	struct rpc_pipe_client *pipe_cli = NULL;
1181	struct policy_handle connect_handle;
1182	struct dom_sid2 *domain_sid = NULL;
1183	struct policy_handle domain_handle, builtin_handle;
1184	struct samr_SamArray *sam = NULL;
1185	uint32_t filter = ACB_NORMAL;
1186	int i;
1187	uint32_t entries_read = 0;
1188
1189	NTSTATUS status = NT_STATUS_OK;
1190	WERROR werr;
1191
1192	ZERO_STRUCT(connect_handle);
1193	ZERO_STRUCT(domain_handle);
1194	ZERO_STRUCT(builtin_handle);
1195
1196	if (!r->out.buffer) {
1197	return WERR_INVALID_PARAM;
1198	}
1199
1200	*r->out.buffer = NULL;
1201	*r->out.entries_read = 0;
1202
1203	switch (r->in.level) {
1204	case 0:
1205	case 1:
1206	case 2:
1207	case 3:
1208	case 4:
1209	case 10:
1210	case 11:
1211	case 20:
1212	case 23:
1213	break;
1214	default:
1215	return WERR_UNKNOWN_LEVEL;
1216	}
1217
1218	werr = libnetapi_open_pipe(ctx, r->in.server_name,
1219	&ndr_table_samr.syntax_id,
1220	&pipe_cli);
1221	if (!W_ERROR_IS_OK(werr)) {
1222	goto done;
1223	}
1224
1225	werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1226	SAMR_ACCESS_ENUM_DOMAINS \|
1227	SAMR_ACCESS_LOOKUP_DOMAIN,
1228	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT \|
1229	SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1230	&connect_handle,
1231	&builtin_handle);
1232	if (!W_ERROR_IS_OK(werr)) {
1233	goto done;
1234	}
1235
1236	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1237	SAMR_ACCESS_ENUM_DOMAINS \|
1238	SAMR_ACCESS_LOOKUP_DOMAIN,
1239	SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 \|
1240	SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS \|
1241	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1242	&connect_handle,
1243	&domain_handle,
1244	&domain_sid);
1245	if (!W_ERROR_IS_OK(werr)) {
1246	goto done;
1247	}
1248
1249	switch (r->in.filter) {
1250	case FILTER_NORMAL_ACCOUNT:
1251	filter = ACB_NORMAL;
1252	break;
1253	case FILTER_TEMP_DUPLICATE_ACCOUNT:
1254	filter = ACB_TEMPDUP;
1255	break;
1256	case FILTER_INTERDOMAIN_TRUST_ACCOUNT:
1257	filter = ACB_DOMTRUST;
1258	break;
1259	case FILTER_WORKSTATION_TRUST_ACCOUNT:
1260	filter = ACB_WSTRUST;
1261	break;
1262	case FILTER_SERVER_TRUST_ACCOUNT:
1263	filter = ACB_SVRTRUST;
1264	break;
1265	default:
1266	break;
1267	}
1268
1269	status = rpccli_samr_EnumDomainUsers(pipe_cli,
1270	ctx,
1271	&domain_handle,
1272	r->in.resume_handle,
1273	filter,
1274	&sam,
1275	r->in.prefmaxlen,
1276	&entries_read);
1277	werr = ntstatus_to_werror(status);
1278	if (NT_STATUS_IS_ERR(status)) {
1279	goto done;
1280	}
1281
1282	for (i=0; i < sam->count; i++) {
1283
1284	status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
1285	domain_sid,
1286	&domain_handle,
1287	&builtin_handle,
1288	sam->entries[i].name.string,
1289	sam->entries[i].idx,
1290	r->in.level,
1291	r->out.buffer,
1292	r->out.entries_read);
1293	if (!NT_STATUS_IS_OK(status)) {
1294	werr = ntstatus_to_werror(status);
1295	goto done;
1296	}
1297	}
1298
1299	done:
1300	/* if last query */
1301	if (NT_STATUS_IS_OK(status) \|\|
1302	NT_STATUS_IS_ERR(status)) {
1303
1304	if (ctx->disable_policy_handle_cache) {
1305	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1306	libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
1307	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1308	}
1309	}
1310
1311	return werr;
1312	}
1313
1314	/****************************************************************
1315	****************************************************************/
1316
1317	WERROR NetUserEnum_l(struct libnetapi_ctx *ctx,
1318	struct NetUserEnum *r)
1319	{
1320	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserEnum);
1321	}
1322
1323	/****************************************************************
1324	****************************************************************/
1325
1326	static WERROR convert_samr_dispinfo_to_NET_DISPLAY_USER(TALLOC_CTX *mem_ctx,
1327	struct samr_DispInfoGeneral *info,
1328	uint32_t *entries_read,
1329	void **buffer)
1330	{
1331	struct NET_DISPLAY_USER *user = NULL;
1332	int i;
1333
1334	user = TALLOC_ZERO_ARRAY(mem_ctx,
1335	struct NET_DISPLAY_USER,
1336	info->count);
1337	W_ERROR_HAVE_NO_MEMORY(user);
1338
1339	for (i = 0; i < info->count; i++) {
1340	user[i].usri1_name = talloc_strdup(mem_ctx,
1341	info->entries[i].account_name.string);
1342	user[i].usri1_comment = talloc_strdup(mem_ctx,
1343	info->entries[i].description.string);
1344	user[i].usri1_flags =
1345	info->entries[i].acct_flags;
1346	user[i].usri1_full_name = talloc_strdup(mem_ctx,
1347	info->entries[i].full_name.string);
1348	user[i].usri1_user_id =
1349	info->entries[i].rid;
1350	user[i].usri1_next_index =
1351	info->entries[i].idx;
1352
1353	if (!user[i].usri1_name) {
1354	return WERR_NOMEM;
1355	}
1356	}
1357
1358	*buffer = talloc_memdup(mem_ctx, user,
1359	sizeof(struct NET_DISPLAY_USER) * info->count);
1360	W_ERROR_HAVE_NO_MEMORY(*buffer);
1361
1362	*entries_read = info->count;
1363
1364	return WERR_OK;
1365	}
1366
1367	/****************************************************************
1368	****************************************************************/
1369
1370	static WERROR convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(TALLOC_CTX *mem_ctx,
1371	struct samr_DispInfoFull *info,
1372	uint32_t *entries_read,
1373	void **buffer)
1374	{
1375	struct NET_DISPLAY_MACHINE *machine = NULL;
1376	int i;
1377
1378	machine = TALLOC_ZERO_ARRAY(mem_ctx,
1379	struct NET_DISPLAY_MACHINE,
1380	info->count);
1381	W_ERROR_HAVE_NO_MEMORY(machine);
1382
1383	for (i = 0; i < info->count; i++) {
1384	machine[i].usri2_name = talloc_strdup(mem_ctx,
1385	info->entries[i].account_name.string);
1386	machine[i].usri2_comment = talloc_strdup(mem_ctx,
1387	info->entries[i].description.string);
1388	machine[i].usri2_flags =
1389	info->entries[i].acct_flags;
1390	machine[i].usri2_user_id =
1391	info->entries[i].rid;
1392	machine[i].usri2_next_index =
1393	info->entries[i].idx;
1394
1395	if (!machine[i].usri2_name) {
1396	return WERR_NOMEM;
1397	}
1398	}
1399
1400	*buffer = talloc_memdup(mem_ctx, machine,
1401	sizeof(struct NET_DISPLAY_MACHINE) * info->count);
1402	W_ERROR_HAVE_NO_MEMORY(*buffer);
1403
1404	*entries_read = info->count;
1405
1406	return WERR_OK;
1407	}
1408
1409	/****************************************************************
1410	****************************************************************/
1411
1412	static WERROR convert_samr_dispinfo_to_NET_DISPLAY_GROUP(TALLOC_CTX *mem_ctx,
1413	struct samr_DispInfoFullGroups *info,
1414	uint32_t *entries_read,
1415	void **buffer)
1416	{
1417	struct NET_DISPLAY_GROUP *group = NULL;
1418	int i;
1419
1420	group = TALLOC_ZERO_ARRAY(mem_ctx,
1421	struct NET_DISPLAY_GROUP,
1422	info->count);
1423	W_ERROR_HAVE_NO_MEMORY(group);
1424
1425	for (i = 0; i < info->count; i++) {
1426	group[i].grpi3_name = talloc_strdup(mem_ctx,
1427	info->entries[i].account_name.string);
1428	group[i].grpi3_comment = talloc_strdup(mem_ctx,
1429	info->entries[i].description.string);
1430	group[i].grpi3_group_id =
1431	info->entries[i].rid;
1432	group[i].grpi3_attributes =
1433	info->entries[i].acct_flags;
1434	group[i].grpi3_next_index =
1435	info->entries[i].idx;
1436
1437	if (!group[i].grpi3_name) {
1438	return WERR_NOMEM;
1439	}
1440	}
1441
1442	*buffer = talloc_memdup(mem_ctx, group,
1443	sizeof(struct NET_DISPLAY_GROUP) * info->count);
1444	W_ERROR_HAVE_NO_MEMORY(*buffer);
1445
1446	*entries_read = info->count;
1447
1448	return WERR_OK;
1449
1450	}
1451
1452	/****************************************************************
1453	****************************************************************/
1454
1455	static WERROR convert_samr_dispinfo_to_NET_DISPLAY(TALLOC_CTX *mem_ctx,
1456	union samr_DispInfo *info,
1457	uint32_t level,
1458	uint32_t *entries_read,
1459	void **buffer)
1460	{
1461	switch (level) {
1462	case 1:
1463	return convert_samr_dispinfo_to_NET_DISPLAY_USER(mem_ctx,
1464	&info->info1,
1465	entries_read,
1466	buffer);
1467	case 2:
1468	return convert_samr_dispinfo_to_NET_DISPLAY_MACHINE(mem_ctx,
1469	&info->info2,
1470	entries_read,
1471	buffer);
1472	case 3:
1473	return convert_samr_dispinfo_to_NET_DISPLAY_GROUP(mem_ctx,
1474	&info->info3,
1475	entries_read,
1476	buffer);
1477	default:
1478	break;
1479	}
1480
1481	return WERR_UNKNOWN_LEVEL;
1482	}
1483
1484	/****************************************************************
1485	****************************************************************/
1486
1487	WERROR NetQueryDisplayInformation_r(struct libnetapi_ctx *ctx,
1488	struct NetQueryDisplayInformation *r)
1489	{
1490	struct rpc_pipe_client *pipe_cli = NULL;
1491	struct policy_handle connect_handle;
1492	struct dom_sid2 *domain_sid = NULL;
1493	struct policy_handle domain_handle;
1494	union samr_DispInfo info;
1495
1496	uint32_t total_size = 0;
1497	uint32_t returned_size = 0;
1498
1499	NTSTATUS status = NT_STATUS_OK;
1500	WERROR werr;
1501	WERROR werr_tmp;
1502
1503	*r->out.entries_read = 0;
1504
1505	ZERO_STRUCT(connect_handle);
1506	ZERO_STRUCT(domain_handle);
1507
1508	switch (r->in.level) {
1509	case 1:
1510	case 2:
1511	case 3:
1512	break;
1513	default:
1514	return WERR_UNKNOWN_LEVEL;
1515	}
1516
1517	werr = libnetapi_open_pipe(ctx, r->in.server_name,
1518	&ndr_table_samr.syntax_id,
1519	&pipe_cli);
1520	if (!W_ERROR_IS_OK(werr)) {
1521	goto done;
1522	}
1523
1524	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1525	SAMR_ACCESS_ENUM_DOMAINS \|
1526	SAMR_ACCESS_LOOKUP_DOMAIN,
1527	SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 \|
1528	SAMR_DOMAIN_ACCESS_ENUM_ACCOUNTS \|
1529	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1530	&connect_handle,
1531	&domain_handle,
1532	&domain_sid);
1533	if (!W_ERROR_IS_OK(werr)) {
1534	goto done;
1535	}
1536
1537	status = rpccli_samr_QueryDisplayInfo2(pipe_cli,
1538	ctx,
1539	&domain_handle,
1540	r->in.level,
1541	r->in.idx,
1542	r->in.entries_requested,
1543	r->in.prefmaxlen,
1544	&total_size,
1545	&returned_size,
1546	&info);
1547	werr = ntstatus_to_werror(status);
1548	if (NT_STATUS_IS_ERR(status)) {
1549	goto done;
1550	}
1551
1552	werr_tmp = convert_samr_dispinfo_to_NET_DISPLAY(ctx, &info,
1553	r->in.level,
1554	r->out.entries_read,
1555	r->out.buffer);
1556	if (!W_ERROR_IS_OK(werr_tmp)) {
1557	werr = werr_tmp;
1558	}
1559	done:
1560	/* if last query */
1561	if (NT_STATUS_IS_OK(status) \|\|
1562	NT_STATUS_IS_ERR(status)) {
1563
1564	if (ctx->disable_policy_handle_cache) {
1565	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1566	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1567	}
1568	}
1569
1570	return werr;
1571
1572	}
1573
1574	/****************************************************************
1575	****************************************************************/
1576
1577
1578	WERROR NetQueryDisplayInformation_l(struct libnetapi_ctx *ctx,
1579	struct NetQueryDisplayInformation *r)
1580	{
1581	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetQueryDisplayInformation);
1582	}
1583
1584	/****************************************************************
1585	****************************************************************/
1586
1587	WERROR NetUserChangePassword_r(struct libnetapi_ctx *ctx,
1588	struct NetUserChangePassword *r)
1589	{
1590	return WERR_NOT_SUPPORTED;
1591	}
1592
1593	/****************************************************************
1594	****************************************************************/
1595
1596	WERROR NetUserChangePassword_l(struct libnetapi_ctx *ctx,
1597	struct NetUserChangePassword *r)
1598	{
1599	return WERR_NOT_SUPPORTED;
1600	}
1601
1602	/****************************************************************
1603	****************************************************************/
1604
1605	WERROR NetUserGetInfo_r(struct libnetapi_ctx *ctx,
1606	struct NetUserGetInfo *r)
1607	{
1608	struct rpc_pipe_client *pipe_cli = NULL;
1609	NTSTATUS status;
1610	WERROR werr;
1611
1612	struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1613	struct lsa_String lsa_account_name;
1614	struct dom_sid2 *domain_sid = NULL;
1615	struct samr_Ids user_rids, name_types;
1616	uint32_t num_entries = 0;
1617
1618	ZERO_STRUCT(connect_handle);
1619	ZERO_STRUCT(domain_handle);
1620	ZERO_STRUCT(builtin_handle);
1621	ZERO_STRUCT(user_handle);
1622
1623	if (!r->out.buffer) {
1624	return WERR_INVALID_PARAM;
1625	}
1626
1627	switch (r->in.level) {
1628	case 0:
1629	case 1:
1630	case 2:
1631	case 3:
1632	case 4:
1633	case 10:
1634	case 11:
1635	case 20:
1636	case 23:
1637	break;
1638	default:
1639	werr = WERR_UNKNOWN_LEVEL;
1640	goto done;
1641	}
1642
1643	werr = libnetapi_open_pipe(ctx, r->in.server_name,
1644	&ndr_table_samr.syntax_id,
1645	&pipe_cli);
1646	if (!W_ERROR_IS_OK(werr)) {
1647	goto done;
1648	}
1649
1650	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1651	SAMR_ACCESS_ENUM_DOMAINS \|
1652	SAMR_ACCESS_LOOKUP_DOMAIN,
1653	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1654	&connect_handle,
1655	&domain_handle,
1656	&domain_sid);
1657	if (!W_ERROR_IS_OK(werr)) {
1658	goto done;
1659	}
1660
1661	werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1662	SAMR_ACCESS_ENUM_DOMAINS \|
1663	SAMR_ACCESS_LOOKUP_DOMAIN,
1664	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT \|
1665	SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1666	&connect_handle,
1667	&builtin_handle);
1668	if (!W_ERROR_IS_OK(werr)) {
1669	goto done;
1670	}
1671
1672	init_lsa_String(&lsa_account_name, r->in.user_name);
1673
1674	status = rpccli_samr_LookupNames(pipe_cli, ctx,
1675	&domain_handle,
1676	1,
1677	&lsa_account_name,
1678	&user_rids,
1679	&name_types);
1680	if (!NT_STATUS_IS_OK(status)) {
1681	werr = ntstatus_to_werror(status);
1682	goto done;
1683	}
1684
1685	status = libnetapi_samr_lookup_user_map_USER_INFO(ctx, pipe_cli,
1686	domain_sid,
1687	&domain_handle,
1688	&builtin_handle,
1689	r->in.user_name,
1690	user_rids.ids[0],
1691	r->in.level,
1692	r->out.buffer,
1693	&num_entries);
1694	if (!NT_STATUS_IS_OK(status)) {
1695	werr = ntstatus_to_werror(status);
1696	goto done;
1697	}
1698
1699	done:
1700	if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
1701	rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1702	}
1703
1704	if (ctx->disable_policy_handle_cache) {
1705	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1706	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1707	}
1708
1709	return werr;
1710	}
1711
1712	/****************************************************************
1713	****************************************************************/
1714
1715	WERROR NetUserGetInfo_l(struct libnetapi_ctx *ctx,
1716	struct NetUserGetInfo *r)
1717	{
1718	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetInfo);
1719	}
1720
1721	/****************************************************************
1722	****************************************************************/
1723
1724	WERROR NetUserSetInfo_r(struct libnetapi_ctx *ctx,
1725	struct NetUserSetInfo *r)
1726	{
1727	struct rpc_pipe_client *pipe_cli = NULL;
1728	NTSTATUS status;
1729	WERROR werr;
1730
1731	struct policy_handle connect_handle, domain_handle, builtin_handle, user_handle;
1732	struct lsa_String lsa_account_name;
1733	struct dom_sid2 *domain_sid = NULL;
1734	struct samr_Ids user_rids, name_types;
1735	uint32_t user_mask = 0;
1736
1737	struct USER_INFO_X uX;
1738
1739	ZERO_STRUCT(connect_handle);
1740	ZERO_STRUCT(domain_handle);
1741	ZERO_STRUCT(builtin_handle);
1742	ZERO_STRUCT(user_handle);
1743
1744	if (!r->in.buffer) {
1745	return WERR_INVALID_PARAM;
1746	}
1747
1748	switch (r->in.level) {
1749	case 0:
1750	user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES;
1751	break;
1752	case 1003:
1753	user_mask = SAMR_USER_ACCESS_SET_PASSWORD;
1754	break;
1755	case 1006:
1756	case 1007:
1757	case 1009:
1758	case 1011:
1759	case 1014:
1760	case 1052:
1761	case 1053:
1762	user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES;
1763	break;
1764	case 1012:
1765	case 1024:
1766	user_mask = SAMR_USER_ACCESS_SET_LOC_COM;
1767	case 1051:
1768	user_mask = SAMR_USER_ACCESS_SET_ATTRIBUTES \|
1769	SAMR_USER_ACCESS_GET_GROUPS;
1770	break;
1771	case 3:
1772	user_mask = STD_RIGHT_READ_CONTROL_ACCESS \|
1773	STD_RIGHT_WRITE_DAC_ACCESS \|
1774	SAMR_USER_ACCESS_GET_GROUPS \|
1775	SAMR_USER_ACCESS_SET_PASSWORD \|
1776	SAMR_USER_ACCESS_SET_ATTRIBUTES \|
1777	SAMR_USER_ACCESS_GET_ATTRIBUTES \|
1778	SAMR_USER_ACCESS_SET_LOC_COM;
1779	break;
1780	case 1:
1781	case 2:
1782	case 4:
1783	case 21:
1784	case 22:
1785	case 1005:
1786	case 1008:
1787	case 1010:
1788	case 1017:
1789	case 1020:
1790	werr = WERR_NOT_SUPPORTED;
1791	goto done;
1792	default:
1793	werr = WERR_UNKNOWN_LEVEL;
1794	goto done;
1795	}
1796
1797	werr = libnetapi_open_pipe(ctx, r->in.server_name,
1798	&ndr_table_samr.syntax_id,
1799	&pipe_cli);
1800	if (!W_ERROR_IS_OK(werr)) {
1801	goto done;
1802	}
1803
1804	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
1805	SAMR_ACCESS_ENUM_DOMAINS \|
1806	SAMR_ACCESS_LOOKUP_DOMAIN,
1807	SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 \|
1808	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
1809	&connect_handle,
1810	&domain_handle,
1811	&domain_sid);
1812	if (!W_ERROR_IS_OK(werr)) {
1813	goto done;
1814	}
1815
1816	werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
1817	SAMR_ACCESS_ENUM_DOMAINS \|
1818	SAMR_ACCESS_LOOKUP_DOMAIN,
1819	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT \|
1820	SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
1821	&connect_handle,
1822	&builtin_handle);
1823	if (!W_ERROR_IS_OK(werr)) {
1824	goto done;
1825	}
1826
1827	init_lsa_String(&lsa_account_name, r->in.user_name);
1828
1829	status = rpccli_samr_LookupNames(pipe_cli, ctx,
1830	&domain_handle,
1831	1,
1832	&lsa_account_name,
1833	&user_rids,
1834	&name_types);
1835	if (!NT_STATUS_IS_OK(status)) {
1836	werr = ntstatus_to_werror(status);
1837	goto done;
1838	}
1839
1840	status = rpccli_samr_OpenUser(pipe_cli, ctx,
1841	&domain_handle,
1842	user_mask,
1843	user_rids.ids[0],
1844	&user_handle);
1845	if (!NT_STATUS_IS_OK(status)) {
1846	werr = ntstatus_to_werror(status);
1847	goto done;
1848	}
1849
1850	status = construct_USER_INFO_X(r->in.level, r->in.buffer, &uX);
1851	if (!NT_STATUS_IS_OK(status)) {
1852	werr = ntstatus_to_werror(status);
1853	goto done;
1854	}
1855
1856	status = set_user_info_USER_INFO_X(ctx, pipe_cli,
1857	&pipe_cli->auth->user_session_key,
1858	&user_handle,
1859	&uX);
1860	if (!NT_STATUS_IS_OK(status)) {
1861	werr = ntstatus_to_werror(status);
1862	goto done;
1863	}
1864
1865	werr = WERR_OK;
1866
1867	done:
1868	if (is_valid_policy_hnd(&user_handle) && pipe_cli) {
1869	rpccli_samr_Close(pipe_cli, ctx, &user_handle);
1870	}
1871
1872	if (ctx->disable_policy_handle_cache) {
1873	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
1874	libnetapi_samr_close_builtin_handle(ctx, &builtin_handle);
1875	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
1876	}
1877
1878	return werr;
1879	}
1880
1881	/****************************************************************
1882	****************************************************************/
1883
1884	WERROR NetUserSetInfo_l(struct libnetapi_ctx *ctx,
1885	struct NetUserSetInfo *r)
1886	{
1887	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserSetInfo);
1888	}
1889
1890	/****************************************************************
1891	****************************************************************/
1892
1893	static NTSTATUS query_USER_MODALS_INFO_rpc(TALLOC_CTX *mem_ctx,
1894	struct rpc_pipe_client *pipe_cli,
1895	struct policy_handle *domain_handle,
1896	struct samr_DomInfo1 *info1,
1897	struct samr_DomInfo3 *info3,
1898	struct samr_DomInfo5 *info5,
1899	struct samr_DomInfo6 *info6,
1900	struct samr_DomInfo7 *info7,
1901	struct samr_DomInfo12 *info12)
1902	{
1903	NTSTATUS status;
1904	union samr_DomainInfo *dom_info = NULL;
1905
1906	if (info1) {
1907	status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1908	domain_handle,
1909	1,
1910	&dom_info);
1911	NT_STATUS_NOT_OK_RETURN(status);
1912
1913	*info1 = dom_info->info1;
1914	}
1915
1916	if (info3) {
1917	status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1918	domain_handle,
1919	3,
1920	&dom_info);
1921	NT_STATUS_NOT_OK_RETURN(status);
1922
1923	*info3 = dom_info->info3;
1924	}
1925
1926	if (info5) {
1927	status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1928	domain_handle,
1929	5,
1930	&dom_info);
1931	NT_STATUS_NOT_OK_RETURN(status);
1932
1933	*info5 = dom_info->info5;
1934	}
1935
1936	if (info6) {
1937	status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1938	domain_handle,
1939	6,
1940	&dom_info);
1941	NT_STATUS_NOT_OK_RETURN(status);
1942
1943	*info6 = dom_info->info6;
1944	}
1945
1946	if (info7) {
1947	status = rpccli_samr_QueryDomainInfo(pipe_cli, mem_ctx,
1948	domain_handle,
1949	7,
1950	&dom_info);
1951	NT_STATUS_NOT_OK_RETURN(status);
1952
1953	*info7 = dom_info->info7;
1954	}
1955
1956	if (info12) {
1957	status = rpccli_samr_QueryDomainInfo2(pipe_cli, mem_ctx,
1958	domain_handle,
1959	12,
1960	&dom_info);
1961	NT_STATUS_NOT_OK_RETURN(status);
1962
1963	*info12 = dom_info->info12;
1964	}
1965
1966	return NT_STATUS_OK;
1967	}
1968
1969	/****************************************************************
1970	****************************************************************/
1971
1972	static NTSTATUS query_USER_MODALS_INFO_0(TALLOC_CTX *mem_ctx,
1973	struct rpc_pipe_client *pipe_cli,
1974	struct policy_handle *domain_handle,
1975	struct USER_MODALS_INFO_0 *info0)
1976	{
1977	NTSTATUS status;
1978	struct samr_DomInfo1 dom_info1;
1979	struct samr_DomInfo3 dom_info3;
1980
1981	ZERO_STRUCTP(info0);
1982
1983	status = query_USER_MODALS_INFO_rpc(mem_ctx,
1984	pipe_cli,
1985	domain_handle,
1986	&dom_info1,
1987	&dom_info3,
1988	NULL,
1989	NULL,
1990	NULL,
1991	NULL);
1992	NT_STATUS_NOT_OK_RETURN(status);
1993
1994	info0->usrmod0_min_passwd_len =
1995	dom_info1.min_password_length;
1996	info0->usrmod0_max_passwd_age =
1997	nt_time_to_unix_abs((NTTIME *)&dom_info1.max_password_age);
1998	info0->usrmod0_min_passwd_age =
1999	nt_time_to_unix_abs((NTTIME *)&dom_info1.min_password_age);
2000	info0->usrmod0_password_hist_len =
2001	dom_info1.password_history_length;
2002
2003	info0->usrmod0_force_logoff =
2004	nt_time_to_unix_abs(&dom_info3.force_logoff_time);
2005
2006	return NT_STATUS_OK;
2007	}
2008
2009	/****************************************************************
2010	****************************************************************/
2011
2012	static NTSTATUS query_USER_MODALS_INFO_1(TALLOC_CTX *mem_ctx,
2013	struct rpc_pipe_client *pipe_cli,
2014	struct policy_handle *domain_handle,
2015	struct USER_MODALS_INFO_1 *info1)
2016	{
2017	NTSTATUS status;
2018	struct samr_DomInfo6 dom_info6;
2019	struct samr_DomInfo7 dom_info7;
2020
2021	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2022	pipe_cli,
2023	domain_handle,
2024	NULL,
2025	NULL,
2026	NULL,
2027	&dom_info6,
2028	&dom_info7,
2029	NULL);
2030	NT_STATUS_NOT_OK_RETURN(status);
2031
2032	info1->usrmod1_primary =
2033	talloc_strdup(mem_ctx, dom_info6.primary.string);
2034
2035	info1->usrmod1_role = dom_info7.role;
2036
2037	return NT_STATUS_OK;
2038	}
2039
2040	/****************************************************************
2041	****************************************************************/
2042
2043	static NTSTATUS query_USER_MODALS_INFO_2(TALLOC_CTX *mem_ctx,
2044	struct rpc_pipe_client *pipe_cli,
2045	struct policy_handle *domain_handle,
2046	struct dom_sid *domain_sid,
2047	struct USER_MODALS_INFO_2 *info2)
2048	{
2049	NTSTATUS status;
2050	struct samr_DomInfo5 dom_info5;
2051
2052	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2053	pipe_cli,
2054	domain_handle,
2055	NULL,
2056	NULL,
2057	&dom_info5,
2058	NULL,
2059	NULL,
2060	NULL);
2061	NT_STATUS_NOT_OK_RETURN(status);
2062
2063	info2->usrmod2_domain_name =
2064	talloc_strdup(mem_ctx, dom_info5.domain_name.string);
2065	info2->usrmod2_domain_id =
2066	(struct domsid *)sid_dup_talloc(mem_ctx, domain_sid);
2067
2068	NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_name);
2069	NT_STATUS_HAVE_NO_MEMORY(info2->usrmod2_domain_id);
2070
2071	return NT_STATUS_OK;
2072	}
2073
2074	/****************************************************************
2075	****************************************************************/
2076
2077	static NTSTATUS query_USER_MODALS_INFO_3(TALLOC_CTX *mem_ctx,
2078	struct rpc_pipe_client *pipe_cli,
2079	struct policy_handle *domain_handle,
2080	struct USER_MODALS_INFO_3 *info3)
2081	{
2082	NTSTATUS status;
2083	struct samr_DomInfo12 dom_info12;
2084
2085	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2086	pipe_cli,
2087	domain_handle,
2088	NULL,
2089	NULL,
2090	NULL,
2091	NULL,
2092	NULL,
2093	&dom_info12);
2094	NT_STATUS_NOT_OK_RETURN(status);
2095
2096	info3->usrmod3_lockout_duration =
2097	nt_time_to_unix_abs(&dom_info12.lockout_duration);
2098	info3->usrmod3_lockout_observation_window =
2099	nt_time_to_unix_abs(&dom_info12.lockout_window);
2100	info3->usrmod3_lockout_threshold =
2101	dom_info12.lockout_threshold;
2102
2103	return NT_STATUS_OK;
2104	}
2105
2106	/****************************************************************
2107	****************************************************************/
2108
2109	static NTSTATUS query_USER_MODALS_INFO_to_buffer(TALLOC_CTX *mem_ctx,
2110	struct rpc_pipe_client *pipe_cli,
2111	uint32_t level,
2112	struct policy_handle *domain_handle,
2113	struct dom_sid *domain_sid,
2114	uint8_t **buffer)
2115	{
2116	NTSTATUS status;
2117
2118	struct USER_MODALS_INFO_0 info0;
2119	struct USER_MODALS_INFO_1 info1;
2120	struct USER_MODALS_INFO_2 info2;
2121	struct USER_MODALS_INFO_3 info3;
2122
2123	if (!buffer) {
2124	return ERROR_INSUFFICIENT_BUFFER;
2125	}
2126
2127	switch (level) {
2128	case 0:
2129	status = query_USER_MODALS_INFO_0(mem_ctx,
2130	pipe_cli,
2131	domain_handle,
2132	&info0);
2133	NT_STATUS_NOT_OK_RETURN(status);
2134
2135	buffer = (uint8_t )talloc_memdup(mem_ctx, &info0,
2136	sizeof(info0));
2137	break;
2138
2139	case 1:
2140	status = query_USER_MODALS_INFO_1(mem_ctx,
2141	pipe_cli,
2142	domain_handle,
2143	&info1);
2144	NT_STATUS_NOT_OK_RETURN(status);
2145
2146	buffer = (uint8_t )talloc_memdup(mem_ctx, &info1,
2147	sizeof(info1));
2148	break;
2149	case 2:
2150	status = query_USER_MODALS_INFO_2(mem_ctx,
2151	pipe_cli,
2152	domain_handle,
2153	domain_sid,
2154	&info2);
2155	NT_STATUS_NOT_OK_RETURN(status);
2156
2157	buffer = (uint8_t )talloc_memdup(mem_ctx, &info2,
2158	sizeof(info2));
2159	break;
2160	case 3:
2161	status = query_USER_MODALS_INFO_3(mem_ctx,
2162	pipe_cli,
2163	domain_handle,
2164	&info3);
2165	NT_STATUS_NOT_OK_RETURN(status);
2166
2167	buffer = (uint8_t )talloc_memdup(mem_ctx, &info3,
2168	sizeof(info3));
2169	break;
2170	default:
2171	break;
2172	}
2173
2174	NT_STATUS_HAVE_NO_MEMORY(*buffer);
2175
2176	return NT_STATUS_OK;
2177	}
2178
2179	/****************************************************************
2180	****************************************************************/
2181
2182	WERROR NetUserModalsGet_r(struct libnetapi_ctx *ctx,
2183	struct NetUserModalsGet *r)
2184	{
2185	struct rpc_pipe_client *pipe_cli = NULL;
2186	NTSTATUS status;
2187	WERROR werr;
2188
2189	struct policy_handle connect_handle, domain_handle;
2190	struct dom_sid2 *domain_sid = NULL;
2191	uint32_t access_mask = SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT;
2192
2193	ZERO_STRUCT(connect_handle);
2194	ZERO_STRUCT(domain_handle);
2195
2196	if (!r->out.buffer) {
2197	return WERR_INVALID_PARAM;
2198	}
2199
2200	switch (r->in.level) {
2201	case 0:
2202	access_mask \|= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 \|
2203	SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
2204	break;
2205	case 1:
2206	case 2:
2207	access_mask \|= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2;
2208	break;
2209	case 3:
2210	access_mask \|= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1;
2211	break;
2212	default:
2213	werr = WERR_UNKNOWN_LEVEL;
2214	goto done;
2215	}
2216
2217	werr = libnetapi_open_pipe(ctx, r->in.server_name,
2218	&ndr_table_samr.syntax_id,
2219	&pipe_cli);
2220	if (!W_ERROR_IS_OK(werr)) {
2221	goto done;
2222	}
2223
2224	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2225	SAMR_ACCESS_ENUM_DOMAINS \|
2226	SAMR_ACCESS_LOOKUP_DOMAIN,
2227	access_mask,
2228	&connect_handle,
2229	&domain_handle,
2230	&domain_sid);
2231	if (!W_ERROR_IS_OK(werr)) {
2232	goto done;
2233	}
2234
2235	/* 0: 1 + 3 */
2236	/* 1: 6 + 7 */
2237	/* 2: 5 */
2238	/* 3: 12 (DomainInfo2) */
2239
2240	status = query_USER_MODALS_INFO_to_buffer(ctx,
2241	pipe_cli,
2242	r->in.level,
2243	&domain_handle,
2244	domain_sid,
2245	r->out.buffer);
2246	if (!NT_STATUS_IS_OK(status)) {
2247	werr = ntstatus_to_werror(status);
2248	goto done;
2249	}
2250
2251	done:
2252	if (ctx->disable_policy_handle_cache) {
2253	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2254	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2255	}
2256
2257	return werr;
2258	}
2259
2260	/****************************************************************
2261	****************************************************************/
2262
2263	WERROR NetUserModalsGet_l(struct libnetapi_ctx *ctx,
2264	struct NetUserModalsGet *r)
2265	{
2266	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserModalsGet);
2267	}
2268
2269	/****************************************************************
2270	****************************************************************/
2271
2272	static NTSTATUS set_USER_MODALS_INFO_rpc(TALLOC_CTX *mem_ctx,
2273	struct rpc_pipe_client *pipe_cli,
2274	struct policy_handle *domain_handle,
2275	struct samr_DomInfo1 *info1,
2276	struct samr_DomInfo3 *info3,
2277	struct samr_DomInfo12 *info12)
2278	{
2279	NTSTATUS status;
2280	union samr_DomainInfo dom_info;
2281
2282	if (info1) {
2283
2284	ZERO_STRUCT(dom_info);
2285
2286	dom_info.info1 = *info1;
2287
2288	status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2289	domain_handle,
2290	1,
2291	&dom_info);
2292	NT_STATUS_NOT_OK_RETURN(status);
2293	}
2294
2295	if (info3) {
2296
2297	ZERO_STRUCT(dom_info);
2298
2299	dom_info.info3 = *info3;
2300
2301	status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2302	domain_handle,
2303	3,
2304	&dom_info);
2305
2306	NT_STATUS_NOT_OK_RETURN(status);
2307	}
2308
2309	if (info12) {
2310
2311	ZERO_STRUCT(dom_info);
2312
2313	dom_info.info12 = *info12;
2314
2315	status = rpccli_samr_SetDomainInfo(pipe_cli, mem_ctx,
2316	domain_handle,
2317	12,
2318	&dom_info);
2319
2320	NT_STATUS_NOT_OK_RETURN(status);
2321	}
2322
2323	return NT_STATUS_OK;
2324	}
2325
2326	/****************************************************************
2327	****************************************************************/
2328
2329	static NTSTATUS set_USER_MODALS_INFO_0_buffer(TALLOC_CTX *mem_ctx,
2330	struct rpc_pipe_client *pipe_cli,
2331	struct policy_handle *domain_handle,
2332	struct USER_MODALS_INFO_0 *info0)
2333	{
2334	NTSTATUS status;
2335	struct samr_DomInfo1 dom_info_1;
2336	struct samr_DomInfo3 dom_info_3;
2337
2338	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2339	pipe_cli,
2340	domain_handle,
2341	&dom_info_1,
2342	&dom_info_3,
2343	NULL,
2344	NULL,
2345	NULL,
2346	NULL);
2347	NT_STATUS_NOT_OK_RETURN(status);
2348
2349	dom_info_1.min_password_length =
2350	info0->usrmod0_min_passwd_len;
2351	dom_info_1.password_history_length =
2352	info0->usrmod0_password_hist_len;
2353
2354	unix_to_nt_time_abs((NTTIME *)&dom_info_1.max_password_age,
2355	info0->usrmod0_max_passwd_age);
2356	unix_to_nt_time_abs((NTTIME *)&dom_info_1.min_password_age,
2357	info0->usrmod0_min_passwd_age);
2358
2359	unix_to_nt_time_abs(&dom_info_3.force_logoff_time,
2360	info0->usrmod0_force_logoff);
2361
2362	return set_USER_MODALS_INFO_rpc(mem_ctx,
2363	pipe_cli,
2364	domain_handle,
2365	&dom_info_1,
2366	&dom_info_3,
2367	NULL);
2368	}
2369
2370	/****************************************************************
2371	****************************************************************/
2372
2373	static NTSTATUS set_USER_MODALS_INFO_3_buffer(TALLOC_CTX *mem_ctx,
2374	struct rpc_pipe_client *pipe_cli,
2375	struct policy_handle *domain_handle,
2376	struct USER_MODALS_INFO_3 *info3)
2377	{
2378	NTSTATUS status;
2379	struct samr_DomInfo12 dom_info_12;
2380
2381	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2382	pipe_cli,
2383	domain_handle,
2384	NULL,
2385	NULL,
2386	NULL,
2387	NULL,
2388	NULL,
2389	&dom_info_12);
2390	NT_STATUS_NOT_OK_RETURN(status);
2391
2392	unix_to_nt_time_abs((NTTIME *)&dom_info_12.lockout_duration,
2393	info3->usrmod3_lockout_duration);
2394	unix_to_nt_time_abs((NTTIME *)&dom_info_12.lockout_window,
2395	info3->usrmod3_lockout_observation_window);
2396	dom_info_12.lockout_threshold = info3->usrmod3_lockout_threshold;
2397
2398	return set_USER_MODALS_INFO_rpc(mem_ctx,
2399	pipe_cli,
2400	domain_handle,
2401	NULL,
2402	NULL,
2403	&dom_info_12);
2404	}
2405
2406	/****************************************************************
2407	****************************************************************/
2408
2409	static NTSTATUS set_USER_MODALS_INFO_1001_buffer(TALLOC_CTX *mem_ctx,
2410	struct rpc_pipe_client *pipe_cli,
2411	struct policy_handle *domain_handle,
2412	struct USER_MODALS_INFO_1001 *info1001)
2413	{
2414	NTSTATUS status;
2415	struct samr_DomInfo1 dom_info_1;
2416
2417	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2418	pipe_cli,
2419	domain_handle,
2420	&dom_info_1,
2421	NULL,
2422	NULL,
2423	NULL,
2424	NULL,
2425	NULL);
2426	NT_STATUS_NOT_OK_RETURN(status);
2427
2428	dom_info_1.min_password_length =
2429	info1001->usrmod1001_min_passwd_len;
2430
2431	return set_USER_MODALS_INFO_rpc(mem_ctx,
2432	pipe_cli,
2433	domain_handle,
2434	&dom_info_1,
2435	NULL,
2436	NULL);
2437	}
2438
2439	/****************************************************************
2440	****************************************************************/
2441
2442	static NTSTATUS set_USER_MODALS_INFO_1002_buffer(TALLOC_CTX *mem_ctx,
2443	struct rpc_pipe_client *pipe_cli,
2444	struct policy_handle *domain_handle,
2445	struct USER_MODALS_INFO_1002 *info1002)
2446	{
2447	NTSTATUS status;
2448	struct samr_DomInfo1 dom_info_1;
2449
2450	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2451	pipe_cli,
2452	domain_handle,
2453	&dom_info_1,
2454	NULL,
2455	NULL,
2456	NULL,
2457	NULL,
2458	NULL);
2459	NT_STATUS_NOT_OK_RETURN(status);
2460
2461	unix_to_nt_time_abs((NTTIME *)&dom_info_1.max_password_age,
2462	info1002->usrmod1002_max_passwd_age);
2463
2464	return set_USER_MODALS_INFO_rpc(mem_ctx,
2465	pipe_cli,
2466	domain_handle,
2467	&dom_info_1,
2468	NULL,
2469	NULL);
2470	}
2471
2472	/****************************************************************
2473	****************************************************************/
2474
2475	static NTSTATUS set_USER_MODALS_INFO_1003_buffer(TALLOC_CTX *mem_ctx,
2476	struct rpc_pipe_client *pipe_cli,
2477	struct policy_handle *domain_handle,
2478	struct USER_MODALS_INFO_1003 *info1003)
2479	{
2480	NTSTATUS status;
2481	struct samr_DomInfo1 dom_info_1;
2482
2483	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2484	pipe_cli,
2485	domain_handle,
2486	&dom_info_1,
2487	NULL,
2488	NULL,
2489	NULL,
2490	NULL,
2491	NULL);
2492	NT_STATUS_NOT_OK_RETURN(status);
2493
2494	unix_to_nt_time_abs((NTTIME *)&dom_info_1.min_password_age,
2495	info1003->usrmod1003_min_passwd_age);
2496
2497	return set_USER_MODALS_INFO_rpc(mem_ctx,
2498	pipe_cli,
2499	domain_handle,
2500	&dom_info_1,
2501	NULL,
2502	NULL);
2503	}
2504
2505	/****************************************************************
2506	****************************************************************/
2507
2508	static NTSTATUS set_USER_MODALS_INFO_1004_buffer(TALLOC_CTX *mem_ctx,
2509	struct rpc_pipe_client *pipe_cli,
2510	struct policy_handle *domain_handle,
2511	struct USER_MODALS_INFO_1004 *info1004)
2512	{
2513	NTSTATUS status;
2514	struct samr_DomInfo3 dom_info_3;
2515
2516	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2517	pipe_cli,
2518	domain_handle,
2519	NULL,
2520	&dom_info_3,
2521	NULL,
2522	NULL,
2523	NULL,
2524	NULL);
2525	NT_STATUS_NOT_OK_RETURN(status);
2526
2527	unix_to_nt_time_abs(&dom_info_3.force_logoff_time,
2528	info1004->usrmod1004_force_logoff);
2529
2530	return set_USER_MODALS_INFO_rpc(mem_ctx,
2531	pipe_cli,
2532	domain_handle,
2533	NULL,
2534	&dom_info_3,
2535	NULL);
2536	}
2537
2538	/****************************************************************
2539	****************************************************************/
2540
2541	static NTSTATUS set_USER_MODALS_INFO_1005_buffer(TALLOC_CTX *mem_ctx,
2542	struct rpc_pipe_client *pipe_cli,
2543	struct policy_handle *domain_handle,
2544	struct USER_MODALS_INFO_1005 *info1005)
2545	{
2546	NTSTATUS status;
2547	struct samr_DomInfo1 dom_info_1;
2548
2549	status = query_USER_MODALS_INFO_rpc(mem_ctx,
2550	pipe_cli,
2551	domain_handle,
2552	&dom_info_1,
2553	NULL,
2554	NULL,
2555	NULL,
2556	NULL,
2557	NULL);
2558	NT_STATUS_NOT_OK_RETURN(status);
2559
2560	dom_info_1.password_history_length =
2561	info1005->usrmod1005_password_hist_len;
2562
2563	return set_USER_MODALS_INFO_rpc(mem_ctx,
2564	pipe_cli,
2565	domain_handle,
2566	&dom_info_1,
2567	NULL,
2568	NULL);
2569	}
2570
2571	/****************************************************************
2572	****************************************************************/
2573
2574	static NTSTATUS set_USER_MODALS_INFO_buffer(TALLOC_CTX *mem_ctx,
2575	struct rpc_pipe_client *pipe_cli,
2576	uint32_t level,
2577	struct policy_handle *domain_handle,
2578	struct dom_sid *domain_sid,
2579	uint8_t *buffer)
2580	{
2581	struct USER_MODALS_INFO_0 *info0;
2582	struct USER_MODALS_INFO_3 *info3;
2583	struct USER_MODALS_INFO_1001 *info1001;
2584	struct USER_MODALS_INFO_1002 *info1002;
2585	struct USER_MODALS_INFO_1003 *info1003;
2586	struct USER_MODALS_INFO_1004 *info1004;
2587	struct USER_MODALS_INFO_1005 *info1005;
2588
2589	if (!buffer) {
2590	return ERROR_INSUFFICIENT_BUFFER;
2591	}
2592
2593	switch (level) {
2594	case 0:
2595	info0 = (struct USER_MODALS_INFO_0 *)buffer;
2596	return set_USER_MODALS_INFO_0_buffer(mem_ctx,
2597	pipe_cli,
2598	domain_handle,
2599	info0);
2600	case 3:
2601	info3 = (struct USER_MODALS_INFO_3 *)buffer;
2602	return set_USER_MODALS_INFO_3_buffer(mem_ctx,
2603	pipe_cli,
2604	domain_handle,
2605	info3);
2606	case 1001:
2607	info1001 = (struct USER_MODALS_INFO_1001 *)buffer;
2608	return set_USER_MODALS_INFO_1001_buffer(mem_ctx,
2609	pipe_cli,
2610	domain_handle,
2611	info1001);
2612	case 1002:
2613	info1002 = (struct USER_MODALS_INFO_1002 *)buffer;
2614	return set_USER_MODALS_INFO_1002_buffer(mem_ctx,
2615	pipe_cli,
2616	domain_handle,
2617	info1002);
2618	case 1003:
2619	info1003 = (struct USER_MODALS_INFO_1003 *)buffer;
2620	return set_USER_MODALS_INFO_1003_buffer(mem_ctx,
2621	pipe_cli,
2622	domain_handle,
2623	info1003);
2624	case 1004:
2625	info1004 = (struct USER_MODALS_INFO_1004 *)buffer;
2626	return set_USER_MODALS_INFO_1004_buffer(mem_ctx,
2627	pipe_cli,
2628	domain_handle,
2629	info1004);
2630	case 1005:
2631	info1005 = (struct USER_MODALS_INFO_1005 *)buffer;
2632	return set_USER_MODALS_INFO_1005_buffer(mem_ctx,
2633	pipe_cli,
2634	domain_handle,
2635	info1005);
2636
2637	default:
2638	break;
2639	}
2640
2641	return NT_STATUS_OK;
2642	}
2643
2644	/****************************************************************
2645	****************************************************************/
2646
2647	WERROR NetUserModalsSet_r(struct libnetapi_ctx *ctx,
2648	struct NetUserModalsSet *r)
2649	{
2650	struct rpc_pipe_client *pipe_cli = NULL;
2651	NTSTATUS status;
2652	WERROR werr;
2653
2654	struct policy_handle connect_handle, domain_handle;
2655	struct dom_sid2 *domain_sid = NULL;
2656	uint32_t access_mask = SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT;
2657
2658	ZERO_STRUCT(connect_handle);
2659	ZERO_STRUCT(domain_handle);
2660
2661	if (!r->in.buffer) {
2662	return WERR_INVALID_PARAM;
2663	}
2664
2665	switch (r->in.level) {
2666	case 0:
2667	access_mask \|= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 \|
2668	SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 \|
2669	SAMR_DOMAIN_ACCESS_SET_INFO_1 \|
2670	SAMR_DOMAIN_ACCESS_SET_INFO_2;
2671	break;
2672	case 3:
2673	case 1001:
2674	case 1002:
2675	case 1003:
2676	case 1005:
2677	access_mask \|= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_1 \|
2678	SAMR_DOMAIN_ACCESS_SET_INFO_1;
2679	break;
2680	case 1004:
2681	access_mask \|= SAMR_DOMAIN_ACCESS_LOOKUP_INFO_2 \|
2682	SAMR_DOMAIN_ACCESS_SET_INFO_2;
2683	break;
2684	case 1:
2685	case 2:
2686	case 1006:
2687	case 1007:
2688	werr = WERR_NOT_SUPPORTED;
2689	break;
2690	default:
2691	werr = WERR_UNKNOWN_LEVEL;
2692	goto done;
2693	}
2694
2695	werr = libnetapi_open_pipe(ctx, r->in.server_name,
2696	&ndr_table_samr.syntax_id,
2697	&pipe_cli);
2698	if (!W_ERROR_IS_OK(werr)) {
2699	goto done;
2700	}
2701
2702	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2703	SAMR_ACCESS_ENUM_DOMAINS \|
2704	SAMR_ACCESS_LOOKUP_DOMAIN,
2705	access_mask,
2706	&connect_handle,
2707	&domain_handle,
2708	&domain_sid);
2709	if (!W_ERROR_IS_OK(werr)) {
2710	goto done;
2711	}
2712
2713	status = set_USER_MODALS_INFO_buffer(ctx,
2714	pipe_cli,
2715	r->in.level,
2716	&domain_handle,
2717	domain_sid,
2718	r->in.buffer);
2719	if (!NT_STATUS_IS_OK(status)) {
2720	werr = ntstatus_to_werror(status);
2721	goto done;
2722	}
2723
2724	done:
2725	if (ctx->disable_policy_handle_cache) {
2726	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2727	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2728	}
2729
2730	return werr;
2731	}
2732
2733	/****************************************************************
2734	****************************************************************/
2735
2736	WERROR NetUserModalsSet_l(struct libnetapi_ctx *ctx,
2737	struct NetUserModalsSet *r)
2738	{
2739	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserModalsSet);
2740	}
2741
2742	/****************************************************************
2743	****************************************************************/
2744
2745	NTSTATUS add_GROUP_USERS_INFO_X_buffer(TALLOC_CTX *mem_ctx,
2746	uint32_t level,
2747	const char *group_name,
2748	uint32_t attributes,
2749	uint8_t **buffer,
2750	uint32_t *num_entries)
2751	{
2752	struct GROUP_USERS_INFO_0 u0;
2753	struct GROUP_USERS_INFO_1 u1;
2754
2755	switch (level) {
2756	case 0:
2757	if (group_name) {
2758	u0.grui0_name = talloc_strdup(mem_ctx, group_name);
2759	NT_STATUS_HAVE_NO_MEMORY(u0.grui0_name);
2760	} else {
2761	u0.grui0_name = NULL;
2762	}
2763
2764	ADD_TO_ARRAY(mem_ctx, struct GROUP_USERS_INFO_0, u0,
2765	(struct GROUP_USERS_INFO_0 **)buffer, num_entries);
2766	break;
2767	case 1:
2768	if (group_name) {
2769	u1.grui1_name = talloc_strdup(mem_ctx, group_name);
2770	NT_STATUS_HAVE_NO_MEMORY(u1.grui1_name);
2771	} else {
2772	u1.grui1_name = NULL;
2773	}
2774
2775	u1.grui1_attributes = attributes;
2776
2777	ADD_TO_ARRAY(mem_ctx, struct GROUP_USERS_INFO_1, u1,
2778	(struct GROUP_USERS_INFO_1 **)buffer, num_entries);
2779	break;
2780	default:
2781	return NT_STATUS_INVALID_INFO_CLASS;
2782	}
2783
2784	return NT_STATUS_OK;
2785	}
2786
2787	/****************************************************************
2788	****************************************************************/
2789
2790	WERROR NetUserGetGroups_r(struct libnetapi_ctx *ctx,
2791	struct NetUserGetGroups *r)
2792	{
2793	struct rpc_pipe_client *pipe_cli = NULL;
2794	struct policy_handle connect_handle, domain_handle, user_handle;
2795	struct lsa_String lsa_account_name;
2796	struct dom_sid2 *domain_sid = NULL;
2797	struct samr_Ids user_rids, name_types;
2798	struct samr_RidWithAttributeArray *rid_array = NULL;
2799	struct lsa_Strings names;
2800	struct samr_Ids types;
2801	uint32_t *rids = NULL;
2802
2803	int i;
2804	uint32_t entries_read = 0;
2805
2806	NTSTATUS status = NT_STATUS_OK;
2807	WERROR werr;
2808
2809	ZERO_STRUCT(connect_handle);
2810	ZERO_STRUCT(domain_handle);
2811
2812	if (!r->out.buffer) {
2813	return WERR_INVALID_PARAM;
2814	}
2815
2816	*r->out.buffer = NULL;
2817	*r->out.entries_read = 0;
2818	*r->out.total_entries = 0;
2819
2820	switch (r->in.level) {
2821	case 0:
2822	case 1:
2823	break;
2824	default:
2825	return WERR_UNKNOWN_LEVEL;
2826	}
2827
2828	werr = libnetapi_open_pipe(ctx, r->in.server_name,
2829	&ndr_table_samr.syntax_id,
2830	&pipe_cli);
2831	if (!W_ERROR_IS_OK(werr)) {
2832	goto done;
2833	}
2834
2835	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2836	SAMR_ACCESS_ENUM_DOMAINS \|
2837	SAMR_ACCESS_LOOKUP_DOMAIN,
2838	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
2839	&connect_handle,
2840	&domain_handle,
2841	&domain_sid);
2842	if (!W_ERROR_IS_OK(werr)) {
2843	goto done;
2844	}
2845
2846	init_lsa_String(&lsa_account_name, r->in.user_name);
2847
2848	status = rpccli_samr_LookupNames(pipe_cli, ctx,
2849	&domain_handle,
2850	1,
2851	&lsa_account_name,
2852	&user_rids,
2853	&name_types);
2854	if (!NT_STATUS_IS_OK(status)) {
2855	werr = ntstatus_to_werror(status);
2856	goto done;
2857	}
2858
2859	status = rpccli_samr_OpenUser(pipe_cli, ctx,
2860	&domain_handle,
2861	SAMR_USER_ACCESS_GET_GROUPS,
2862	user_rids.ids[0],
2863	&user_handle);
2864	if (!NT_STATUS_IS_OK(status)) {
2865	werr = ntstatus_to_werror(status);
2866	goto done;
2867	}
2868
2869	status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
2870	&user_handle,
2871	&rid_array);
2872	if (!NT_STATUS_IS_OK(status)) {
2873	werr = ntstatus_to_werror(status);
2874	goto done;
2875	}
2876
2877	rids = talloc_array(ctx, uint32_t, rid_array->count);
2878	if (!rids) {
2879	werr = WERR_NOMEM;
2880	goto done;
2881	}
2882
2883	for (i=0; i < rid_array->count; i++) {
2884	rids[i] = rid_array->rids[i].rid;
2885	}
2886
2887	status = rpccli_samr_LookupRids(pipe_cli, ctx,
2888	&domain_handle,
2889	rid_array->count,
2890	rids,
2891	&names,
2892	&types);
2893	if (!NT_STATUS_IS_OK(status) &&
2894	!NT_STATUS_EQUAL(status, STATUS_SOME_UNMAPPED)) {
2895	werr = ntstatus_to_werror(status);
2896	goto done;
2897	}
2898
2899	for (i=0; i < names.count; i++) {
2900	status = add_GROUP_USERS_INFO_X_buffer(ctx,
2901	r->in.level,
2902	names.names[i].string,
2903	rid_array->rids[i].attributes,
2904	r->out.buffer,
2905	&entries_read);
2906	if (!NT_STATUS_IS_OK(status)) {
2907	werr = ntstatus_to_werror(status);
2908	goto done;
2909	}
2910	}
2911
2912	*r->out.entries_read = entries_read;
2913	*r->out.total_entries = entries_read;
2914
2915	done:
2916	if (ctx->disable_policy_handle_cache) {
2917	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
2918	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
2919	}
2920
2921	return werr;
2922	}
2923
2924	/****************************************************************
2925	****************************************************************/
2926
2927	WERROR NetUserGetGroups_l(struct libnetapi_ctx *ctx,
2928	struct NetUserGetGroups *r)
2929	{
2930	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetGroups);
2931	}
2932
2933	/****************************************************************
2934	****************************************************************/
2935
2936	WERROR NetUserSetGroups_r(struct libnetapi_ctx *ctx,
2937	struct NetUserSetGroups *r)
2938	{
2939	struct rpc_pipe_client *pipe_cli = NULL;
2940	struct policy_handle connect_handle, domain_handle, user_handle, group_handle;
2941	struct lsa_String lsa_account_name;
2942	struct dom_sid2 *domain_sid = NULL;
2943	struct samr_Ids user_rids, name_types;
2944	struct samr_Ids group_rids;
2945	struct samr_RidWithAttributeArray *rid_array = NULL;
2946	struct lsa_String *lsa_names = NULL;
2947
2948	uint32_t *add_rids = NULL;
2949	uint32_t *del_rids = NULL;
2950	size_t num_add_rids = 0;
2951	size_t num_del_rids = 0;
2952
2953	uint32_t *member_rids = NULL;
2954	size_t num_member_rids = 0;
2955
2956	struct GROUP_USERS_INFO_0 *i0 = NULL;
2957	struct GROUP_USERS_INFO_1 *i1 = NULL;
2958
2959	int i, k;
2960
2961	NTSTATUS status = NT_STATUS_OK;
2962	WERROR werr;
2963
2964	ZERO_STRUCT(connect_handle);
2965	ZERO_STRUCT(domain_handle);
2966
2967	if (!r->in.buffer) {
2968	return WERR_INVALID_PARAM;
2969	}
2970
2971	switch (r->in.level) {
2972	case 0:
2973	case 1:
2974	break;
2975	default:
2976	return WERR_UNKNOWN_LEVEL;
2977	}
2978
2979	werr = libnetapi_open_pipe(ctx, r->in.server_name,
2980	&ndr_table_samr.syntax_id,
2981	&pipe_cli);
2982	if (!W_ERROR_IS_OK(werr)) {
2983	goto done;
2984	}
2985
2986	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
2987	SAMR_ACCESS_ENUM_DOMAINS \|
2988	SAMR_ACCESS_LOOKUP_DOMAIN,
2989	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT,
2990	&connect_handle,
2991	&domain_handle,
2992	&domain_sid);
2993	if (!W_ERROR_IS_OK(werr)) {
2994	goto done;
2995	}
2996
2997	init_lsa_String(&lsa_account_name, r->in.user_name);
2998
2999	status = rpccli_samr_LookupNames(pipe_cli, ctx,
3000	&domain_handle,
3001	1,
3002	&lsa_account_name,
3003	&user_rids,
3004	&name_types);
3005	if (!NT_STATUS_IS_OK(status)) {
3006	werr = ntstatus_to_werror(status);
3007	goto done;
3008	}
3009
3010	status = rpccli_samr_OpenUser(pipe_cli, ctx,
3011	&domain_handle,
3012	SAMR_USER_ACCESS_GET_GROUPS,
3013	user_rids.ids[0],
3014	&user_handle);
3015	if (!NT_STATUS_IS_OK(status)) {
3016	werr = ntstatus_to_werror(status);
3017	goto done;
3018	}
3019
3020	switch (r->in.level) {
3021	case 0:
3022	i0 = (struct GROUP_USERS_INFO_0 *)r->in.buffer;
3023	break;
3024	case 1:
3025	i1 = (struct GROUP_USERS_INFO_1 *)r->in.buffer;
3026	break;
3027	}
3028
3029	lsa_names = talloc_array(ctx, struct lsa_String, r->in.num_entries);
3030	if (!lsa_names) {
3031	werr = WERR_NOMEM;
3032	goto done;
3033	}
3034
3035	for (i=0; i < r->in.num_entries; i++) {
3036
3037	switch (r->in.level) {
3038	case 0:
3039	init_lsa_String(&lsa_names[i], i0->grui0_name);
3040	i0++;
3041	break;
3042	case 1:
3043	init_lsa_String(&lsa_names[i], i1->grui1_name);
3044	i1++;
3045	break;
3046	}
3047	}
3048
3049	status = rpccli_samr_LookupNames(pipe_cli, ctx,
3050	&domain_handle,
3051	r->in.num_entries,
3052	lsa_names,
3053	&group_rids,
3054	&name_types);
3055	if (!NT_STATUS_IS_OK(status)) {
3056	werr = ntstatus_to_werror(status);
3057	goto done;
3058	}
3059
3060	member_rids = group_rids.ids;
3061	num_member_rids = group_rids.count;
3062
3063	status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
3064	&user_handle,
3065	&rid_array);
3066	if (!NT_STATUS_IS_OK(status)) {
3067	werr = ntstatus_to_werror(status);
3068	goto done;
3069	}
3070
3071	/* add list */
3072
3073	for (i=0; i < r->in.num_entries; i++) {
3074	bool already_member = false;
3075	for (k=0; k < rid_array->count; k++) {
3076	if (member_rids[i] == rid_array->rids[k].rid) {
3077	already_member = true;
3078	break;
3079	}
3080	}
3081	if (!already_member) {
3082	if (!add_rid_to_array_unique(ctx,
3083	member_rids[i],
3084	&add_rids, &num_add_rids)) {
3085	werr = WERR_GENERAL_FAILURE;
3086	goto done;
3087	}
3088	}
3089	}
3090
3091	/* del list */
3092
3093	for (k=0; k < rid_array->count; k++) {
3094	bool keep_member = false;
3095	for (i=0; i < r->in.num_entries; i++) {
3096	if (member_rids[i] == rid_array->rids[k].rid) {
3097	keep_member = true;
3098	break;
3099	}
3100	}
3101	if (!keep_member) {
3102	if (!add_rid_to_array_unique(ctx,
3103	rid_array->rids[k].rid,
3104	&del_rids, &num_del_rids)) {
3105	werr = WERR_GENERAL_FAILURE;
3106	goto done;
3107	}
3108	}
3109	}
3110
3111	/* add list */
3112
3113	for (i=0; i < num_add_rids; i++) {
3114	status = rpccli_samr_OpenGroup(pipe_cli, ctx,
3115	&domain_handle,
3116	SAMR_GROUP_ACCESS_ADD_MEMBER,
3117	add_rids[i],
3118	&group_handle);
3119	if (!NT_STATUS_IS_OK(status)) {
3120	werr = ntstatus_to_werror(status);
3121	goto done;
3122	}
3123
3124	status = rpccli_samr_AddGroupMember(pipe_cli, ctx,
3125	&group_handle,
3126	user_rids.ids[0],
3127	7 /* ? */);
3128	if (!NT_STATUS_IS_OK(status)) {
3129	werr = ntstatus_to_werror(status);
3130	goto done;
3131	}
3132
3133	if (is_valid_policy_hnd(&group_handle)) {
3134	rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3135	}
3136	}
3137
3138	/* del list */
3139
3140	for (i=0; i < num_del_rids; i++) {
3141	status = rpccli_samr_OpenGroup(pipe_cli, ctx,
3142	&domain_handle,
3143	SAMR_GROUP_ACCESS_REMOVE_MEMBER,
3144	del_rids[i],
3145	&group_handle);
3146	if (!NT_STATUS_IS_OK(status)) {
3147	werr = ntstatus_to_werror(status);
3148	goto done;
3149	}
3150
3151	status = rpccli_samr_DeleteGroupMember(pipe_cli, ctx,
3152	&group_handle,
3153	user_rids.ids[0]);
3154	if (!NT_STATUS_IS_OK(status)) {
3155	werr = ntstatus_to_werror(status);
3156	goto done;
3157	}
3158
3159	if (is_valid_policy_hnd(&group_handle)) {
3160	rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3161	}
3162	}
3163
3164	werr = WERR_OK;
3165
3166	done:
3167	if (is_valid_policy_hnd(&group_handle)) {
3168	rpccli_samr_Close(pipe_cli, ctx, &group_handle);
3169	}
3170
3171	if (ctx->disable_policy_handle_cache) {
3172	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
3173	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
3174	}
3175
3176	return werr;
3177	}
3178
3179	/****************************************************************
3180	****************************************************************/
3181
3182	WERROR NetUserSetGroups_l(struct libnetapi_ctx *ctx,
3183	struct NetUserSetGroups *r)
3184	{
3185	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserSetGroups);
3186	}
3187
3188	/****************************************************************
3189	****************************************************************/
3190
3191	static NTSTATUS add_LOCALGROUP_USERS_INFO_X_buffer(TALLOC_CTX *mem_ctx,
3192	uint32_t level,
3193	const char *group_name,
3194	uint8_t **buffer,
3195	uint32_t *num_entries)
3196	{
3197	struct LOCALGROUP_USERS_INFO_0 u0;
3198
3199	switch (level) {
3200	case 0:
3201	u0.lgrui0_name = talloc_strdup(mem_ctx, group_name);
3202	NT_STATUS_HAVE_NO_MEMORY(u0.lgrui0_name);
3203
3204	ADD_TO_ARRAY(mem_ctx, struct LOCALGROUP_USERS_INFO_0, u0,
3205	(struct LOCALGROUP_USERS_INFO_0 **)buffer, num_entries);
3206	break;
3207	default:
3208	return NT_STATUS_INVALID_INFO_CLASS;
3209	}
3210
3211	return NT_STATUS_OK;
3212	}
3213
3214	/****************************************************************
3215	****************************************************************/
3216
3217	WERROR NetUserGetLocalGroups_r(struct libnetapi_ctx *ctx,
3218	struct NetUserGetLocalGroups *r)
3219	{
3220	struct rpc_pipe_client *pipe_cli = NULL;
3221	struct policy_handle connect_handle, domain_handle, user_handle,
3222	builtin_handle;
3223	struct lsa_String lsa_account_name;
3224	struct dom_sid2 *domain_sid = NULL;
3225	struct samr_Ids user_rids, name_types;
3226	struct samr_RidWithAttributeArray *rid_array = NULL;
3227	struct lsa_Strings names;
3228	struct samr_Ids types;
3229	uint32_t *rids = NULL;
3230	size_t num_rids = 0;
3231	struct dom_sid user_sid;
3232	struct lsa_SidArray sid_array;
3233	struct samr_Ids domain_rids;
3234	struct samr_Ids builtin_rids;
3235
3236	int i;
3237	uint32_t entries_read = 0;
3238
3239	NTSTATUS status = NT_STATUS_OK;
3240	WERROR werr;
3241
3242	ZERO_STRUCT(connect_handle);
3243	ZERO_STRUCT(domain_handle);
3244
3245	if (!r->out.buffer) {
3246	return WERR_INVALID_PARAM;
3247	}
3248
3249	*r->out.buffer = NULL;
3250	*r->out.entries_read = 0;
3251	*r->out.total_entries = 0;
3252
3253	switch (r->in.level) {
3254	case 0:
3255	case 1:
3256	break;
3257	default:
3258	return WERR_UNKNOWN_LEVEL;
3259	}
3260
3261	werr = libnetapi_open_pipe(ctx, r->in.server_name,
3262	&ndr_table_samr.syntax_id,
3263	&pipe_cli);
3264	if (!W_ERROR_IS_OK(werr)) {
3265	goto done;
3266	}
3267
3268	werr = libnetapi_samr_open_domain(ctx, pipe_cli,
3269	SAMR_ACCESS_ENUM_DOMAINS \|
3270	SAMR_ACCESS_LOOKUP_DOMAIN,
3271	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT \|
3272	SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
3273	&connect_handle,
3274	&domain_handle,
3275	&domain_sid);
3276	if (!W_ERROR_IS_OK(werr)) {
3277	goto done;
3278	}
3279
3280	werr = libnetapi_samr_open_builtin_domain(ctx, pipe_cli,
3281	SAMR_ACCESS_ENUM_DOMAINS \|
3282	SAMR_ACCESS_LOOKUP_DOMAIN,
3283	SAMR_DOMAIN_ACCESS_OPEN_ACCOUNT \|
3284	SAMR_DOMAIN_ACCESS_LOOKUP_ALIAS,
3285	&connect_handle,
3286	&builtin_handle);
3287	if (!W_ERROR_IS_OK(werr)) {
3288	goto done;
3289	}
3290
3291	init_lsa_String(&lsa_account_name, r->in.user_name);
3292
3293	status = rpccli_samr_LookupNames(pipe_cli, ctx,
3294	&domain_handle,
3295	1,
3296	&lsa_account_name,
3297	&user_rids,
3298	&name_types);
3299	if (!NT_STATUS_IS_OK(status)) {
3300	werr = ntstatus_to_werror(status);
3301	goto done;
3302	}
3303
3304	status = rpccli_samr_OpenUser(pipe_cli, ctx,
3305	&domain_handle,
3306	SAMR_USER_ACCESS_GET_GROUPS,
3307	user_rids.ids[0],
3308	&user_handle);
3309	if (!NT_STATUS_IS_OK(status)) {
3310	werr = ntstatus_to_werror(status);
3311	goto done;
3312	}
3313
3314	status = rpccli_samr_GetGroupsForUser(pipe_cli, ctx,
3315	&user_handle,
3316	&rid_array);
3317	if (!NT_STATUS_IS_OK(status)) {
3318	werr = ntstatus_to_werror(status);
3319	goto done;
3320	}
3321
3322	if (!sid_compose(&user_sid, domain_sid, user_rids.ids[0])) {
3323	werr = WERR_NOMEM;
3324	goto done;
3325	}
3326
3327	sid_array.num_sids = rid_array->count + 1;
3328	sid_array.sids = TALLOC_ARRAY(ctx, struct lsa_SidPtr, sid_array.num_sids);
3329	if (!sid_array.sids) {
3330	werr = WERR_NOMEM;
3331	goto done;
3332	}
3333
3334	sid_array.sids[0].sid = sid_dup_talloc(ctx, &user_sid);
3335	if (!sid_array.sids[0].sid) {
3336	werr = WERR_NOMEM;
3337	goto done;
3338	}
3339
3340	for (i=0; i < rid_array->count; i++) {
3341	struct dom_sid sid;
3342
3343	if (!sid_compose(&sid, domain_sid, rid_array->rids[i].rid)) {
3344	werr = WERR_NOMEM;
3345	goto done;
3346	}
3347
3348	sid_array.sids[i+1].sid = sid_dup_talloc(ctx, &sid);
3349	if (!sid_array.sids[i+1].sid) {
3350	werr = WERR_NOMEM;
3351	goto done;
3352	}
3353	}
3354
3355	status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
3356	&domain_handle,
3357	&sid_array,
3358	&domain_rids);
3359	if (!NT_STATUS_IS_OK(status)) {
3360	werr = ntstatus_to_werror(status);
3361	goto done;
3362	}
3363
3364	for (i=0; i < domain_rids.count; i++) {
3365	if (!add_rid_to_array_unique(ctx, domain_rids.ids[i],
3366	&rids, &num_rids)) {
3367	werr = WERR_NOMEM;
3368	goto done;
3369	}
3370	}
3371
3372	status = rpccli_samr_GetAliasMembership(pipe_cli, ctx,
3373	&builtin_handle,
3374	&sid_array,
3375	&builtin_rids);
3376	if (!NT_STATUS_IS_OK(status)) {
3377	werr = ntstatus_to_werror(status);
3378	goto done;
3379	}
3380
3381	for (i=0; i < builtin_rids.count; i++) {
3382	if (!add_rid_to_array_unique(ctx, builtin_rids.ids[i],
3383	&rids, &num_rids)) {
3384	werr = WERR_NOMEM;
3385	goto done;
3386	}
3387	}
3388
3389	status = rpccli_samr_LookupRids(pipe_cli, ctx,
3390	&builtin_handle,
3391	num_rids,
3392	rids,
3393	&names,
3394	&types);
3395	if (!NT_STATUS_IS_OK(status)) {
3396	werr = ntstatus_to_werror(status);
3397	goto done;
3398	}
3399
3400	for (i=0; i < names.count; i++) {
3401	status = add_LOCALGROUP_USERS_INFO_X_buffer(ctx,
3402	r->in.level,
3403	names.names[i].string,
3404	r->out.buffer,
3405	&entries_read);
3406	if (!NT_STATUS_IS_OK(status)) {
3407	werr = ntstatus_to_werror(status);
3408	goto done;
3409	}
3410	}
3411
3412	*r->out.entries_read = entries_read;
3413	*r->out.total_entries = entries_read;
3414
3415	done:
3416	if (ctx->disable_policy_handle_cache) {
3417	libnetapi_samr_close_domain_handle(ctx, &domain_handle);
3418	libnetapi_samr_close_connect_handle(ctx, &connect_handle);
3419	}
3420
3421	return werr;
3422	}
3423
3424	/****************************************************************
3425	****************************************************************/
3426
3427	WERROR NetUserGetLocalGroups_l(struct libnetapi_ctx *ctx,
3428	struct NetUserGetLocalGroups *r)
3429	{
3430	LIBNETAPI_REDIRECT_TO_LOCALHOST(ctx, r, NetUserGetLocalGroups);
3431	}

Note: See TracBrowser for help on using the repository browser.

Download in other formats: