?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
fixed error check which caused domain logons to fail
[Samba.git] / source / rpc_server / srv_samr_nt.c
blob1f61919be966da2cab51d4e6a83254d35849a7f3
1 /*
2 * Unix SMB/Netbios implementation.
3 * Version 1.9.
4 * RPC Pipe client / server routines
5 * Copyright (C) Andrew Tridgell 1992-1997,
6 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
7 * Copyright (C) Paul Ashton 1997.
8 * Copyright (C) Marc Jacobsen 1999.
9 * Copyright (C) Jeremy Allison 2001.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 /*
27 * This is the implementation of the SAMR code.
28 */
29
30 #include "includes.h"
31
32 extern fstring global_myworkgroup;
33 extern pstring global_myname;
34 extern DOM_SID global_sam_sid;
35 extern DOM_SID global_sid_Builtin;
36
37 extern rid_name domain_group_rids[];
38 extern rid_name domain_alias_rids[];
39 extern rid_name builtin_alias_rids[];
40
41 struct samr_info {
42 /* for use by the \PIPE\samr policy */
43 DOM_SID sid;
44 uint32 status; /* some sort of flag. best to record it. comes from opnum 0x39 */
45 };
46
47 /*******************************************************************
48 Function to free the per handle data.
49 ********************************************************************/
50
51 static void free_samr_info(void *ptr)
52 {
53 SAFE_FREE(ptr);
54 }
55
56 /*******************************************************************
57 Ensure password info is never given out. Paranioa... JRA.
58 ********************************************************************/
59
60 static void samr_clear_passwd_fields( SAM_USER_INFO_21 *pass, int num_entries)
61 {
62 int i;
63
64 if (!pass)
65 return;
66
67 for (i = 0; i < num_entries; i++) {
68 memset(&pass[i].lm_pwd, '\0', sizeof(pass[i].lm_pwd));
69 memset(&pass[i].nt_pwd, '\0', sizeof(pass[i].nt_pwd));
70 }
71 }
72
73 static void samr_clear_sam_passwd(SAM_ACCOUNT *sam_pass)
74 {
75 if (!sam_pass)
76 return;
77
78 if (sam_pass->lm_pw) memset(sam_pass->lm_pw, '\0', 16);
79 if (sam_pass->nt_pw) memset(sam_pass->nt_pw, '\0', 16);
80 }
81
82 /*******************************************************************
83 This next function should be replaced with something that
84 dynamically returns the correct user info..... JRA.
85 ********************************************************************/
86
87 static NTSTATUS get_sampwd_entries(SAM_USER_INFO_21 *pw_buf, int start_idx,
88 int *total_entries, int *num_entries,
89 int max_num_entries, uint16 acb_mask)
90 {
91 SAM_ACCOUNT *pwd = NULL;
92 BOOL not_finished = True;
93
94 (*num_entries) = 0;
95 (*total_entries) = 0;
96
97 if (pw_buf == NULL)
98 return NT_STATUS_NO_MEMORY;
99
100 pdb_init_sam(&pwd);
101
102 if (!pdb_setsampwent(False)) {
103 DEBUG(0, ("get_sampwd_entries: Unable to open passdb.\n"));
104 pdb_free_sam(pwd);
105 return NT_STATUS_ACCESS_DENIED;
106 }
107
108 while (((not_finished = pdb_getsampwent(pwd)) != False)
109 && (*num_entries) < max_num_entries)
110 {
111 int user_name_len;
112
113 if (start_idx > 0) {
114 /* skip the requested number of entries.
115 not very efficient, but hey... */
116 pdb_reset_sam(pwd);
117 start_idx--;
118 continue;
119 }
120
121 user_name_len = strlen(pdb_get_username(pwd))+1;
122 init_unistr2(&pw_buf[(*num_entries)].uni_user_name, pdb_get_username(pwd), user_name_len);
123 init_uni_hdr(&pw_buf[(*num_entries)].hdr_user_name, user_name_len);
124 pw_buf[(*num_entries)].user_rid = pwd->user_rid;
125 memset((char *)pw_buf[(*num_entries)].nt_pwd, '\0', 16);
126
127 /* Now check if the NT compatible password is available. */
128 if (pdb_get_nt_passwd(pwd))
129 memcpy( pw_buf[(*num_entries)].nt_pwd , pdb_get_nt_passwd(pwd), 16);
130
131 pw_buf[(*num_entries)].acb_info = pdb_get_acct_ctrl(pwd);
132
133 DEBUG(5, ("entry idx: %d user %s, rid 0x%x, acb %x",
134 (*num_entries), pdb_get_username(pwd), pdb_get_user_rid(pwd), pdb_get_acct_ctrl(pwd) ));
135
136 if (acb_mask == 0 || (pwd->acct_ctrl & acb_mask)) {
137 DEBUG(5,(" acb_mask %x accepts\n", acb_mask));
138 (*num_entries)++;
139 } else
140 DEBUG(5,(" acb_mask %x rejects\n", acb_mask));
141
142 (*total_entries)++;
143 pdb_reset_sam(pwd);
144 }
145
146 pdb_endsampwent();
147 pdb_free_sam(pwd);
148
149 if (not_finished)
150 return STATUS_MORE_ENTRIES;
151 else
152 return NT_STATUS_OK;
153 }
154
155 static NTSTATUS jf_get_sampwd_entries(SAM_USER_INFO_21 *pw_buf, int start_idx,
156 int *total_entries, uint32 *num_entries,
157 int max_num_entries, uint16 acb_mask)
158 {
159 SAM_ACCOUNT *pwd = NULL;
160 BOOL not_finished = True;
161
162 *num_entries = 0;
163 *total_entries = 0;
164
165 if (pw_buf == NULL)
166 return NT_STATUS_NO_MEMORY;
167
168 DEBUG(10,("jf_get_sampwd_entries: start index:%d, max entries:%d, mask:%d\n",
169 start_idx, max_num_entries, acb_mask));
170
171 if (!pdb_setsampwent(False)) {
172 DEBUG(0, ("jf_get_sampwd_entries: Unable to open passdb.\n"));
173 return NT_STATUS_ACCESS_DENIED;
174 }
175
176 pdb_init_sam(&pwd);
177
178 while (((not_finished = pdb_getsampwent(pwd)) != False) && (*num_entries) < max_num_entries) {
179 int user_name_len;
180 int full_name_len;
181
182 if (acb_mask != 0 && !(pdb_get_acct_ctrl(pwd) & acb_mask)) {
183 pdb_reset_sam(pwd);
184 continue;
185 }
186
187 if (start_idx > 0) {
188 /* skip the requested number of entries.
189 not very efficient, but hey...
190 */
191 start_idx--;
192 pdb_reset_sam(pwd);
193 continue;
194 }
195
196 ZERO_STRUCTP(&pw_buf[(*num_entries)]);
197
198 user_name_len = strlen(pdb_get_username(pwd));
199 init_unistr2(&pw_buf[(*num_entries)].uni_user_name, pdb_get_username(pwd), user_name_len);
200 init_uni_hdr(&pw_buf[(*num_entries)].hdr_user_name, user_name_len);
201
202 full_name_len = strlen(pdb_get_fullname(pwd));
203 init_unistr2(&pw_buf[(*num_entries)].uni_full_name, pdb_get_fullname(pwd), full_name_len);
204 init_uni_hdr(&pw_buf[(*num_entries)].hdr_full_name, full_name_len);
205
206 pw_buf[(*num_entries)].user_rid = pdb_get_user_rid(pwd);
207 memset((char *)pw_buf[(*num_entries)].nt_pwd, '\0', 16);
208
209 /* Now check if the NT compatible password is available. */
210 if (pdb_get_nt_passwd(pwd))
211 memcpy( pw_buf[(*num_entries)].nt_pwd , pdb_get_nt_passwd(pwd), 16);
212
213 pw_buf[(*num_entries)].acb_info = pdb_get_acct_ctrl(pwd);
214
215 DEBUG(5, ("entry idx: %d user %s, rid 0x%x, acb %x\n", (*num_entries),
216 pdb_get_username(pwd), pdb_get_user_rid(pwd), pdb_get_acct_ctrl(pwd) ));
217
218 (*num_entries)++;
219
220 pdb_reset_sam(pwd);
221 }
222
223 pdb_endsampwent();
224
225 *total_entries = *num_entries;
226
227 pdb_free_sam(pwd);
228
229 if (not_finished)
230 return STATUS_MORE_ENTRIES;
231 else
232 return NT_STATUS_OK;
233 }
234
235 /*
236 * These next two functions are not used. Tagged
237 * for deletion
238 */
239
240 #if 0
241 /*******************************************************************
242 This function uses the username map file and tries to map a UNIX
243 user name to an DOS name. (Sort of the reverse of the
244 map_username() function.) Since more than one DOS name can map
245 to the UNIX name, to reverse the mapping you have to specify
246 which corresponding DOS name you want; that's where the name_idx
247 parameter comes in. Returns the string requested or NULL if it
248 fails or can't complete the request for any reason. This doesn't
249 handle group names (starting with '@') or names starting with
250 '+' or '&'. If they are encountered, they are skipped.
251 ********************************************************************/
252
253 static char *unmap_unixname(char *unix_user_name, int name_idx)
254 {
255 char *mapfile = lp_username_map();
256 char **lines;
257 static pstring tok;
258 int i;
259
260 if (!*unix_user_name) return NULL;
261 if (!*mapfile) return NULL;
262
263 lines = file_lines_load(mapfile, NULL,False);
264 if (!lines) {
265 DEBUG(0,("unmap_unixname: can't open username map %s\n", mapfile));
266 return NULL;
267 }
268
269 DEBUG(5,("unmap_unixname: scanning username map %s, index: %d\n", mapfile, name_idx));
270
271 for (i=0; lines[i]; i++) {
272 char *unixname = lines[i];
273 char *dosname = strchr(unixname,'=');
274
275 if (!dosname)
276 continue;
277
278 *dosname++ = 0;
279
280 while (isspace(*unixname))
281 unixname++;
282 if ('!' == *unixname) {
283 unixname++;
284 while (*unixname && isspace(*unixname))
285 unixname++;
286 }
287
288 if (!*unixname || strchr("#;",*unixname))
289 continue;
290
291 if (strncmp(unixname, unix_user_name, strlen(unix_user_name)))
292 continue;
293
294 /* We have matched the UNIX user name */
295
296 while(next_token(&dosname, tok, LIST_SEP, sizeof(tok))) {
297 if (!strchr("@&+", *tok)) {
298 name_idx--;
299 if (name_idx < 0 ) {
300 break;
301 }
302 }
303 }
304
305 if (name_idx >= 0) {
306 DEBUG(0,("unmap_unixname: index too high - not that many DOS names\n"));
307 file_lines_free(lines);
308 return NULL;
309 } else {
310 file_lines_free(lines);
311 return tok;
312 }
313 }
314
315 DEBUG(0,("unmap_unixname: Couldn't find the UNIX user name\n"));
316 file_lines_free(lines);
317 return NULL;
318 }
319
320 /*******************************************************************
321 This function sets up a list of users taken from the list of
322 users that UNIX knows about, as well as all the user names that
323 Samba maps to a valid UNIX user name. (This should work with
324 /etc/passwd or NIS.)
325 ********************************************************************/
326
327 static BOOL get_passwd_entries(SAM_USER_INFO_21 *pw_buf,
328 int start_idx,
329 int *total_entries, int *num_entries,
330 int max_num_entries,
331 uint16 acb_mask)
332 {
333 static struct passwd *pwd = NULL;
334 static uint32 pw_rid;
335 static BOOL orig_done = False;
336 static int current_idx = 0;
337 static int mapped_idx = 0;
338 char *sep;
339
340 DEBUG(5, ("get_passwd_entries: retrieving a list of UNIX users\n"));
341
342 (*num_entries) = 0;
343 (*total_entries) = 0;
344
345 /* Skip all this stuff if we're in appliance mode */
346
347 if (lp_hide_local_users()) goto done;
348
349 if (pw_buf == NULL) return False;
350
351 if (current_idx == 0) {
352 sys_setpwent();
353 }
354
355 /* These two cases are inefficient, but should be called very rarely */
356 /* they are the cases where the starting index isn't picking up */
357 /* where we left off last time. It is efficient when it starts over */
358 /* at zero though. */
359 if (start_idx > current_idx) {
360 /* We aren't far enough; advance to start_idx */
361 while (current_idx <= start_idx) {
362 char *unmap_name;
363
364 if(!orig_done) {
365 if ((pwd = sys_getpwent()) == NULL) break;
366 current_idx++;
367 orig_done = True;
368 }
369
370 while (((unmap_name = unmap_unixname(pwd->pw_name, mapped_idx)) != NULL) &&
371 (current_idx < start_idx)) {
372 current_idx++;
373 mapped_idx++;
374 }
375
376 if (unmap_name == NULL) {
377 orig_done = False;
378 mapped_idx = 0;
379 }
380 }
381 } else if (start_idx < current_idx) {
382 /* We are already too far; start over and advance to start_idx */
383 sys_endpwent();
384 sys_setpwent();
385 current_idx = 0;
386 mapped_idx = 0;
387 orig_done = False;
388 while (current_idx < start_idx) {
389 char *unmap_name;
390
391 if(!orig_done) {
392 if ((pwd = sys_getpwent()) == NULL) break;
393 current_idx++;
394 orig_done = True;
395 }
396
397 while (((unmap_name = unmap_unixname(pwd->pw_name, mapped_idx)) != NULL) &&
398 (current_idx < start_idx)) {
399 current_idx++;
400 mapped_idx++;
401 }
402
403 if (unmap_name == NULL) {
404 orig_done = False;
405 mapped_idx = 0;
406 }
407 }
408 }
409
410 sep = lp_winbind_separator();
411
412 /* now current_idx == start_idx */
413 while ((*num_entries) < max_num_entries) {
414 int user_name_len;
415 char *unmap_name;
416
417 /* This does the original UNIX user itself */
418 if(!orig_done) {
419 if ((pwd = sys_getpwent()) == NULL) break;
420
421 /* Don't enumerate winbind users as they are not local */
422
423 if (strchr(pwd->pw_name, *sep) != NULL) {
424 continue;
425 }
426
427 user_name_len = strlen(pwd->pw_name);
428
429 /* skip the trust account stored in the /etc/passwd file */
430 if (pwd->pw_name[user_name_len-1]=='$')
431 continue;
432
433 pw_rid = pdb_uid_to_user_rid(pwd->pw_uid);
434 ZERO_STRUCTP(&pw_buf[(*num_entries)]);
435 init_unistr2(&pw_buf[(*num_entries)].uni_user_name, pwd->pw_name, user_name_len);
436 init_uni_hdr(&pw_buf[(*num_entries)].hdr_user_name, user_name_len);
437 pw_buf[(*num_entries)].user_rid = pw_rid;
438 memset((char *)pw_buf[(*num_entries)].nt_pwd, '\0', 16);
439
440 pw_buf[(*num_entries)].acb_info = ACB_NORMAL;
441
442 DEBUG(5, ("get_passwd_entries: entry idx %d user %s, rid 0x%x\n", (*num_entries), pwd->pw_name, pw_rid));
443
444 (*num_entries)++;
445 (*total_entries)++;
446 current_idx++;
447 orig_done = True;
448 }
449
450 /* This does all the user names that map to the UNIX user */
451 while (((unmap_name = unmap_unixname(pwd->pw_name, mapped_idx)) != NULL) &&
452 (*num_entries < max_num_entries)) {
453 user_name_len = strlen(unmap_name);
454 ZERO_STRUCTP(&pw_buf[(*num_entries)]);
455 init_unistr2(&pw_buf[(*num_entries)].uni_user_name, unmap_name, user_name_len);
456 init_uni_hdr(&pw_buf[(*num_entries)].hdr_user_name, user_name_len);
457 pw_buf[(*num_entries)].user_rid = pw_rid;
458 memset((char *)pw_buf[(*num_entries)].nt_pwd, '\0', 16);
459
460 pw_buf[(*num_entries)].acb_info = ACB_NORMAL;
461
462 DEBUG(5, ("get_passwd_entries: entry idx %d user %s, rid 0x%x\n", (*num_entries), pwd->pw_name, pw_rid));
463
464 (*num_entries)++;
465 (*total_entries)++;
466 current_idx++;
467 mapped_idx++;
468 }
469
470 if (unmap_name == NULL) {
471 /* done with 'aliases', go on to next UNIX user */
472 orig_done = False;
473 mapped_idx = 0;
474 }
475 }
476
477 if (pwd == NULL) {
478 /* totally done, reset everything */
479 sys_endpwent();
480 current_idx = 0;
481 mapped_idx = 0;
482 }
483
484 done:
485 return (*num_entries) > 0;
486 }
487 #endif
488
489 /*******************************************************************
490 _samr_close_hnd
491 ********************************************************************/
492
493 NTSTATUS _samr_close_hnd(pipes_struct *p, SAMR_Q_CLOSE_HND *q_u, SAMR_R_CLOSE_HND *r_u)
494 {
495 r_u->status = NT_STATUS_OK;
496
497 /* close the policy handle */
498 if (!close_policy_hnd(p, &q_u->pol))
499 return NT_STATUS_OBJECT_NAME_INVALID;
500
501 DEBUG(5,("samr_reply_close_hnd: %d\n", __LINE__));
502
503 return r_u->status;
504 }
505
506 /*******************************************************************
507 samr_reply_open_domain
508 ********************************************************************/
509
510 NTSTATUS _samr_open_domain(pipes_struct *p, SAMR_Q_OPEN_DOMAIN *q_u, SAMR_R_OPEN_DOMAIN *r_u)
511 {
512 struct samr_info *info;
513
514 r_u->status = NT_STATUS_OK;
515
516 /* find the connection policy handle. */
517 if (!find_policy_by_hnd(p, &q_u->pol, NULL))
518 return NT_STATUS_INVALID_HANDLE;
519
520 /* associate the domain SID with the (unique) handle. */
521 if ((info = (struct samr_info *)malloc(sizeof(struct samr_info))) == NULL)
522 return NT_STATUS_NO_MEMORY;
523
524 ZERO_STRUCTP(info);
525 info->sid = q_u->dom_sid.sid;
526
527 /* get a (unique) handle. open a policy on it. */
528 if (!create_policy_hnd(p, &r_u->domain_pol, free_samr_info, (void *)info))
529 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
530
531 DEBUG(5,("samr_open_domain: %d\n", __LINE__));
532
533 return r_u->status;
534 }
535
536 static uint32 get_lsa_policy_samr_rid(struct samr_info *info)
537 {
538 if (!info) {
539 DEBUG(3,("Error getting policy\n"));
540 return 0xffffffff;
541 }
542
543 return info->sid.sub_auths[info->sid.num_auths-1];
544 }
545
546 /*******************************************************************
547 _samr_get_usrdom_pwinfo
548 ********************************************************************/
549
550 NTSTATUS _samr_get_usrdom_pwinfo(pipes_struct *p, SAMR_Q_GET_USRDOM_PWINFO *q_u, SAMR_R_GET_USRDOM_PWINFO *r_u)
551 {
552 struct samr_info *info = NULL;
553
554 r_u->status = NT_STATUS_OK;
555
556 /* find the policy handle. open a policy on it. */
557 if (!find_policy_by_hnd(p, &q_u->user_pol, (void **)&info)) {
558 return NT_STATUS_INVALID_HANDLE;
559 }
560
561 /* find the user's rid */
562 if (get_lsa_policy_samr_rid(info) == 0xffffffff) {
563 return NT_STATUS_OBJECT_TYPE_MISMATCH;
564 }
565
566 init_samr_r_get_usrdom_pwinfo(r_u, NT_STATUS_OK);
567
568 DEBUG(5,("_samr_get_usrdom_pwinfo: %d\n", __LINE__));
569
570 return r_u->status;
571 }
572
573 /*******************************************************************
574 samr_make_usr_obj_sd
575 ********************************************************************/
576
577 static NTSTATUS samr_make_usr_obj_sd(TALLOC_CTX *ctx, SEC_DESC_BUF **buf, DOM_SID *usr_sid)
578 {
579 extern DOM_SID global_sid_Builtin;
580 extern DOM_SID global_sid_World;
581 DOM_SID adm_sid;
582 DOM_SID act_sid;
583
584 SEC_ACE ace[4];
585 SEC_ACCESS mask;
586
587 SEC_ACL *psa = NULL;
588 SEC_DESC *psd = NULL;
589 size_t sd_size;
590
591 sid_copy(&adm_sid, &global_sid_Builtin);
592 sid_append_rid(&adm_sid, BUILTIN_ALIAS_RID_ADMINS);
593
594 sid_copy(&act_sid, &global_sid_Builtin);
595 sid_append_rid(&act_sid, BUILTIN_ALIAS_RID_ACCOUNT_OPS);
596
597 init_sec_access(&mask, 0x2035b);
598 init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
599
600 init_sec_access(&mask, 0xf07ff);
601 init_sec_ace(&ace[1], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
602 init_sec_ace(&ace[2], &act_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
603
604 init_sec_access(&mask,0x20044);
605 init_sec_ace(&ace[3], usr_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
606
607 if((psa = make_sec_acl(ctx, NT4_ACL_REVISION, 4, ace)) == NULL)
608 return NT_STATUS_NO_MEMORY;
609
610 if((psd = make_sec_desc(ctx, SEC_DESC_REVISION, NULL, NULL, NULL, psa, &sd_size)) == NULL)
611 return NT_STATUS_NO_MEMORY;
612
613 if((*buf = make_sec_desc_buf(ctx, sd_size, psd)) == NULL)
614 return NT_STATUS_NO_MEMORY;
615
616 return NT_STATUS_OK;
617 }
618
619 static BOOL get_lsa_policy_samr_sid(pipes_struct *p, POLICY_HND *pol, DOM_SID *sid)
620 {
621 struct samr_info *info = NULL;
622
623 /* find the policy handle. open a policy on it. */
624 if (!find_policy_by_hnd(p, pol, (void **)&info))
625 return False;
626
627 if (!info)
628 return False;
629
630 *sid = info->sid;
631 return True;
632 }
633
634 /*******************************************************************
635 _samr_query_sec_obj
636 ********************************************************************/
637
638 NTSTATUS _samr_query_sec_obj(pipes_struct *p, SAMR_Q_QUERY_SEC_OBJ *q_u, SAMR_R_QUERY_SEC_OBJ *r_u)
639 {
640 DOM_SID pol_sid;
641
642 r_u->status = NT_STATUS_OK;
643
644 /* Get the SID. */
645
646 if (!get_lsa_policy_samr_sid(p, &q_u->user_pol, &pol_sid))
647 return NT_STATUS_INVALID_HANDLE;
648
649 r_u->status = samr_make_usr_obj_sd(p->mem_ctx, &r_u->buf, &pol_sid);
650
651 if (NT_STATUS_IS_OK(r_u->status))
652 r_u->ptr = 1;
653
654 return r_u->status;
655 }
656
657 /*******************************************************************
658 makes a SAM_ENTRY / UNISTR2* structure from a user list.
659 ********************************************************************/
660
661 static void make_user_sam_entry_list(TALLOC_CTX *ctx, SAM_ENTRY **sam_pp, UNISTR2 **uni_name_pp,
662 uint32 num_sam_entries, SAM_USER_INFO_21 *pass)
663 {
664 uint32 i;
665 SAM_ENTRY *sam;
666 UNISTR2 *uni_name;
667
668 *sam_pp = NULL;
669 *uni_name_pp = NULL;
670
671 if (num_sam_entries == 0)
672 return;
673
674 sam = (SAM_ENTRY *)talloc_zero(ctx, sizeof(SAM_ENTRY)*num_sam_entries);
675
676 uni_name = (UNISTR2 *)talloc_zero(ctx, sizeof(UNISTR2)*num_sam_entries);
677
678 if (sam == NULL || uni_name == NULL) {
679 DEBUG(0, ("NULL pointers in SAMR_R_QUERY_DISPINFO\n"));
680 return;
681 }
682
683 for (i = 0; i < num_sam_entries; i++) {
684 int len = pass[i].uni_user_name.uni_str_len;
685
686 init_sam_entry(&sam[i], len, pass[i].user_rid);
687 copy_unistr2(&uni_name[i], &pass[i].uni_user_name);
688 }
689
690 *sam_pp = sam;
691 *uni_name_pp = uni_name;
692 }
693
694 /*******************************************************************
695 samr_reply_enum_dom_users
696 ********************************************************************/
697
698 NTSTATUS _samr_enum_dom_users(pipes_struct *p, SAMR_Q_ENUM_DOM_USERS *q_u, SAMR_R_ENUM_DOM_USERS *r_u)
699 {
700 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES];
701 int num_entries = 0;
702 int total_entries = 0;
703
704 r_u->status = NT_STATUS_OK;
705
706 /* find the policy handle. open a policy on it. */
707 if (!find_policy_by_hnd(p, &q_u->pol, NULL))
708 return NT_STATUS_INVALID_HANDLE;
709
710 DEBUG(5,("_samr_enum_dom_users: %d\n", __LINE__));
711
712 become_root();
713 r_u->status = get_sampwd_entries(pass, q_u->start_idx, &total_entries, &num_entries,
714 MAX_SAM_ENTRIES, q_u->acb_mask);
715 unbecome_root();
716
717 if (NT_STATUS_IS_ERR(r_u->status))
718 return r_u->status;
719
720 samr_clear_passwd_fields(pass, num_entries);
721
722 /*
723 * Note from JRA. total_entries is not being used here. Currently if there is a
724 * large user base then it looks like NT will enumerate until get_sampwd_entries
725 * returns False due to num_entries being zero. This will cause an access denied
726 * return. I don't think this is right and needs further investigation. Note that
727 * this is also the same in the TNG code (I don't think that has been tested with
728 * a very large user list as MAX_SAM_ENTRIES is set to 600).
729 *
730 * I also think that one of the 'num_entries' return parameters is probably
731 * the "max entries" parameter - but in the TNG code they're all currently set to the same
732 * value (again I think this is wrong).
733 */
734
735 make_user_sam_entry_list(p->mem_ctx, &r_u->sam, &r_u->uni_acct_name, num_entries, pass);
736
737 init_samr_r_enum_dom_users(r_u, q_u->start_idx + num_entries, num_entries);
738
739 DEBUG(5,("_samr_enum_dom_users: %d\n", __LINE__));
740
741 return r_u->status;
742 }
743
744 /*******************************************************************
745 makes a SAM_ENTRY / UNISTR2* structure from a group list.
746 ********************************************************************/
747
748 static void make_group_sam_entry_list(TALLOC_CTX *ctx, SAM_ENTRY **sam_pp, UNISTR2 **uni_name_pp,
749 uint32 num_sam_entries, DOMAIN_GRP *grp)
750 {
751 uint32 i;
752 SAM_ENTRY *sam;
753 UNISTR2 *uni_name;
754
755 *sam_pp = NULL;
756 *uni_name_pp = NULL;
757
758 if (num_sam_entries == 0)
759 return;
760
761 sam = (SAM_ENTRY *)talloc_zero(ctx, sizeof(SAM_ENTRY)*num_sam_entries);
762
763 uni_name = (UNISTR2 *)talloc_zero(ctx, sizeof(UNISTR2)*num_sam_entries);
764
765 if (sam == NULL || uni_name == NULL) {
766 DEBUG(0, ("NULL pointers in SAMR_R_QUERY_DISPINFO\n"));
767 return;
768 }
769
770 for (i = 0; i < num_sam_entries; i++) {
771 /*
772 * JRA. I think this should include the null. TNG does not.
773 */
774 int len = strlen(grp[i].name)+1;
775
776 init_sam_entry(&sam[i], len, grp[i].rid);
777 init_unistr2(&uni_name[i], grp[i].name, len);
778 }
779
780 *sam_pp = sam;
781 *uni_name_pp = uni_name;
782 }
783
784 /*******************************************************************
785 Get the group entries - similar to get_sampwd_entries().
786 ********************************************************************/
787
788 static NTSTATUS get_group_alias_entries(DOMAIN_GRP *d_grp, DOM_SID *sid, uint32 start_idx,
789 uint32 *p_num_entries, uint32 max_entries)
790 {
791 fstring sid_str;
792 fstring sam_sid_str;
793 uint32 num_entries = 0;
794
795 sid_to_string(sid_str, sid);
796 sid_to_string(sam_sid_str, &global_sam_sid);
797
798 *p_num_entries = 0;
799
800 /* well-known aliases */
801 if (strequal(sid_str, "S-1-5-32")) {
802 char *alias_name;
803 while (!lp_hide_local_users() &&
804 num_entries < max_entries &&
805 ((alias_name = builtin_alias_rids[num_entries].name) != NULL)) {
806
807 fstrcpy(d_grp[num_entries].name, alias_name);
808 d_grp[num_entries].rid = builtin_alias_rids[num_entries].rid;
809
810 num_entries++;
811 }
812 } else if (strequal(sid_str, sam_sid_str) && !lp_hide_local_users()) {
813 fstring name;
814 char *sep;
815 struct sys_grent *glist;
816 struct sys_grent *grp;
817
818 sep = lp_winbind_separator();
819
820 /* local aliases */
821 /* we return the UNIX groups here. This seems to be the right */
822 /* thing to do, since NT member servers return their local */
823 /* groups in the same situation. */
824
825 /* use getgrent_list() to retrieve the list of groups to avoid
826 * problems with getgrent possible infinite loop by internal
827 * libc grent structures overwrites by called functions */
828 grp = glist = getgrent_list();
829 if (grp == NULL)
830 return NT_STATUS_NO_MEMORY;
831
832 for (;(num_entries < max_entries) && (grp != NULL); grp = grp->next) {
833 int i;
834 uint32 trid;
835
836 fstrcpy(name,grp->gr_name);
837 DEBUG(10,("get_group_alias_entries: got group %s\n", name ));
838
839 /* Don't return winbind groups as they are not local! */
840
841 if (strchr(name, *sep) != NULL) {
842 DEBUG(10,("get_group_alias_entries: not returing %s, not local.\n", name ));
843 continue;
844 }
845
846 /* Don't return user private groups... */
847 if (Get_Pwnam(name, False) != 0) {
848 DEBUG(10,("get_group_alias_entries: not returing %s, clashes with user.\n", name ));
849 continue;
850 }
851
852 trid = pdb_gid_to_group_rid(grp->gr_gid);
853 for( i = 0; i < num_entries; i++)
854 if ( d_grp[i].rid == trid )
855 break;
856
857 if ( i < num_entries )
858 continue; /* rid was there, dup! */
859
860 /* JRA - added this for large group db enumeration... */
861
862 if (start_idx > 0) {
863 /* skip the requested number of entries.
864 not very efficient, but hey...
865 */
866 start_idx--;
867 continue;
868 }
869
870 fstrcpy(d_grp[num_entries].name, name);
871 d_grp[num_entries].rid = trid;
872 num_entries++;
873 }
874
875 grent_free(glist);
876 }
877
878 *p_num_entries = num_entries;
879
880 if (num_entries >= max_entries)
881 return STATUS_MORE_ENTRIES;
882 return NT_STATUS_OK;
883 }
884
885 /*******************************************************************
886 Get the group entries - similar to get_sampwd_entries().
887 ********************************************************************/
888
889 static NTSTATUS get_group_domain_entries(DOMAIN_GRP *d_grp, DOM_SID *sid, uint32 start_idx,
890 uint32 *p_num_entries, uint32 max_entries)
891 {
892 fstring sid_str;
893 fstring sam_sid_str;
894 uint32 num_entries = 0;
895 fstring name="Domain Admins";
896 fstring comment="Just to make it work !";
897
898 sid_to_string(sid_str, sid);
899 sid_to_string(sam_sid_str, &global_sam_sid);
900
901 *p_num_entries = 0;
902
903 fstrcpy(d_grp[0].name, name);
904 fstrcpy(d_grp[0].comment, comment);
905 d_grp[0].rid = DOMAIN_GROUP_RID_ADMINS;
906 d_grp[0].attr=SID_NAME_DOM_GRP;
907
908 fstrcpy(d_grp[1].name, "Domain Users");
909 fstrcpy(d_grp[1].comment, "Just to make it work !");
910 d_grp[1].rid = DOMAIN_GROUP_RID_USERS;
911 d_grp[1].attr=SID_NAME_DOM_GRP;
912
913 num_entries = 2;
914
915 *p_num_entries = num_entries;
916
917 return NT_STATUS_OK;
918 }
919
920 /*******************************************************************
921 samr_reply_enum_dom_groups
922 Only reply with one group - domain admins. This must be fixed for
923 a real PDC. JRA.
924 ********************************************************************/
925
926 NTSTATUS _samr_enum_dom_groups(pipes_struct *p, SAMR_Q_ENUM_DOM_GROUPS *q_u, SAMR_R_ENUM_DOM_GROUPS *r_u)
927 {
928 DOMAIN_GRP grp[2];
929 uint32 num_entries;
930 DOM_SID sid;
931
932 r_u->status = NT_STATUS_OK;
933
934 if (!get_lsa_policy_samr_sid(p, &q_u->pol, &sid))
935 return NT_STATUS_INVALID_HANDLE;
936
937 DEBUG(5,("samr_reply_enum_dom_groups: %d\n", __LINE__));
938
939 get_group_domain_entries(grp, &sid, q_u->start_idx, &num_entries, MAX_SAM_ENTRIES);
940
941 make_group_sam_entry_list(p->mem_ctx, &r_u->sam, &r_u->uni_grp_name, num_entries, grp);
942
943 init_samr_r_enum_dom_groups(r_u, q_u->start_idx, num_entries);
944
945 DEBUG(5,("samr_enum_dom_groups: %d\n", __LINE__));
946
947 return r_u->status;
948 }
949
950
951 /*******************************************************************
952 samr_reply_enum_dom_aliases
953 ********************************************************************/
954
955 NTSTATUS _samr_enum_dom_aliases(pipes_struct *p, SAMR_Q_ENUM_DOM_ALIASES *q_u, SAMR_R_ENUM_DOM_ALIASES *r_u)
956 {
957 DOMAIN_GRP grp[MAX_SAM_ENTRIES];
958 uint32 num_entries = 0;
959 fstring sid_str;
960 DOM_SID sid;
961
962 r_u->status = NT_STATUS_OK;
963
964 if (!get_lsa_policy_samr_sid(p, &q_u->pol, &sid))
965 return NT_STATUS_INVALID_HANDLE;
966
967 sid_to_string(sid_str, &sid);
968 DEBUG(5,("samr_reply_enum_dom_aliases: sid %s\n", sid_str));
969
970 r_u->status = get_group_alias_entries(grp, &sid, q_u->start_idx,
971 &num_entries, MAX_SAM_ENTRIES);
972 if (NT_STATUS_IS_ERR(r_u->status))
973 return r_u->status;
974
975 make_group_sam_entry_list(p->mem_ctx, &r_u->sam, &r_u->uni_grp_name, num_entries, grp);
976
977 init_samr_r_enum_dom_aliases(r_u, q_u->start_idx + num_entries, num_entries);
978
979 DEBUG(5,("samr_enum_dom_aliases: %d\n", __LINE__));
980
981 return r_u->status;
982 }
983
984 /*******************************************************************
985 samr_reply_query_dispinfo
986 ********************************************************************/
987
988 NTSTATUS _samr_query_dispinfo(pipes_struct *p, SAMR_Q_QUERY_DISPINFO *q_u, SAMR_R_QUERY_DISPINFO *r_u)
989 {
990 SAM_USER_INFO_21 pass[MAX_SAM_ENTRIES];
991 DOMAIN_GRP grps[MAX_SAM_ENTRIES];
992 uint16 acb_mask = ACB_NORMAL;
993 uint32 num_entries = 0;
994 int orig_num_entries = 0;
995 int total_entries = 0;
996 uint32 data_size = 0;
997 DOM_SID sid;
998 NTSTATUS disp_ret;
999 SAM_DISPINFO_CTR *ctr;
1000
1001 DEBUG(5, ("samr_reply_query_dispinfo: %d\n", __LINE__));
1002
1003 r_u->status = NT_STATUS_OK;
1004
1005 if (!get_lsa_policy_samr_sid(p, &q_u->domain_pol, &sid))
1006 return NT_STATUS_INVALID_HANDLE;
1007
1008 /* decide how many entries to get depending on the max_entries
1009 and max_size passed by client */
1010
1011 if(q_u->max_entries > MAX_SAM_ENTRIES)
1012 q_u->max_entries = MAX_SAM_ENTRIES;
1013
1014 /* Get what we need from the password database */
1015 switch (q_u->switch_level) {
1016 case 0x2:
1017 acb_mask = ACB_WSTRUST;
1018 /* Fall through */
1019 case 0x1:
1020 case 0x4:
1021 become_root();
1022 #if 0
1023 r_u->status = get_passwd_entries(pass, q_u->start_idx, &total_entries, &num_entries,
1024 MAX_SAM_ENTRIES, acb_mask);
1025 #endif
1026 #if 0
1027 /*
1028 * Which should we use here ? JRA.
1029 */
1030 r_u->status = get_sampwd_entries(pass, q_u->start_idx, &total_entries, &num_entries,
1031 MAX_SAM_ENTRIES, acb_mask);
1032 #endif
1033 #if 1
1034 r_u->status = jf_get_sampwd_entries(pass, q_u->start_idx, &total_entries, &num_entries,
1035 MAX_SAM_ENTRIES, acb_mask);
1036 #endif
1037 unbecome_root();
1038 if (NT_STATUS_IS_ERR(r_u->status)) {
1039 DEBUG(5, ("get_sampwd_entries: failed\n"));
1040 return r_u->status;
1041 }
1042 break;
1043 case 0x3:
1044 case 0x5:
1045 r_u->status = get_group_domain_entries(grps, &sid, q_u->start_idx, &num_entries, MAX_SAM_ENTRIES);
1046 break;
1047 default:
1048 DEBUG(0,("_samr_query_dispinfo: Unknown info level (%u)\n", (unsigned int)q_u->switch_level ));
1049 return NT_STATUS_INVALID_INFO_CLASS;
1050 }
1051
1052 orig_num_entries = num_entries;
1053
1054 if (num_entries > q_u->max_entries)
1055 num_entries = q_u->max_entries;
1056
1057 if (num_entries > MAX_SAM_ENTRIES) {
1058 num_entries = MAX_SAM_ENTRIES;
1059 DEBUG(5, ("limiting number of entries to %d\n", num_entries));
1060 }
1061
1062 /* Ensure password info is never given out here. PARANOIA... JRA */
1063 samr_clear_passwd_fields(pass, num_entries);
1064
1065 data_size = q_u->max_size;
1066
1067 if (!(ctr = (SAM_DISPINFO_CTR *)talloc_zero(p->mem_ctx,sizeof(SAM_DISPINFO_CTR))))
1068 return NT_STATUS_NO_MEMORY;
1069
1070 ZERO_STRUCTP(ctr);
1071
1072 /* Now create reply structure */
1073 switch (q_u->switch_level) {
1074 case 0x1:
1075 if (num_entries) {
1076 if (!(ctr->sam.info1 = (SAM_DISPINFO_1 *)talloc_zero(p->mem_ctx,num_entries*sizeof(SAM_DISPINFO_1))))
1077 return NT_STATUS_NO_MEMORY;
1078 }
1079 disp_ret = init_sam_dispinfo_1(p->mem_ctx,ctr->sam.info1, &num_entries, &data_size, q_u->start_idx, pass);
1080 if (NT_STATUS_IS_ERR(disp_ret))
1081 return disp_ret;
1082 break;
1083 case 0x2:
1084 if (num_entries) {
1085 if (!(ctr->sam.info2 = (SAM_DISPINFO_2 *)talloc_zero(p->mem_ctx,num_entries*sizeof(SAM_DISPINFO_2))))
1086 return NT_STATUS_NO_MEMORY;
1087 }
1088 disp_ret = init_sam_dispinfo_2(p->mem_ctx,ctr->sam.info2, &num_entries, &data_size, q_u->start_idx, pass);
1089 if (NT_STATUS_IS_ERR(disp_ret))
1090 return disp_ret;
1091 break;
1092 case 0x3:
1093 if (num_entries) {
1094 if (!(ctr->sam.info3 = (SAM_DISPINFO_3 *)talloc_zero(p->mem_ctx,num_entries*sizeof(SAM_DISPINFO_3))))
1095 return NT_STATUS_NO_MEMORY;
1096 }
1097 disp_ret = init_sam_dispinfo_3(p->mem_ctx,ctr->sam.info3, &num_entries, &data_size, q_u->start_idx, grps);
1098 if (NT_STATUS_IS_ERR(disp_ret))
1099 return disp_ret;
1100 break;
1101 case 0x4:
1102 if (num_entries) {
1103 if (!(ctr->sam.info4 = (SAM_DISPINFO_4 *)talloc_zero(p->mem_ctx,num_entries*sizeof(SAM_DISPINFO_4))))
1104 return NT_STATUS_NO_MEMORY;
1105 }
1106 disp_ret = init_sam_dispinfo_4(p->mem_ctx,ctr->sam.info4, &num_entries, &data_size, q_u->start_idx, pass);
1107 if (NT_STATUS_IS_ERR(disp_ret))
1108 return disp_ret;
1109 break;
1110 case 0x5:
1111 if (num_entries) {
1112 if (!(ctr->sam.info5 = (SAM_DISPINFO_5 *)talloc_zero(p->mem_ctx,num_entries*sizeof(SAM_DISPINFO_5))))
1113 return NT_STATUS_NO_MEMORY;
1114 }
1115 disp_ret = init_sam_dispinfo_5(p->mem_ctx,ctr->sam.info5, &num_entries, &data_size, q_u->start_idx, grps);
1116 if (NT_STATUS_IS_ERR(disp_ret))
1117 return disp_ret;
1118 break;
1119 default:
1120 ctr->sam.info = NULL;
1121 return NT_STATUS_INVALID_INFO_CLASS;
1122 }
1123
1124 DEBUG(5, ("_samr_query_dispinfo: %d\n", __LINE__));
1125
1126 if (num_entries < orig_num_entries)
1127 return STATUS_MORE_ENTRIES;
1128
1129 init_samr_r_query_dispinfo(r_u, num_entries, data_size, q_u->switch_level, ctr, r_u->status);
1130
1131 return r_u->status;
1132 }
1133
1134 /*******************************************************************
1135 samr_reply_query_aliasinfo
1136 ********************************************************************/
1137
1138 NTSTATUS _samr_query_aliasinfo(pipes_struct *p, SAMR_Q_QUERY_ALIASINFO *q_u, SAMR_R_QUERY_ALIASINFO *r_u)
1139 {
1140 fstring alias_desc = "Local Unix group";
1141 fstring alias="";
1142 enum SID_NAME_USE type;
1143 uint32 alias_rid;
1144 struct samr_info *info = NULL;
1145
1146 r_u->status = NT_STATUS_OK;
1147
1148 DEBUG(5,("_samr_query_aliasinfo: %d\n", __LINE__));
1149
1150 /* find the policy handle. open a policy on it. */
1151 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
1152 return NT_STATUS_INVALID_HANDLE;
1153
1154 alias_rid = get_lsa_policy_samr_rid(info);
1155 if(alias_rid == 0xffffffff)
1156 return NT_STATUS_NO_SUCH_ALIAS;
1157
1158 if(!local_lookup_rid(alias_rid, alias, &type))
1159 return NT_STATUS_NO_SUCH_ALIAS;
1160
1161 switch (q_u->switch_level) {
1162 case 3:
1163 r_u->ptr = 1;
1164 r_u->ctr.switch_value1 = 3;
1165 init_samr_alias_info3(&r_u->ctr.alias.info3, alias_desc);
1166 break;
1167 default:
1168 return NT_STATUS_INVALID_INFO_CLASS;
1169 }
1170
1171 DEBUG(5,("_samr_query_aliasinfo: %d\n", __LINE__));
1172
1173 return r_u->status;
1174 }
1175
1176 #if 0
1177 /*******************************************************************
1178 samr_reply_lookup_ids
1179 ********************************************************************/
1180
1181 uint32 _samr_lookup_ids(pipes_struct *p, SAMR_Q_LOOKUP_IDS *q_u, SAMR_R_LOOKUP_IDS *r_u)
1182 {
1183 uint32 rid[MAX_SAM_ENTRIES];
1184 int num_rids = q_u->num_sids1;
1185
1186 r_u->status = NT_STATUS_OK;
1187
1188 DEBUG(5,("_samr_lookup_ids: %d\n", __LINE__));
1189
1190 if (num_rids > MAX_SAM_ENTRIES) {
1191 num_rids = MAX_SAM_ENTRIES;
1192 DEBUG(5,("_samr_lookup_ids: truncating entries to %d\n", num_rids));
1193 }
1194
1195 #if 0
1196 int i;
1197 SMB_ASSERT_ARRAY(q_u->uni_user_name, num_rids);
1198
1199 for (i = 0; i < num_rids && status == 0; i++)
1200 {
1201 struct sam_passwd *sam_pass;
1202 fstring user_name;
1203
1204
1205 fstrcpy(user_name, unistrn2(q_u->uni_user_name[i].buffer,
1206 q_u->uni_user_name[i].uni_str_len));
1207
1208 /* find the user account */
1209 become_root();
1210 sam_pass = get_smb21pwd_entry(user_name, 0);
1211 unbecome_root();
1212
1213 if (sam_pass == NULL)
1214 {
1215 status = 0xC0000000 | NT_STATUS_NO_SUCH_USER;
1216 rid[i] = 0;
1217 }
1218 else
1219 {
1220 rid[i] = sam_pass->user_rid;
1221 }
1222 }
1223 #endif
1224
1225 num_rids = 1;
1226 rid[0] = BUILTIN_ALIAS_RID_USERS;
1227
1228 init_samr_r_lookup_ids(&r_u, num_rids, rid, NT_STATUS_OK);
1229
1230 DEBUG(5,("_samr_lookup_ids: %d\n", __LINE__));
1231
1232 return r_u->status;
1233 }
1234 #endif
1235
1236 /*******************************************************************
1237 _samr_lookup_names
1238 ********************************************************************/
1239
1240 NTSTATUS _samr_lookup_names(pipes_struct *p, SAMR_Q_LOOKUP_NAMES *q_u, SAMR_R_LOOKUP_NAMES *r_u)
1241 {
1242 uint32 rid[MAX_SAM_ENTRIES];
1243 uint32 local_rid;
1244 enum SID_NAME_USE type[MAX_SAM_ENTRIES];
1245 enum SID_NAME_USE local_type;
1246 int i;
1247 int num_rids = q_u->num_names2;
1248 DOM_SID pol_sid;
1249 fstring sid_str;
1250
1251 r_u->status = NT_STATUS_OK;
1252
1253 DEBUG(5,("_samr_lookup_names: %d\n", __LINE__));
1254
1255 ZERO_ARRAY(rid);
1256 ZERO_ARRAY(type);
1257
1258 if (!get_lsa_policy_samr_sid(p, &q_u->pol, &pol_sid)) {
1259 init_samr_r_lookup_names(p->mem_ctx, r_u, 0, NULL, NULL, NT_STATUS_OBJECT_TYPE_MISMATCH);
1260 return r_u->status;
1261 }
1262
1263 if (num_rids > MAX_SAM_ENTRIES) {
1264 num_rids = MAX_SAM_ENTRIES;
1265 DEBUG(5,("_samr_lookup_names: truncating entries to %d\n", num_rids));
1266 }
1267
1268 DEBUG(5,("_samr_lookup_names: looking name on SID %s\n", sid_to_string(sid_str, &pol_sid)));
1269
1270 for (i = 0; i < num_rids; i++) {
1271 fstring name;
1272 DOM_SID sid;
1273
1274 r_u->status = NT_STATUS_NONE_MAPPED;
1275
1276 rid [i] = 0xffffffff;
1277 type[i] = SID_NAME_UNKNOWN;
1278
1279 fstrcpy(name, dos_unistrn2(q_u->uni_name[i].buffer, q_u->uni_name[i].uni_str_len));
1280
1281 /*
1282 * we are only looking for a name
1283 * the SID we get back can be outside
1284 * the scope of the pol_sid
1285 *
1286 * in clear: it prevents to reply to domain\group: yes
1287 * when only builtin\group exists.
1288 *
1289 * a cleaner code is to add the sid of the domain we're looking in
1290 * to the local_lookup_name function.
1291 */
1292
1293 if(local_lookup_name(global_myname, name, &sid, &local_type)) {
1294 sid_split_rid(&sid, &local_rid);
1295
1296 if (sid_equal(&sid, &pol_sid)) {
1297 rid[i]=local_rid;
1298 type[i]=local_type;
1299 r_u->status = NT_STATUS_OK;
1300 }
1301 }
1302 }
1303
1304 init_samr_r_lookup_names(p->mem_ctx, r_u, num_rids, rid, (uint32 *)type, r_u->status);
1305
1306 DEBUG(5,("_samr_lookup_names: %d\n", __LINE__));
1307
1308 return r_u->status;
1309 }
1310
1311 /*******************************************************************
1312 _samr_chgpasswd_user
1313 ********************************************************************/
1314
1315 NTSTATUS _samr_chgpasswd_user(pipes_struct *p, SAMR_Q_CHGPASSWD_USER *q_u, SAMR_R_CHGPASSWD_USER *r_u)
1316 {
1317 fstring user_name;
1318 fstring wks;
1319
1320 DEBUG(5,("_samr_chgpasswd_user: %d\n", __LINE__));
1321
1322 r_u->status = NT_STATUS_OK;
1323
1324 fstrcpy(user_name, dos_unistrn2(q_u->uni_user_name.buffer, q_u->uni_user_name.uni_str_len));
1325 fstrcpy(wks , dos_unistrn2(q_u->uni_dest_host.buffer, q_u->uni_dest_host.uni_str_len));
1326
1327 DEBUG(5,("samr_chgpasswd_user: user: %s wks: %s\n", user_name, wks));
1328
1329 /*
1330 * Pass the user through the NT -> unix user mapping
1331 * function.
1332 */
1333
1334 (void)map_username(user_name);
1335
1336 /*
1337 * Do any UNIX username case mangling.
1338 */
1339 (void)Get_Pwnam( user_name, True);
1340
1341 if (!pass_oem_change(user_name, q_u->lm_newpass.pass, q_u->lm_oldhash.hash,
1342 q_u->nt_newpass.pass, q_u->nt_oldhash.hash))
1343 r_u->status = NT_STATUS_WRONG_PASSWORD;
1344
1345 init_samr_r_chgpasswd_user(r_u, r_u->status);
1346
1347 DEBUG(5,("_samr_chgpasswd_user: %d\n", __LINE__));
1348
1349 return r_u->status;
1350 }
1351
1352 /*******************************************************************
1353 makes a SAMR_R_LOOKUP_RIDS structure.
1354 ********************************************************************/
1355
1356 static BOOL make_samr_lookup_rids(TALLOC_CTX *ctx, uint32 num_names, fstring names[],
1357 UNIHDR **pp_hdr_name, UNISTR2 **pp_uni_name)
1358 {
1359 uint32 i;
1360 UNIHDR *hdr_name = NULL;
1361 UNISTR2 *uni_name = NULL;
1362
1363 *pp_uni_name = NULL;
1364 *pp_hdr_name = NULL;
1365
1366 if (num_names != 0) {
1367 hdr_name = (UNIHDR *)talloc_zero(ctx, sizeof(UNIHDR)*num_names);
1368 if (hdr_name == NULL)
1369 return False;
1370
1371 uni_name = (UNISTR2 *)talloc_zero(ctx,sizeof(UNISTR2)*num_names);
1372 if (uni_name == NULL)
1373 return False;
1374 }
1375
1376 for (i = 0; i < num_names; i++) {
1377 int len = names[i] != NULL ? strlen(names[i]) : 0;
1378 DEBUG(10, ("names[%d]:%s\n", i, names[i]));
1379 init_uni_hdr(&hdr_name[i], len);
1380 init_unistr2(&uni_name[i], names[i], len);
1381 }
1382
1383 *pp_uni_name = uni_name;
1384 *pp_hdr_name = hdr_name;
1385
1386 return True;
1387 }
1388
1389 /*******************************************************************
1390 _samr_lookup_rids
1391 ********************************************************************/
1392
1393 NTSTATUS _samr_lookup_rids(pipes_struct *p, SAMR_Q_LOOKUP_RIDS *q_u, SAMR_R_LOOKUP_RIDS *r_u)
1394 {
1395 fstring group_names[MAX_SAM_ENTRIES];
1396 uint32 *group_attrs = NULL;
1397 UNIHDR *hdr_name = NULL;
1398 UNISTR2 *uni_name = NULL;
1399 DOM_SID pol_sid;
1400 int num_rids = q_u->num_rids1;
1401 int i;
1402
1403 r_u->status = NT_STATUS_OK;
1404
1405 DEBUG(5,("_samr_lookup_rids: %d\n", __LINE__));
1406
1407 /* find the policy handle. open a policy on it. */
1408 if (!get_lsa_policy_samr_sid(p, &q_u->pol, &pol_sid))
1409 return NT_STATUS_INVALID_HANDLE;
1410
1411 if (num_rids > MAX_SAM_ENTRIES) {
1412 num_rids = MAX_SAM_ENTRIES;
1413 DEBUG(5,("_samr_lookup_rids: truncating entries to %d\n", num_rids));
1414 }
1415
1416 if (num_rids) {
1417 if ((group_attrs = (uint32 *)talloc_zero(p->mem_ctx, num_rids * sizeof(uint32))) == NULL)
1418 return NT_STATUS_NO_MEMORY;
1419 }
1420
1421 r_u->status = NT_STATUS_NONE_MAPPED;
1422
1423 for (i = 0; i < num_rids; i++) {
1424 fstring tmpname;
1425 fstring domname;
1426 DOM_SID sid;
1427 enum SID_NAME_USE type;
1428
1429 group_attrs[i] = SID_NAME_UNKNOWN;
1430 *group_names[i] = '\0';
1431
1432 if (sid_equal(&pol_sid, &global_sam_sid)) {
1433 sid_copy(&sid, &pol_sid);
1434 sid_append_rid(&sid, q_u->rid[i]);
1435
1436 if (lookup_sid(&sid, domname, tmpname, &type)) {
1437 r_u->status = NT_STATUS_OK;
1438 group_attrs[i] = (uint32)type;
1439 fstrcpy(group_names[i],tmpname);
1440 }
1441 }
1442 }
1443
1444 if(!make_samr_lookup_rids(p->mem_ctx, num_rids, group_names, &hdr_name, &uni_name))
1445 return NT_STATUS_NO_MEMORY;
1446
1447 init_samr_r_lookup_rids(r_u, num_rids, hdr_name, uni_name, group_attrs);
1448
1449 DEBUG(5,("_samr_lookup_rids: %d\n", __LINE__));
1450
1451 return r_u->status;
1452 }
1453
1454 /*******************************************************************
1455 _api_samr_open_user. Safe - gives out no passwd info.
1456 ********************************************************************/
1457
1458 NTSTATUS _api_samr_open_user(pipes_struct *p, SAMR_Q_OPEN_USER *q_u, SAMR_R_OPEN_USER *r_u)
1459 {
1460 SAM_ACCOUNT *sampass=NULL;
1461 DOM_SID sid;
1462 POLICY_HND domain_pol = q_u->domain_pol;
1463 uint32 user_rid = q_u->user_rid;
1464 POLICY_HND *user_pol = &r_u->user_pol;
1465 struct samr_info *info = NULL;
1466 BOOL ret;
1467
1468 r_u->status = NT_STATUS_OK;
1469
1470 /* find the domain policy handle. */
1471 if (!find_policy_by_hnd(p, &domain_pol, NULL))
1472 return NT_STATUS_INVALID_HANDLE;
1473
1474 pdb_init_sam(&sampass);
1475
1476 become_root();
1477 ret=pdb_getsampwrid(sampass, user_rid);
1478 unbecome_root();
1479
1480 /* check that the RID exists in our domain. */
1481 if (ret == False) {
1482 pdb_free_sam(sampass);
1483 return NT_STATUS_NO_SUCH_USER;
1484 }
1485
1486 samr_clear_sam_passwd(sampass);
1487 pdb_free_sam(sampass);
1488
1489 /* Get the domain SID stored in the domain policy */
1490 if(!get_lsa_policy_samr_sid(p, &domain_pol, &sid))
1491 return NT_STATUS_INVALID_HANDLE;
1492
1493 /* append the user's RID to it */
1494 if(!sid_append_rid(&sid, user_rid))
1495 return NT_STATUS_NO_SUCH_USER;
1496
1497 /* associate the user's SID with the new handle. */
1498 if ((info = (struct samr_info *)malloc(sizeof(struct samr_info))) == NULL)
1499 return NT_STATUS_NO_MEMORY;
1500
1501 ZERO_STRUCTP(info);
1502 info->sid = sid;
1503
1504 /* get a (unique) handle. open a policy on it. */
1505 if (!create_policy_hnd(p, user_pol, free_samr_info, (void *)info))
1506 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1507
1508 return r_u->status;
1509 }
1510
1511 /*************************************************************************
1512 get_user_info_10. Safe. Only gives out acb bits.
1513 *************************************************************************/
1514
1515 static BOOL get_user_info_10(SAM_USER_INFO_10 *id10, uint32 user_rid)
1516 {
1517 SAM_ACCOUNT *smbpass=NULL;
1518 BOOL ret;
1519
1520 if (!pdb_rid_is_user(user_rid)) {
1521 DEBUG(4,("RID 0x%x is not a user RID\n", user_rid));
1522 return False;
1523 }
1524
1525 pdb_init_sam(&smbpass);
1526
1527 become_root();
1528 ret = pdb_getsampwrid(smbpass, user_rid);
1529 unbecome_root();
1530
1531 if (ret==False) {
1532 DEBUG(4,("User 0x%x not found\n", user_rid));
1533 pdb_free_sam(smbpass);
1534 return False;
1535 }
1536
1537 DEBUG(3,("User:[%s]\n", pdb_get_username(smbpass) ));
1538
1539 ZERO_STRUCTP(id10);
1540 init_sam_user_info10(id10, pdb_get_acct_ctrl(smbpass) );
1541
1542 samr_clear_sam_passwd(smbpass);
1543 pdb_free_sam(smbpass);
1544
1545 return True;
1546 }
1547
1548 /*************************************************************************
1549 get_user_info_12. OK - this is the killer as it gives out password info.
1550 Ensure that this is only allowed on an encrypted connection with a root
1551 user. JRA.
1552 *************************************************************************/
1553
1554 static NTSTATUS get_user_info_12(pipes_struct *p, SAM_USER_INFO_12 * id12, uint32 user_rid)
1555 {
1556 SAM_ACCOUNT *smbpass=NULL;
1557 BOOL ret;
1558
1559 if (!p->ntlmssp_auth_validated)
1560 return NT_STATUS_ACCESS_DENIED;
1561
1562 if (!(p->ntlmssp_chal_flags & NTLMSSP_NEGOTIATE_SIGN) || !(p->ntlmssp_chal_flags & NTLMSSP_NEGOTIATE_SEAL))
1563 return NT_STATUS_ACCESS_DENIED;
1564
1565 /*
1566 * Do *NOT* do become_root()/unbecome_root() here ! JRA.
1567 */
1568 pdb_init_sam(&smbpass);
1569
1570 ret = pdb_getsampwrid(smbpass, user_rid);
1571
1572 if (ret == False) {
1573 DEBUG(4, ("User 0x%x not found\n", user_rid));
1574 pdb_free_sam(smbpass);
1575 return (geteuid() == (uid_t)0) ? NT_STATUS_NO_SUCH_USER : NT_STATUS_ACCESS_DENIED;
1576 }
1577
1578 DEBUG(3,("User:[%s] 0x%x\n", pdb_get_username(smbpass), pdb_get_acct_ctrl(smbpass) ));
1579
1580 if ( pdb_get_acct_ctrl(smbpass) & ACB_DISABLED) {
1581 pdb_free_sam(smbpass);
1582 return NT_STATUS_ACCOUNT_DISABLED;
1583 }
1584
1585 ZERO_STRUCTP(id12);
1586 init_sam_user_info12(id12, pdb_get_lanman_passwd(smbpass), pdb_get_nt_passwd(smbpass));
1587
1588 pdb_free_sam(smbpass);
1589
1590 return NT_STATUS_OK;
1591 }
1592
1593 #if 1 /* JRA - re-enabled... JERRY - why was this removed ? */
1594 /*************************************************************************
1595 get_user_info_20
1596 *************************************************************************/
1597
1598 static BOOL get_user_info_20(SAM_USER_INFO_20 *id20, uint32 user_rid)
1599 {
1600 SAM_ACCOUNT *sampass=NULL;
1601 BOOL ret;
1602
1603 if (!pdb_rid_is_user(user_rid)) {
1604 DEBUG(4,("RID 0x%x is not a user RID\n", user_rid));
1605 return False;
1606 }
1607
1608 pdb_init_sam(&sampass);
1609
1610 become_root();
1611 ret = pdb_getsampwrid(sampass, user_rid);
1612 unbecome_root();
1613
1614 if (ret == False) {
1615 DEBUG(4,("User 0x%x not found\n", user_rid));
1616 pdb_free_sam(sampass);
1617 return False;
1618 }
1619
1620 samr_clear_sam_passwd(sampass);
1621
1622 DEBUG(3,("User:[%s]\n", pdb_get_username(sampass) ));
1623
1624 ZERO_STRUCTP(id20);
1625 init_sam_user_info20A(id20, sampass);
1626
1627 pdb_free_sam(sampass);
1628
1629 return True;
1630 }
1631 #endif
1632
1633 /*************************************************************************
1634 get_user_info_21
1635 *************************************************************************/
1636
1637 static BOOL get_user_info_21(SAM_USER_INFO_21 *id21, uint32 user_rid)
1638 {
1639 SAM_ACCOUNT *sampass=NULL;
1640 BOOL ret;
1641
1642 if (!pdb_rid_is_user(user_rid)) {
1643 DEBUG(4,("RID 0x%x is not a user RID\n", user_rid));
1644 return False;
1645 }
1646
1647 pdb_init_sam(&sampass);
1648
1649 become_root();
1650 ret = pdb_getsampwrid(sampass, user_rid);
1651 unbecome_root();
1652
1653 if (ret == False) {
1654 DEBUG(4,("User 0x%x not found\n", user_rid));
1655 pdb_free_sam(sampass);
1656 return False;
1657 }
1658
1659 samr_clear_sam_passwd(sampass);
1660
1661 DEBUG(3,("User:[%s]\n", pdb_get_username(sampass) ));
1662
1663 ZERO_STRUCTP(id21);
1664 init_sam_user_info21A(id21, sampass);
1665
1666 pdb_free_sam(sampass);
1667
1668 return True;
1669 }
1670
1671 /*******************************************************************
1672 _samr_query_userinfo
1673 ********************************************************************/
1674
1675 NTSTATUS _samr_query_userinfo(pipes_struct *p, SAMR_Q_QUERY_USERINFO *q_u, SAMR_R_QUERY_USERINFO *r_u)
1676 {
1677 SAM_USERINFO_CTR *ctr;
1678 uint32 rid = 0;
1679 struct samr_info *info = NULL;
1680
1681 r_u->status=NT_STATUS_OK;
1682
1683 /* search for the handle */
1684 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
1685 return NT_STATUS_INVALID_HANDLE;
1686
1687 /* find the user's rid */
1688 if ((rid = get_lsa_policy_samr_rid(info)) == 0xffffffff)
1689 return NT_STATUS_OBJECT_TYPE_MISMATCH;
1690
1691 DEBUG(5,("_samr_query_userinfo: rid:0x%x\n", rid));
1692
1693 ctr = (SAM_USERINFO_CTR *)talloc_zero(p->mem_ctx, sizeof(SAM_USERINFO_CTR));
1694 if (!ctr)
1695 return NT_STATUS_NO_MEMORY;
1696
1697 ZERO_STRUCTP(ctr);
1698
1699 /* ok! user info levels (lots: see MSDEV help), off we go... */
1700 ctr->switch_value = q_u->switch_value;
1701
1702 switch (q_u->switch_value) {
1703 case 0x10:
1704 ctr->info.id10 = (SAM_USER_INFO_10 *)talloc_zero(p->mem_ctx, sizeof(SAM_USER_INFO_10));
1705 if (ctr->info.id10 == NULL)
1706 return NT_STATUS_NO_MEMORY;
1707
1708 if (!get_user_info_10(ctr->info.id10, rid))
1709 return NT_STATUS_NO_SUCH_USER;
1710 break;
1711
1712 #if 0
1713 /* whoops - got this wrong. i think. or don't understand what's happening. */
1714 case 0x11:
1715 {
1716 NTTIME expire;
1717 info = (void *)&id11;
1718
1719 expire.low = 0xffffffff;
1720 expire.high = 0x7fffffff;
1721
1722 ctr->info.id = (SAM_USER_INFO_11 *)talloc_zero(p->mem_ctx,
1723 sizeof
1724 (*ctr->
1725 info.
1726 id11));
1727 init_sam_user_info11(ctr->info.id11, &expire,
1728 "BROOKFIELDS$", /* name */
1729 0x03ef, /* user rid */
1730 0x201, /* group rid */
1731 0x0080); /* acb info */
1732
1733 break;
1734 }
1735 #endif
1736
1737 case 0x12:
1738 ctr->info.id12 = (SAM_USER_INFO_12 *)talloc_zero(p->mem_ctx, sizeof(SAM_USER_INFO_12));
1739 if (ctr->info.id12 == NULL)
1740 return NT_STATUS_NO_MEMORY;
1741
1742 if (NT_STATUS_IS_ERR(r_u->status = get_user_info_12(p, ctr->info.id12, rid)))
1743 return r_u->status;
1744 break;
1745
1746 case 20:
1747 ctr->info.id20 = (SAM_USER_INFO_20 *)talloc_zero(p->mem_ctx,sizeof(SAM_USER_INFO_20));
1748 if (ctr->info.id20 == NULL)
1749 return NT_STATUS_NO_MEMORY;
1750 if (!get_user_info_20(ctr->info.id20, rid))
1751 return NT_STATUS_NO_SUCH_USER;
1752 break;
1753
1754 case 21:
1755 ctr->info.id21 = (SAM_USER_INFO_21 *)talloc_zero(p->mem_ctx,sizeof(SAM_USER_INFO_21));
1756 if (ctr->info.id21 == NULL)
1757 return NT_STATUS_NO_MEMORY;
1758 if (!get_user_info_21(ctr->info.id21, rid))
1759 return NT_STATUS_NO_SUCH_USER;
1760 break;
1761
1762 default:
1763 return NT_STATUS_INVALID_INFO_CLASS;
1764 }
1765
1766 init_samr_r_query_userinfo(r_u, ctr, r_u->status);
1767
1768 DEBUG(5,("_samr_query_userinfo: %d\n", __LINE__));
1769
1770 return r_u->status;
1771 }
1772
1773 /*******************************************************************
1774 samr_reply_query_usergroups
1775 ********************************************************************/
1776
1777 NTSTATUS _samr_query_usergroups(pipes_struct *p, SAMR_Q_QUERY_USERGROUPS *q_u, SAMR_R_QUERY_USERGROUPS *r_u)
1778 {
1779 SAM_ACCOUNT *sam_pass=NULL;
1780 DOM_GID *gids = NULL;
1781 int num_groups = 0;
1782 pstring groups;
1783 uint32 rid;
1784 struct samr_info *info = NULL;
1785 BOOL ret;
1786
1787 r_u->status = NT_STATUS_OK;
1788
1789 DEBUG(5,("_samr_query_usergroups: %d\n", __LINE__));
1790
1791 /* find the policy handle. open a policy on it. */
1792 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
1793 return NT_STATUS_INVALID_HANDLE;
1794
1795 /* find the user's rid */
1796 if ((rid = get_lsa_policy_samr_rid(info)) == 0xffffffff)
1797 return NT_STATUS_OBJECT_TYPE_MISMATCH;
1798
1799 pdb_init_sam(&sam_pass);
1800
1801 become_root();
1802 ret = pdb_getsampwrid(sam_pass, rid);
1803 unbecome_root();
1804
1805 if (ret == False) {
1806 samr_clear_sam_passwd(sam_pass);
1807 return NT_STATUS_NO_SUCH_USER;
1808 }
1809
1810 get_domain_user_groups(groups, pdb_get_username(sam_pass));
1811 gids = NULL;
1812 num_groups = make_dom_gids(p->mem_ctx, groups, &gids);
1813
1814 /* construct the response. lkclXXXX: gids are not copied! */
1815 init_samr_r_query_usergroups(r_u, num_groups, gids, r_u->status);
1816
1817 DEBUG(5,("_samr_query_usergroups: %d\n", __LINE__));
1818
1819 samr_clear_sam_passwd(sam_pass);
1820
1821 return r_u->status;
1822 }
1823
1824 /*******************************************************************
1825 _samr_query_dom_info
1826 ********************************************************************/
1827
1828 NTSTATUS _samr_query_dom_info(pipes_struct *p, SAMR_Q_QUERY_DOMAIN_INFO *q_u, SAMR_R_QUERY_DOMAIN_INFO *r_u)
1829 {
1830 SAM_UNK_CTR *ctr;
1831
1832 if ((ctr = (SAM_UNK_CTR *)talloc_zero(p->mem_ctx, sizeof(SAM_UNK_CTR))) == NULL)
1833 return NT_STATUS_NO_MEMORY;
1834
1835 ZERO_STRUCTP(ctr);
1836
1837 r_u->status = NT_STATUS_OK;
1838
1839 DEBUG(5,("_samr_query_dom_info: %d\n", __LINE__));
1840
1841 /* find the policy handle. open a policy on it. */
1842 if (!find_policy_by_hnd(p, &q_u->domain_pol, NULL))
1843 return NT_STATUS_INVALID_HANDLE;
1844
1845 switch (q_u->switch_value) {
1846 case 0x01:
1847 init_unk_info1(&ctr->info.inf1);
1848 break;
1849 case 0x02:
1850 /* The time call below is to get a sequence number for the sam. FIXME !!! JRA. */
1851 init_unk_info2(&ctr->info.inf2, global_myworkgroup, global_myname, (uint32) time(NULL));
1852 break;
1853 case 0x03:
1854 init_unk_info3(&ctr->info.inf3);
1855 break;
1856 case 0x05:
1857 init_unk_info5(&ctr->info.inf5, global_myname);
1858 break;
1859 case 0x06:
1860 init_unk_info6(&ctr->info.inf6);
1861 break;
1862 case 0x07:
1863 init_unk_info7(&ctr->info.inf7);
1864 break;
1865 case 0x0c:
1866 init_unk_info12(&ctr->info.inf12);
1867 break;
1868 default:
1869 return NT_STATUS_INVALID_INFO_CLASS;
1870 }
1871
1872 init_samr_r_query_dom_info(r_u, q_u->switch_value, ctr, NT_STATUS_OK);
1873
1874 DEBUG(5,("_samr_query_dom_info: %d\n", __LINE__));
1875
1876 return r_u->status;
1877 }
1878
1879 /*******************************************************************
1880 _api_samr_create_user
1881 Create an account, can be either a normal user or a machine.
1882 This funcion will need to be updated for bdc/domain trusts.
1883 ********************************************************************/
1884
1885 NTSTATUS _api_samr_create_user(pipes_struct *p, SAMR_Q_CREATE_USER *q_u, SAMR_R_CREATE_USER *r_u)
1886 {
1887 SAM_ACCOUNT *sam_pass=NULL;
1888 fstring mach_acct;
1889 pstring err_str;
1890 pstring msg_str;
1891 int local_flags=0;
1892 DOM_SID sid;
1893 pstring add_script;
1894 POLICY_HND dom_pol = q_u->domain_pol;
1895 UNISTR2 user_account = q_u->uni_name;
1896 uint16 acb_info = q_u->acb_info;
1897 POLICY_HND *user_pol = &r_u->user_pol;
1898 struct samr_info *info = NULL;
1899 BOOL ret;
1900
1901 /* find the policy handle. open a policy on it. */
1902 if (!find_policy_by_hnd(p, &dom_pol, NULL))
1903 return NT_STATUS_INVALID_HANDLE;
1904
1905 /* find the machine account: tell the caller if it exists.
1906 lkclXXXX i have *no* idea if this is a problem or not
1907 or even if you are supposed to construct a different
1908 reply if the account already exists...
1909 */
1910
1911 fstrcpy(mach_acct, dos_unistrn2(user_account.buffer, user_account.uni_str_len));
1912 strlower(mach_acct);
1913
1914 pdb_init_sam(&sam_pass);
1915
1916 become_root();
1917 ret = pdb_getsampwnam(sam_pass, mach_acct);
1918 unbecome_root();
1919 if (ret == True) {
1920 /* machine account exists: say so */
1921 pdb_free_sam(sam_pass);
1922 return NT_STATUS_USER_EXISTS;
1923 }
1924
1925 local_flags=LOCAL_ADD_USER|LOCAL_DISABLE_USER|LOCAL_SET_NO_PASSWORD;
1926 local_flags|= (acb_info & ACB_WSTRUST) ? LOCAL_TRUST_ACCOUNT:0;
1927
1928 /*
1929 * NB. VERY IMPORTANT ! This call must be done as the current pipe user,
1930 * *NOT* surrounded by a become_root()/unbecome_root() call. This ensures
1931 * that only people with write access to the smbpasswd file will be able
1932 * to create a user. JRA.
1933 */
1934
1935 /*
1936 * add the user in the /etc/passwd file or the unix authority system.
1937 * We don't check if the smb_create_user() function succed or not for 2 reasons:
1938 * a) local_password_change() checks for us if the /etc/passwd account really exists
1939 * b) smb_create_user() would return an error if the account already exists
1940 * and as it could return an error also if it can't create the account, it would be tricky.
1941 *
1942 * So we go the easy way, only check after if the account exists.
1943 * JFM (2/3/2001), to clear any possible bad understanding (-:
1944 */
1945
1946 pstrcpy(add_script, lp_adduser_script());
1947
1948 if(*add_script)
1949 smb_create_user(mach_acct, NULL);
1950
1951 /* add the user in the smbpasswd file or the Samba authority database */
1952 if (!local_password_change(mach_acct, local_flags, NULL, err_str, sizeof(err_str), msg_str, sizeof(msg_str))) {
1953 DEBUG(0, ("%s\n", err_str));
1954 pdb_free_sam(sam_pass);
1955 return NT_STATUS_ACCESS_DENIED;
1956 }
1957
1958 become_root();
1959 ret = pdb_getsampwnam(sam_pass, mach_acct);
1960 unbecome_root();
1961 if (ret == False) {
1962 /* account doesn't exist: say so */
1963 pdb_free_sam(sam_pass);
1964 return NT_STATUS_ACCESS_DENIED;
1965 }
1966
1967 /* Get the domain SID stored in the domain policy */
1968 if(!get_lsa_policy_samr_sid(p, &dom_pol, &sid)) {
1969 pdb_free_sam(sam_pass);
1970 return NT_STATUS_INVALID_HANDLE;
1971 }
1972
1973 /* append the user's RID to it */
1974 if(!sid_append_rid(&sid, pdb_get_user_rid(sam_pass) )) {
1975 pdb_free_sam(sam_pass);
1976 return NT_STATUS_NO_SUCH_USER;
1977 }
1978
1979 /* associate the user's SID with the new handle. */
1980 if ((info = (struct samr_info *)malloc(sizeof(struct samr_info))) == NULL) {
1981 pdb_free_sam(sam_pass);
1982 return NT_STATUS_NO_MEMORY;
1983 }
1984
1985 ZERO_STRUCTP(info);
1986 info->sid = sid;
1987
1988 /* get a (unique) handle. open a policy on it. */
1989 if (!create_policy_hnd(p, user_pol, free_samr_info, (void *)info)) {
1990 pdb_free_sam(sam_pass);
1991 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1992 }
1993
1994 r_u->user_rid=sam_pass->user_rid;
1995 r_u->unknown_0 = 0x000703ff;
1996
1997 pdb_free_sam(sam_pass);
1998
1999 return NT_STATUS_OK;
2000 }
2001
2002 /*******************************************************************
2003 samr_reply_connect_anon
2004 ********************************************************************/
2005
2006 NTSTATUS _samr_connect_anon(pipes_struct *p, SAMR_Q_CONNECT_ANON *q_u, SAMR_R_CONNECT_ANON *r_u)
2007 {
2008 struct samr_info *info = NULL;
2009
2010 /* set up the SAMR connect_anon response */
2011
2012 r_u->status = NT_STATUS_OK;
2013
2014 /* associate the user's SID with the new handle. */
2015 if ((info = (struct samr_info *)malloc(sizeof(struct samr_info))) == NULL)
2016 return NT_STATUS_NO_MEMORY;
2017
2018 ZERO_STRUCTP(info);
2019 info->status = q_u->unknown_0;
2020
2021 /* get a (unique) handle. open a policy on it. */
2022 if (!create_policy_hnd(p, &r_u->connect_pol, free_samr_info, (void *)info))
2023 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2024
2025 return r_u->status;
2026 }
2027
2028 /*******************************************************************
2029 samr_reply_connect
2030 ********************************************************************/
2031
2032 NTSTATUS _samr_connect(pipes_struct *p, SAMR_Q_CONNECT *q_u, SAMR_R_CONNECT *r_u)
2033 {
2034 struct samr_info *info = NULL;
2035
2036 DEBUG(5,("_samr_connect: %d\n", __LINE__));
2037
2038 r_u->status = NT_STATUS_OK;
2039
2040 /* associate the user's SID with the new handle. */
2041 if ((info = (struct samr_info *)malloc(sizeof(struct samr_info))) == NULL)
2042 return NT_STATUS_NO_MEMORY;
2043
2044 ZERO_STRUCTP(info);
2045 info->status = q_u->access_mask;
2046
2047 /* get a (unique) handle. open a policy on it. */
2048 if (!create_policy_hnd(p, &r_u->connect_pol, free_samr_info, (void *)info))
2049 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2050
2051 DEBUG(5,("_samr_connect: %d\n", __LINE__));
2052
2053 return r_u->status;
2054 }
2055
2056 /**********************************************************************
2057 api_samr_lookup_domain
2058 **********************************************************************/
2059
2060 NTSTATUS _samr_lookup_domain(pipes_struct *p, SAMR_Q_LOOKUP_DOMAIN *q_u, SAMR_R_LOOKUP_DOMAIN *r_u)
2061 {
2062 r_u->status = NT_STATUS_OK;
2063
2064 if (!find_policy_by_hnd(p, &q_u->connect_pol, NULL))
2065 return NT_STATUS_INVALID_HANDLE;
2066
2067 /* assume the domain name sent is our global_myname and
2068 send global_sam_sid */
2069 init_samr_r_lookup_domain(r_u, &global_sam_sid, r_u->status);
2070
2071 return r_u->status;
2072 }
2073
2074 /******************************************************************
2075 makes a SAMR_R_ENUM_DOMAINS structure.
2076 ********************************************************************/
2077
2078 static BOOL make_enum_domains(TALLOC_CTX *ctx, SAM_ENTRY **pp_sam,
2079 UNISTR2 **pp_uni_name, uint32 num_sam_entries, fstring doms[])
2080 {
2081 uint32 i;
2082 SAM_ENTRY *sam;
2083 UNISTR2 *uni_name;
2084
2085 DEBUG(5, ("make_enum_domains\n"));
2086
2087 *pp_sam = NULL;
2088 *pp_uni_name = NULL;
2089
2090 if (num_sam_entries == 0)
2091 return True;
2092
2093 sam = (SAM_ENTRY *)talloc_zero(ctx, sizeof(SAM_ENTRY)*num_sam_entries);
2094 uni_name = (UNISTR2 *)talloc_zero(ctx, sizeof(UNISTR2)*num_sam_entries);
2095
2096 if (sam == NULL || uni_name == NULL)
2097 return False;
2098
2099 for (i = 0; i < num_sam_entries; i++) {
2100 int len = doms[i] != NULL ? strlen(doms[i]) : 0;
2101
2102 init_sam_entry(&sam[i], len, 0);
2103 init_unistr2(&uni_name[i], doms[i], len);
2104 }
2105
2106 *pp_sam = sam;
2107 *pp_uni_name = uni_name;
2108
2109 return True;
2110 }
2111
2112 /**********************************************************************
2113 api_samr_enum_domains
2114 **********************************************************************/
2115
2116 NTSTATUS _samr_enum_domains(pipes_struct *p, SAMR_Q_ENUM_DOMAINS *q_u, SAMR_R_ENUM_DOMAINS *r_u)
2117 {
2118 uint32 num_entries = 2;
2119 fstring dom[2];
2120
2121 r_u->status = NT_STATUS_OK;
2122
2123 fstrcpy(dom[0],global_myworkgroup);
2124 fstrcpy(dom[1],"Builtin");
2125
2126 if (!make_enum_domains(p->mem_ctx, &r_u->sam, &r_u->uni_dom_name, num_entries, dom))
2127 return NT_STATUS_NO_MEMORY;
2128
2129 init_samr_r_enum_domains(r_u, q_u->start_idx + num_entries, num_entries);
2130
2131 return r_u->status;
2132 }
2133
2134 /*******************************************************************
2135 api_samr_open_alias
2136 ********************************************************************/
2137
2138 NTSTATUS _api_samr_open_alias(pipes_struct *p, SAMR_Q_OPEN_ALIAS *q_u, SAMR_R_OPEN_ALIAS *r_u)
2139 {
2140 DOM_SID sid;
2141 POLICY_HND domain_pol = q_u->dom_pol;
2142 uint32 alias_rid = q_u->rid_alias;
2143 POLICY_HND *alias_pol = &r_u->pol;
2144 struct samr_info *info = NULL;
2145
2146 r_u->status = NT_STATUS_OK;
2147
2148 /* get the domain policy. */
2149 if (!find_policy_by_hnd(p, &domain_pol, NULL))
2150 return NT_STATUS_INVALID_HANDLE;
2151
2152 /* Get the domain SID stored in the domain policy */
2153 if(!get_lsa_policy_samr_sid(p, &domain_pol, &sid))
2154 return NT_STATUS_INVALID_HANDLE;
2155
2156 /* append the alias' RID to it */
2157 if(!sid_append_rid(&sid, alias_rid))
2158 return NT_STATUS_NO_SUCH_USER;
2159
2160 /*
2161 * we should check if the rid really exist !!!
2162 * JFM.
2163 */
2164
2165 /* associate the user's SID with the new handle. */
2166 if ((info = (struct samr_info *)malloc(sizeof(struct samr_info))) == NULL)
2167 return NT_STATUS_NO_MEMORY;
2168
2169 ZERO_STRUCTP(info);
2170 info->sid = sid;
2171
2172 /* get a (unique) handle. open a policy on it. */
2173 if (!create_policy_hnd(p, alias_pol, free_samr_info, (void *)info))
2174 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2175
2176 return r_u->status;
2177 }
2178
2179 /*******************************************************************
2180 set_user_info_10
2181 ********************************************************************/
2182
2183 static BOOL set_user_info_10(const SAM_USER_INFO_10 *id10, uint32 rid)
2184 {
2185 SAM_ACCOUNT *pwd =NULL;
2186 BOOL ret;
2187
2188 pdb_init_sam(&pwd);
2189
2190 ret = pdb_getsampwrid(pwd, rid);
2191
2192 if(ret==False) {
2193 pdb_free_sam(pwd);
2194 return False;
2195 }
2196
2197 if (id10 == NULL) {
2198 DEBUG(5, ("set_user_info_10: NULL id10\n"));
2199 pdb_free_sam(pwd);
2200 return False;
2201 }
2202
2203 if (!pdb_set_acct_ctrl(pwd, id10->acb_info)) {
2204 pdb_free_sam(pwd);
2205 return False;
2206 }
2207
2208 if(!pdb_update_sam_account(pwd, True)) {
2209 pdb_free_sam(pwd);
2210 return False;
2211 }
2212
2213 pdb_free_sam(pwd);
2214
2215 return True;
2216 }
2217
2218 /*******************************************************************
2219 set_user_info_12
2220 ********************************************************************/
2221
2222 static BOOL set_user_info_12(SAM_USER_INFO_12 *id12, uint32 rid)
2223 {
2224 SAM_ACCOUNT *pwd = NULL;
2225
2226 pdb_init_sam(&pwd);
2227
2228 if(!pdb_getsampwrid(pwd, rid)) {
2229 pdb_free_sam(pwd);
2230 return False;
2231 }
2232
2233 if (id12 == NULL) {
2234 DEBUG(2, ("set_user_info_12: id12 is NULL\n"));
2235 pdb_free_sam(pwd);
2236 return False;
2237 }
2238
2239 if (!pdb_set_lanman_passwd (pwd, id12->lm_pwd)) {
2240 pdb_free_sam(pwd);
2241 return False;
2242 }
2243 if (!pdb_set_nt_passwd(pwd, id12->nt_pwd)) {
2244 pdb_free_sam(pwd);
2245 return False;
2246 }
2247
2248 if(!pdb_update_sam_account(pwd, True)) {
2249 pdb_free_sam(pwd);
2250 return False;
2251 }
2252
2253 pdb_free_sam(pwd);
2254 return True;
2255 }
2256
2257 /*******************************************************************
2258 set_user_info_21
2259 ********************************************************************/
2260
2261 static BOOL set_user_info_21(SAM_USER_INFO_21 *id21, uint32 rid)
2262 {
2263 SAM_ACCOUNT *pwd = NULL;
2264 SAM_ACCOUNT *new_pwd = NULL;
2265
2266 if (id21 == NULL) {
2267 DEBUG(5, ("set_user_info_21: NULL id21\n"));
2268 return False;
2269 }
2270
2271 pdb_init_sam(&pwd);
2272 pdb_init_sam(&new_pwd);
2273
2274 if (!pdb_getsampwrid(pwd, rid)) {
2275 pdb_free_sam(pwd);
2276 pdb_free_sam(new_pwd);
2277 return False;
2278 }
2279
2280 /* we make a copy so that we can modify stuff */
2281 copy_sam_passwd(new_pwd, pwd);
2282 copy_id21_to_sam_passwd(new_pwd, id21);
2283
2284 /*
2285 * The funny part about the previous two calls is
2286 * that pwd still has the password hashes from the
2287 * passdb entry. These have not been updated from
2288 * id21. I don't know if they need to be set. --jerry
2289 */
2290
2291 /* write the change out */
2292 if(!pdb_update_sam_account(new_pwd, True)) {
2293 pdb_free_sam(pwd);
2294 pdb_free_sam(new_pwd);
2295 return False;
2296 }
2297
2298 pdb_free_sam(pwd);
2299 pdb_free_sam(new_pwd);
2300
2301 return True;
2302 }
2303
2304 /*******************************************************************
2305 set_user_info_23
2306 ********************************************************************/
2307
2308 static BOOL set_user_info_23(SAM_USER_INFO_23 *id23, uint32 rid)
2309 {
2310 SAM_ACCOUNT *pwd = NULL;
2311 SAM_ACCOUNT *new_pwd = NULL;
2312 uint8 nt_hash[16];
2313 uint8 lm_hash[16];
2314 pstring buf;
2315 uint32 len;
2316 uint16 acct_ctrl;
2317
2318 if (id23 == NULL) {
2319 DEBUG(5, ("set_user_info_23: NULL id23\n"));
2320 return False;
2321 }
2322
2323 pdb_init_sam(&pwd);
2324 pdb_init_sam(&new_pwd);
2325
2326 if (!pdb_getsampwrid(pwd, rid)) {
2327 pdb_free_sam(pwd);
2328 pdb_free_sam(new_pwd);
2329 return False;
2330 }
2331
2332 acct_ctrl = pdb_get_acct_ctrl(pwd);
2333
2334 copy_sam_passwd(new_pwd, pwd);
2335 pdb_free_sam(pwd);
2336
2337 copy_id23_to_sam_passwd(new_pwd, id23);
2338
2339 if (!decode_pw_buffer((char*)id23->pass, buf, 256, &len, nt_hash, lm_hash)) {
2340 pdb_free_sam(new_pwd);
2341 return False;
2342 }
2343
2344 if (!pdb_set_lanman_passwd (new_pwd, lm_hash)) {
2345 pdb_free_sam(new_pwd);
2346 return False;
2347 }
2348 if (!pdb_set_nt_passwd(new_pwd, nt_hash)) {
2349 pdb_free_sam(new_pwd);
2350 return False;
2351 }
2352
2353 /* if it's a trust account, don't update /etc/passwd */
2354 if ( ( (acct_ctrl & ACB_DOMTRUST) == ACB_DOMTRUST ) ||
2355 ( (acct_ctrl & ACB_WSTRUST) == ACB_WSTRUST) ||
2356 ( (acct_ctrl & ACB_SVRTRUST) == ACB_SVRTRUST) ) {
2357 DEBUG(5, ("Changing trust account password, not updating /etc/passwd\n"));
2358 } else {
2359 /* update the UNIX password */
2360 if (lp_unix_password_sync() )
2361 if(!chgpasswd(pdb_get_username(new_pwd), "", buf, True)) {
2362 pdb_free_sam(new_pwd);
2363 return False;
2364 }
2365 }
2366
2367 memset(buf, 0, sizeof(buf));
2368
2369 if(!pdb_update_sam_account(new_pwd, True)) {
2370 pdb_free_sam(new_pwd);
2371 return False;
2372 }
2373
2374 pdb_free_sam(new_pwd);
2375
2376 return True;
2377 }
2378
2379 /*******************************************************************
2380 set_user_info_pw
2381 ********************************************************************/
2382
2383 static BOOL set_user_info_pw(char *pass, uint32 rid)
2384 {
2385 SAM_ACCOUNT *pwd = NULL;
2386 uchar nt_hash[16];
2387 uchar lm_hash[16];
2388 uint32 len;
2389 pstring buf;
2390 uint16 acct_ctrl;
2391
2392 pdb_init_sam(&pwd);
2393
2394 if (!pdb_getsampwrid(pwd, rid)) {
2395 pdb_free_sam(pwd);
2396 return False;
2397 }
2398
2399 acct_ctrl = pdb_get_acct_ctrl(pwd);
2400
2401 memset(buf, 0, sizeof(buf));
2402
2403 if (!decode_pw_buffer(pass, buf, 256, &len, nt_hash, lm_hash)) {
2404 pdb_free_sam(pwd);
2405 return False;
2406 }
2407
2408 if (!pdb_set_lanman_passwd (pwd, lm_hash)) {
2409 pdb_free_sam(pwd);
2410 return False;
2411 }
2412 if (!pdb_set_nt_passwd(pwd, nt_hash)) {
2413 pdb_free_sam(pwd);
2414 return False;
2415 }
2416
2417 /* if it's a trust account, don't update /etc/passwd */
2418 if ( ( (acct_ctrl & ACB_DOMTRUST) == ACB_DOMTRUST ) ||
2419 ( (acct_ctrl & ACB_WSTRUST) == ACB_WSTRUST) ||
2420 ( (acct_ctrl & ACB_SVRTRUST) == ACB_SVRTRUST) ) {
2421 DEBUG(5, ("Changing trust account password, not updating /etc/passwd\n"));
2422 } else {
2423 /* update the UNIX password */
2424 if (lp_unix_password_sync())
2425 if(!chgpasswd(pdb_get_username(pwd), "", buf, True)) {
2426 pdb_free_sam(pwd);
2427 return False;
2428 }
2429 }
2430
2431 memset(buf, 0, sizeof(buf));
2432
2433 DEBUG(5,("set_user_info_pw: pdb_update_sam_account()\n"));
2434
2435 /* update the SAMBA password */
2436 if(!pdb_update_sam_account(pwd, True)) {
2437 pdb_free_sam(pwd);
2438 return False;
2439 }
2440
2441 pdb_free_sam(pwd);
2442
2443 return True;
2444 }
2445
2446 /*******************************************************************
2447 samr_reply_set_userinfo
2448 ********************************************************************/
2449
2450 NTSTATUS _samr_set_userinfo(pipes_struct *p, SAMR_Q_SET_USERINFO *q_u, SAMR_R_SET_USERINFO *r_u)
2451 {
2452 uint32 rid = 0x0;
2453 DOM_SID sid;
2454 struct current_user user;
2455 SAM_ACCOUNT *sam_pass=NULL;
2456 unsigned char sess_key[16];
2457 POLICY_HND *pol = &q_u->pol;
2458 uint16 switch_value = q_u->switch_value;
2459 SAM_USERINFO_CTR *ctr = q_u->ctr;
2460 BOOL ret;
2461
2462 DEBUG(5, ("_samr_set_userinfo: %d\n", __LINE__));
2463
2464 r_u->status = NT_STATUS_OK;
2465
2466 if (p->ntlmssp_auth_validated) {
2467 memcpy(&user, &p->pipe_user, sizeof(user));
2468 } else {
2469 extern struct current_user current_user;
2470 memcpy(&user, &current_user, sizeof(user));
2471 }
2472
2473 /* find the policy handle. open a policy on it. */
2474 if (!get_lsa_policy_samr_sid(p, pol, &sid))
2475 return NT_STATUS_INVALID_HANDLE;
2476
2477 sid_split_rid(&sid, &rid);
2478
2479 DEBUG(5, ("_samr_set_userinfo: rid:0x%x, level:%d\n", rid, switch_value));
2480
2481 if (ctr == NULL) {
2482 DEBUG(5, ("_samr_set_userinfo: NULL info level\n"));
2483 return NT_STATUS_INVALID_INFO_CLASS;
2484 }
2485
2486
2487 pdb_init_sam(&sam_pass);
2488
2489 /*
2490 * We need the NT hash of the user who is changing the user's password.
2491 * This NT hash is used to generate a "user session key"
2492 * This "user session key" is in turn used to encrypt/decrypt the user's password.
2493 */
2494
2495 become_root();
2496 ret = pdb_getsampwuid(sam_pass, user.uid);
2497 unbecome_root();
2498 if(ret == False) {
2499 DEBUG(0,("_samr_set_userinfo: Unable to get smbpasswd entry for uid %u\n", (unsigned int)user.uid ));
2500 pdb_free_sam(sam_pass);
2501 return NT_STATUS_ACCESS_DENIED;
2502 }
2503
2504 memset(sess_key, '\0', 16);
2505 mdfour(sess_key, pdb_get_nt_passwd(sam_pass), 16);
2506
2507 pdb_free_sam(sam_pass);
2508
2509 /* ok! user info levels (lots: see MSDEV help), off we go... */
2510 switch (switch_value) {
2511 case 0x12:
2512 if (!set_user_info_12(ctr->info.id12, rid))
2513 return NT_STATUS_ACCESS_DENIED;
2514 break;
2515
2516 case 24:
2517 SamOEMhash(ctr->info.id24->pass, sess_key, 516);
2518
2519 dump_data(100, (char *)ctr->info.id24->pass, 516);
2520
2521 if (!set_user_info_pw((char *)ctr->info.id24->pass, rid))
2522 return NT_STATUS_ACCESS_DENIED;
2523 break;
2524
2525 case 25:
2526 #if 0
2527 /*
2528 * Currently we don't really know how to unmarshall
2529 * the level 25 struct, and the password encryption
2530 * is different. This is a placeholder for when we
2531 * do understand it. In the meantime just return INVALID
2532 * info level and W2K SP2 drops down to level 23... JRA.
2533 */
2534
2535 SamOEMhash(ctr->info.id25->pass, sess_key, 532);
2536
2537 dump_data(100, (char *)ctr->info.id25->pass, 532);
2538
2539 if (!set_user_info_pw(ctr->info.id25->pass, rid))
2540 return NT_STATUS_ACCESS_DENIED;
2541 break;
2542 #endif
2543 return NT_STATUS_INVALID_INFO_CLASS;
2544
2545 case 23:
2546 SamOEMhash(ctr->info.id23->pass, sess_key, 516);
2547
2548 dump_data(100, (char *)ctr->info.id23->pass, 516);
2549
2550 if (!set_user_info_23(ctr->info.id23, rid))
2551 return NT_STATUS_ACCESS_DENIED;
2552 break;
2553
2554 default:
2555 return NT_STATUS_INVALID_INFO_CLASS;
2556 }
2557
2558 return r_u->status;
2559 }
2560
2561 /*******************************************************************
2562 samr_reply_set_userinfo2
2563 ********************************************************************/
2564
2565 NTSTATUS _samr_set_userinfo2(pipes_struct *p, SAMR_Q_SET_USERINFO2 *q_u, SAMR_R_SET_USERINFO2 *r_u)
2566 {
2567 DOM_SID sid;
2568 uint32 rid = 0x0;
2569 SAM_USERINFO_CTR *ctr = q_u->ctr;
2570 POLICY_HND *pol = &q_u->pol;
2571 uint16 switch_value = q_u->switch_value;
2572
2573 DEBUG(5, ("samr_reply_set_userinfo2: %d\n", __LINE__));
2574
2575 r_u->status = NT_STATUS_OK;
2576
2577 /* find the policy handle. open a policy on it. */
2578 if (!get_lsa_policy_samr_sid(p, pol, &sid))
2579 return NT_STATUS_INVALID_HANDLE;
2580
2581 sid_split_rid(&sid, &rid);
2582
2583 DEBUG(5, ("samr_reply_set_userinfo2: rid:0x%x\n", rid));
2584
2585 if (ctr == NULL) {
2586 DEBUG(5, ("samr_reply_set_userinfo2: NULL info level\n"));
2587 return NT_STATUS_INVALID_INFO_CLASS;
2588 }
2589
2590 switch_value=ctr->switch_value;
2591
2592 /* ok! user info levels (lots: see MSDEV help), off we go... */
2593 switch (switch_value) {
2594 case 21:
2595 if (!set_user_info_21(ctr->info.id21, rid))
2596 return NT_STATUS_ACCESS_DENIED;
2597 break;
2598 case 16:
2599 if (!set_user_info_10(ctr->info.id10, rid))
2600 return NT_STATUS_ACCESS_DENIED;
2601 break;
2602 case 18:
2603 /* Used by AS/U JRA. */
2604 if (!set_user_info_12(ctr->info.id12, rid))
2605 return NT_STATUS_ACCESS_DENIED;
2606 break;
2607 default:
2608 return NT_STATUS_INVALID_INFO_CLASS;
2609 }
2610
2611 return r_u->status;
2612 }
2613
2614 /*********************************************************************
2615 _samr_query_aliasmem
2616 *********************************************************************/
2617
2618 NTSTATUS _samr_query_useraliases(pipes_struct *p, SAMR_Q_QUERY_USERALIASES *q_u, SAMR_R_QUERY_USERALIASES *r_u)
2619 {
2620 uint32 *rid=NULL;
2621 int num_rids;
2622
2623 num_rids = 1;
2624 rid=(uint32 *)talloc_zero(p->mem_ctx, num_rids*sizeof(uint32));
2625 if (rid == NULL)
2626 return NT_STATUS_NO_MEMORY;
2627
2628 /* until i see a real useraliases query, we fack one up */
2629
2630 rid[0] = BUILTIN_ALIAS_RID_USERS;
2631
2632 init_samr_r_query_useraliases(r_u, num_rids, rid, NT_STATUS_OK);
2633
2634 return NT_STATUS_OK;
2635
2636 }
2637
2638 /*********************************************************************
2639 _samr_query_aliasmem
2640 *********************************************************************/
2641
2642 NTSTATUS _samr_query_aliasmem(pipes_struct *p, SAMR_Q_QUERY_ALIASMEM *q_u, SAMR_R_QUERY_ALIASMEM *r_u)
2643 {
2644 DEBUG(0,("_samr_query_aliasmem: Not yet implemented.\n"));
2645 return NT_STATUS_NOT_IMPLEMENTED;
2646 }
2647
2648 /*********************************************************************
2649 _samr_query_groupmem
2650 *********************************************************************/
2651
2652 NTSTATUS _samr_query_groupmem(pipes_struct *p, SAMR_Q_QUERY_GROUPMEM *q_u, SAMR_R_QUERY_GROUPMEM *r_u)
2653 {
2654 DEBUG(0,("_samr_query_groupmem: Not yet implemented.\n"));
2655 return NT_STATUS_NOT_IMPLEMENTED;
2656 }
2657
2658 /*********************************************************************
2659 _samr_add_aliasmem
2660 *********************************************************************/
2661
2662 NTSTATUS _samr_add_aliasmem(pipes_struct *p, SAMR_Q_ADD_ALIASMEM *q_u, SAMR_R_ADD_ALIASMEM *r_u)
2663 {
2664 DEBUG(0,("_samr_add_aliasmem: Not yet implemented.\n"));
2665 return NT_STATUS_NOT_IMPLEMENTED;
2666 }
2667
2668 /*********************************************************************
2669 _samr_del_aliasmem
2670 *********************************************************************/
2671
2672 NTSTATUS _samr_del_aliasmem(pipes_struct *p, SAMR_Q_DEL_ALIASMEM *q_u, SAMR_R_DEL_ALIASMEM *r_u)
2673 {
2674 DEBUG(0,("_samr_del_aliasmem: Not yet implemented.\n"));
2675 return NT_STATUS_NOT_IMPLEMENTED;
2676 }
2677
2678 /*********************************************************************
2679 _samr_add_groupmem
2680 *********************************************************************/
2681
2682 NTSTATUS _samr_add_groupmem(pipes_struct *p, SAMR_Q_ADD_GROUPMEM *q_u, SAMR_R_ADD_GROUPMEM *r_u)
2683 {
2684 DEBUG(0,("_samr_add_groupmem: Not yet implemented.\n"));
2685 return NT_STATUS_NOT_IMPLEMENTED;
2686 }
2687
2688 /*********************************************************************
2689 _samr_del_groupmem
2690 *********************************************************************/
2691
2692 NTSTATUS _samr_del_groupmem(pipes_struct *p, SAMR_Q_DEL_GROUPMEM *q_u, SAMR_R_DEL_GROUPMEM *r_u)
2693 {
2694 DEBUG(0,("_samr_del_groupmem: Not yet implemented.\n"));
2695 return NT_STATUS_NOT_IMPLEMENTED;
2696 }
2697
2698 /*********************************************************************
2699 _samr_delete_dom_user
2700 *********************************************************************/
2701
2702 NTSTATUS _samr_delete_dom_user(pipes_struct *p, SAMR_Q_DELETE_DOM_USER *q_u, SAMR_R_DELETE_DOM_USER *r_u )
2703 {
2704 DEBUG(0,("_samr_delete_dom_user: Not yet implemented.\n"));
2705 return NT_STATUS_NOT_IMPLEMENTED;
2706 }
2707
2708 /*********************************************************************
2709 _samr_delete_dom_group
2710 *********************************************************************/
2711
2712 NTSTATUS _samr_delete_dom_group(pipes_struct *p, SAMR_Q_DELETE_DOM_GROUP *q_u, SAMR_R_DELETE_DOM_GROUP *r_u)
2713 {
2714 DEBUG(0,("_samr_delete_dom_group: Not yet implemented.\n"));
2715 return NT_STATUS_NOT_IMPLEMENTED;
2716 }
2717
2718 /*********************************************************************
2719 _samr_delete_dom_alias
2720 *********************************************************************/
2721
2722 NTSTATUS _samr_delete_dom_alias(pipes_struct *p, SAMR_Q_DELETE_DOM_ALIAS *q_u, SAMR_R_DELETE_DOM_ALIAS *r_u)
2723 {
2724 DEBUG(0,("_samr_delete_dom_alias: Not yet implemented.\n"));
2725 return NT_STATUS_NOT_IMPLEMENTED;
2726 }
2727
2728 /*********************************************************************
2729 _samr_create_dom_group
2730 *********************************************************************/
2731
2732 NTSTATUS _samr_create_dom_group(pipes_struct *p, SAMR_Q_CREATE_DOM_GROUP *q_u, SAMR_R_CREATE_DOM_GROUP *r_u)
2733 {
2734 DEBUG(0,("_samr_create_dom_group: Not yet implemented.\n"));
2735 return NT_STATUS_NOT_IMPLEMENTED;
2736 }
2737
2738 /*********************************************************************
2739 _samr_create_dom_alias
2740 *********************************************************************/
2741
2742 NTSTATUS _samr_create_dom_alias(pipes_struct *p, SAMR_Q_CREATE_DOM_ALIAS *q_u, SAMR_R_CREATE_DOM_ALIAS *r_u)
2743 {
2744 DEBUG(0,("_samr_create_dom_alias: Not yet implemented.\n"));
2745 return NT_STATUS_NOT_IMPLEMENTED;
2746 }
2747
2748 /*********************************************************************
2749 _samr_query_groupinfo
2750 *********************************************************************/
2751
2752 NTSTATUS _samr_query_groupinfo(pipes_struct *p, SAMR_Q_QUERY_GROUPINFO *q_u, SAMR_R_QUERY_GROUPINFO *r_u)
2753 {
2754 DEBUG(0,("_samr_query_groupinfo: Not yet implemented.\n"));
2755 return NT_STATUS_NOT_IMPLEMENTED;
2756 }
2757
2758 /*********************************************************************
2759 _samr_set_groupinfo
2760 *********************************************************************/
2761
2762 NTSTATUS _samr_set_groupinfo(pipes_struct *p, SAMR_Q_SET_GROUPINFO *q_u, SAMR_R_SET_GROUPINFO *r_u)
2763 {
2764 DEBUG(0,("_samr_set_groupinfo: Not yet implemented.\n"));
2765 return NT_STATUS_NOT_IMPLEMENTED;
2766 }
2767
2768 /*********************************************************************
2769 _samr_get_dom_pwinfo
2770 *********************************************************************/
2771
2772 NTSTATUS _samr_get_dom_pwinfo(pipes_struct *p, SAMR_Q_GET_DOM_PWINFO *q_u, SAMR_R_GET_DOM_PWINFO *r_u)
2773 {
2774 /* Actually, returning zeros here works quite well :-). */
2775 return NT_STATUS_OK;
2776 }
2777
2778 /*********************************************************************
2779 _samr_open_group
2780 *********************************************************************/
2781
2782 NTSTATUS _samr_open_group(pipes_struct *p, SAMR_Q_OPEN_GROUP *q_u, SAMR_R_OPEN_GROUP *r_u)
2783 {
2784 DEBUG(0,("_samr_open_group: Not yet implemented.\n"));
2785 return NT_STATUS_NOT_IMPLEMENTED;
2786 }
2787
2788 /*********************************************************************
2789 _samr_unknown_2d
2790 *********************************************************************/
2791
2792 NTSTATUS _samr_unknown_2d(pipes_struct *p, SAMR_Q_UNKNOWN_2D *q_u, SAMR_R_UNKNOWN_2D *r_u)
2793 {
2794 DEBUG(0,("_samr_unknown_2d: Not yet implemented.\n"));
2795 return NT_STATUS_NOT_IMPLEMENTED;
2796 }
Samba GIT mirror