source: vendor/current/source3/winbindd/winbindd_samr.c

Last change on this file was 988, checked in by Silvan Scherrer, 9 years ago

Samba Server: update vendor to version 4.4.3
File size: 23.8 KB
Line 
1/*
2 * Unix SMB/CIFS implementation.
3 *
4 * Winbind rpc backend functions
5 *
6 * Copyright (c) 2000-2003 Tim Potter
7 * Copyright (c) 2001 Andrew Tridgell
8 * Copyright (c) 2005 Volker Lendecke
9 * Copyright (c) 2008 Guenther Deschner (pidl conversion)
10 * Copyright (c) 2010 Andreas Schneider <asn@samba.org>
11 *
12 * This program is free software; you can redistribute it and/or modify
13 * it under the terms of the GNU General Public License as published by
14 * the Free Software Foundation; either version 3 of the License, or
15 * (at your option) any later version.
16 *
17 * This program is distributed in the hope that it will be useful,
18 * but WITHOUT ANY WARRANTY; without even the implied warranty of
19 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20 * GNU General Public License for more details.
21 *
22 * You should have received a copy of the GNU General Public License
23 * along with this program. If not, see <http://www.gnu.org/licenses/>.
24 */
25
26#include "includes.h"
27#include "winbindd.h"
28#include "winbindd_rpc.h"
29#include "rpc_client/rpc_client.h"
30#include "../librpc/gen_ndr/ndr_samr_c.h"
31#include "rpc_client/cli_samr.h"
32#include "../librpc/gen_ndr/ndr_lsa_c.h"
33#include "rpc_client/cli_lsarpc.h"
34#include "rpc_server/rpc_ncacn_np.h"
35#include "../libcli/security/security.h"
36#include "passdb/machine_sid.h"
37#include "auth.h"
38
39#undef DBGC_CLASS
40#define DBGC_CLASS DBGC_WINBIND
41
42NTSTATUS open_internal_samr_conn(TALLOC_CTX *mem_ctx,
43 struct winbindd_domain *domain,
44 struct rpc_pipe_client **samr_pipe,
45 struct policy_handle *samr_domain_hnd)
46{
47 NTSTATUS status, result;
48 struct policy_handle samr_connect_hnd;
49 struct dcerpc_binding_handle *b;
50
51 status = wb_open_internal_pipe(mem_ctx, &ndr_table_samr, samr_pipe);
52 if (!NT_STATUS_IS_OK(status)) {
53 return status;
54 }
55
56 b = (*samr_pipe)->binding_handle;
57
58 status = dcerpc_samr_Connect2(b, mem_ctx,
59 (*samr_pipe)->desthost,
60 SEC_FLAG_MAXIMUM_ALLOWED,
61 &samr_connect_hnd,
62 &result);
63 if (!NT_STATUS_IS_OK(status)) {
64 return status;
65 }
66 if (!NT_STATUS_IS_OK(result)) {
67 return result;
68 }
69
70 status = dcerpc_samr_OpenDomain(b, mem_ctx,
71 &samr_connect_hnd,
72 SEC_FLAG_MAXIMUM_ALLOWED,
73 &domain->sid,
74 samr_domain_hnd,
75 &result);
76 if (!NT_STATUS_IS_OK(status)) {
77 return status;
78 }
79
80 return result;
81}
82
83NTSTATUS open_internal_lsa_conn(TALLOC_CTX *mem_ctx,
84 struct rpc_pipe_client **lsa_pipe,
85 struct policy_handle *lsa_hnd)
86{
87 NTSTATUS status;
88
89 status = wb_open_internal_pipe(mem_ctx, &ndr_table_lsarpc, lsa_pipe);
90 if (!NT_STATUS_IS_OK(status)) {
91 return status;
92 }
93
94 status = rpccli_lsa_open_policy((*lsa_pipe),
95 mem_ctx,
96 true,
97 SEC_FLAG_MAXIMUM_ALLOWED,
98 lsa_hnd);
99
100 return status;
101}
102
103/*********************************************************************
104 SAM specific functions.
105*********************************************************************/
106
107/* List all domain groups */
108static NTSTATUS sam_enum_dom_groups(struct winbindd_domain *domain,
109 TALLOC_CTX *mem_ctx,
110 uint32_t *pnum_info,
111 struct wb_acct_info **pinfo)
112{
113 struct rpc_pipe_client *samr_pipe;
114 struct policy_handle dom_pol;
115 struct wb_acct_info *info = NULL;
116 uint32_t num_info = 0;
117 TALLOC_CTX *tmp_ctx;
118 NTSTATUS status, result;
119 struct dcerpc_binding_handle *b = NULL;
120
121 DEBUG(3,("sam_enum_dom_groups\n"));
122
123 ZERO_STRUCT(dom_pol);
124
125 if (pnum_info) {
126 *pnum_info = 0;
127 }
128
129 tmp_ctx = talloc_stackframe();
130 if (tmp_ctx == NULL) {
131 return NT_STATUS_NO_MEMORY;
132 }
133
134 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
135 if (!NT_STATUS_IS_OK(status)) {
136 goto error;
137 }
138
139 b = samr_pipe->binding_handle;
140
141 status = rpc_enum_dom_groups(tmp_ctx,
142 samr_pipe,
143 &dom_pol,
144 &num_info,
145 &info);
146 if (!NT_STATUS_IS_OK(status)) {
147 goto error;
148 }
149
150 if (pnum_info) {
151 *pnum_info = num_info;
152 }
153
154 if (pinfo) {
155 *pinfo = talloc_move(mem_ctx, &info);
156 }
157
158error:
159 if (b && is_valid_policy_hnd(&dom_pol)) {
160 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
161 }
162 TALLOC_FREE(tmp_ctx);
163 return status;
164}
165
166/* Query display info for a domain */
167static NTSTATUS sam_query_user_list(struct winbindd_domain *domain,
168 TALLOC_CTX *mem_ctx,
169 uint32_t *pnum_info,
170 struct wbint_userinfo **pinfo)
171{
172 struct rpc_pipe_client *samr_pipe = NULL;
173 struct policy_handle dom_pol;
174 struct wbint_userinfo *info = NULL;
175 uint32_t num_info = 0;
176 TALLOC_CTX *tmp_ctx;
177 NTSTATUS status, result;
178 struct dcerpc_binding_handle *b = NULL;
179
180 DEBUG(3,("samr_query_user_list\n"));
181
182 ZERO_STRUCT(dom_pol);
183
184 if (pnum_info) {
185 *pnum_info = 0;
186 }
187
188 tmp_ctx = talloc_stackframe();
189 if (tmp_ctx == NULL) {
190 return NT_STATUS_NO_MEMORY;
191 }
192
193 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
194 if (!NT_STATUS_IS_OK(status)) {
195 goto done;
196 }
197
198 b = samr_pipe->binding_handle;
199
200 status = rpc_query_user_list(tmp_ctx,
201 samr_pipe,
202 &dom_pol,
203 &domain->sid,
204 &num_info,
205 &info);
206 if (!NT_STATUS_IS_OK(status)) {
207 goto done;
208 }
209
210 if (pnum_info) {
211 *pnum_info = num_info;
212 }
213
214 if (pinfo) {
215 *pinfo = talloc_move(mem_ctx, &info);
216 }
217
218done:
219 if (b && is_valid_policy_hnd(&dom_pol)) {
220 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
221 }
222
223 TALLOC_FREE(tmp_ctx);
224 return status;
225}
226
227/* Lookup user information from a rid or username. */
228static NTSTATUS sam_query_user(struct winbindd_domain *domain,
229 TALLOC_CTX *mem_ctx,
230 const struct dom_sid *user_sid,
231 struct wbint_userinfo *user_info)
232{
233 struct rpc_pipe_client *samr_pipe;
234 struct policy_handle dom_pol;
235 TALLOC_CTX *tmp_ctx;
236 NTSTATUS status, result;
237 struct dcerpc_binding_handle *b = NULL;
238
239 DEBUG(3,("sam_query_user\n"));
240
241 ZERO_STRUCT(dom_pol);
242
243 /* Paranoia check */
244 if (!sid_check_is_in_our_sam(user_sid)) {
245 return NT_STATUS_NO_SUCH_USER;
246 }
247
248 user_info->homedir = NULL;
249 user_info->shell = NULL;
250 user_info->primary_gid = (gid_t) -1;
251
252 tmp_ctx = talloc_stackframe();
253 if (tmp_ctx == NULL) {
254 return NT_STATUS_NO_MEMORY;
255 }
256
257 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
258 if (!NT_STATUS_IS_OK(status)) {
259 goto done;
260 }
261
262 b = samr_pipe->binding_handle;
263
264 status = rpc_query_user(tmp_ctx,
265 samr_pipe,
266 &dom_pol,
267 &domain->sid,
268 user_sid,
269 user_info);
270
271done:
272 if (b && is_valid_policy_hnd(&dom_pol)) {
273 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
274 }
275
276 TALLOC_FREE(tmp_ctx);
277 return status;
278}
279
280/* get a list of trusted domains - builtin domain */
281static NTSTATUS sam_trusted_domains(struct winbindd_domain *domain,
282 TALLOC_CTX *mem_ctx,
283 struct netr_DomainTrustList *ptrust_list)
284{
285 struct rpc_pipe_client *lsa_pipe;
286 struct policy_handle lsa_policy;
287 struct netr_DomainTrust *trusts = NULL;
288 uint32_t num_trusts = 0;
289 TALLOC_CTX *tmp_ctx;
290 NTSTATUS status, result;
291 struct dcerpc_binding_handle *b = NULL;
292
293 DEBUG(3,("samr: trusted domains\n"));
294
295 ZERO_STRUCT(lsa_policy);
296
297 if (ptrust_list) {
298 ZERO_STRUCTP(ptrust_list);
299 }
300
301 tmp_ctx = talloc_stackframe();
302 if (tmp_ctx == NULL) {
303 return NT_STATUS_NO_MEMORY;
304 }
305
306 status = open_internal_lsa_conn(tmp_ctx, &lsa_pipe, &lsa_policy);
307 if (!NT_STATUS_IS_OK(status)) {
308 goto done;
309 }
310
311 b = lsa_pipe->binding_handle;
312
313 status = rpc_trusted_domains(tmp_ctx,
314 lsa_pipe,
315 &lsa_policy,
316 &num_trusts,
317 &trusts);
318 if (!NT_STATUS_IS_OK(status)) {
319 goto done;
320 }
321
322 if (ptrust_list) {
323 ptrust_list->count = num_trusts;
324 ptrust_list->array = talloc_move(mem_ctx, &trusts);
325 }
326
327done:
328 if (b && is_valid_policy_hnd(&lsa_policy)) {
329 dcerpc_lsa_Close(b, mem_ctx, &lsa_policy, &result);
330 }
331
332 TALLOC_FREE(tmp_ctx);
333 return status;
334}
335
336/* Lookup group membership given a rid. */
337static NTSTATUS sam_lookup_groupmem(struct winbindd_domain *domain,
338 TALLOC_CTX *mem_ctx,
339 const struct dom_sid *group_sid,
340 enum lsa_SidType type,
341 uint32_t *pnum_names,
342 struct dom_sid **psid_mem,
343 char ***pnames,
344 uint32_t **pname_types)
345{
346 struct rpc_pipe_client *samr_pipe;
347 struct policy_handle dom_pol;
348
349 uint32_t num_names = 0;
350 struct dom_sid *sid_mem = NULL;
351 char **names = NULL;
352 uint32_t *name_types = NULL;
353
354 TALLOC_CTX *tmp_ctx;
355 NTSTATUS status, result;
356 struct dcerpc_binding_handle *b = NULL;
357
358 DEBUG(3,("sam_lookup_groupmem\n"));
359
360 ZERO_STRUCT(dom_pol);
361
362 /* Paranoia check */
363 if (sid_check_is_in_builtin(group_sid) && (type != SID_NAME_ALIAS)) {
364 /* There's no groups, only aliases in BUILTIN */
365 return NT_STATUS_NO_SUCH_GROUP;
366 }
367
368 if (pnum_names) {
369 *pnum_names = 0;
370 }
371
372 tmp_ctx = talloc_stackframe();
373 if (tmp_ctx == NULL) {
374 return NT_STATUS_NO_MEMORY;
375 }
376
377 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
378 if (!NT_STATUS_IS_OK(status)) {
379 goto done;
380 }
381
382 b = samr_pipe->binding_handle;
383
384 status = rpc_lookup_groupmem(tmp_ctx,
385 samr_pipe,
386 &dom_pol,
387 domain->name,
388 &domain->sid,
389 group_sid,
390 type,
391 &num_names,
392 &sid_mem,
393 &names,
394 &name_types);
395
396 if (pnum_names) {
397 *pnum_names = num_names;
398 }
399
400 if (pnames) {
401 *pnames = talloc_move(mem_ctx, &names);
402 }
403
404 if (pname_types) {
405 *pname_types = talloc_move(mem_ctx, &name_types);
406 }
407
408 if (psid_mem) {
409 *psid_mem = talloc_move(mem_ctx, &sid_mem);
410 }
411
412done:
413 if (b && is_valid_policy_hnd(&dom_pol)) {
414 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
415 }
416
417 TALLOC_FREE(tmp_ctx);
418 return status;
419}
420
421/*********************************************************************
422 BUILTIN specific functions.
423*********************************************************************/
424
425/* List all domain groups */
426static NTSTATUS builtin_enum_dom_groups(struct winbindd_domain *domain,
427 TALLOC_CTX *mem_ctx,
428 uint32_t *num_entries,
429 struct wb_acct_info **info)
430{
431 /* BUILTIN doesn't have domain groups */
432 *num_entries = 0;
433 *info = NULL;
434 return NT_STATUS_OK;
435}
436
437/* Query display info for a domain */
438static NTSTATUS builtin_query_user_list(struct winbindd_domain *domain,
439 TALLOC_CTX *mem_ctx,
440 uint32_t *num_entries,
441 struct wbint_userinfo **info)
442{
443 /* We don't have users */
444 *num_entries = 0;
445 *info = NULL;
446 return NT_STATUS_OK;
447}
448
449/* Lookup user information from a rid or username. */
450static NTSTATUS builtin_query_user(struct winbindd_domain *domain,
451 TALLOC_CTX *mem_ctx,
452 const struct dom_sid *user_sid,
453 struct wbint_userinfo *user_info)
454{
455 return NT_STATUS_NO_SUCH_USER;
456}
457
458/* get a list of trusted domains - builtin domain */
459static NTSTATUS builtin_trusted_domains(struct winbindd_domain *domain,
460 TALLOC_CTX *mem_ctx,
461 struct netr_DomainTrustList *trusts)
462{
463 ZERO_STRUCTP(trusts);
464 return NT_STATUS_OK;
465}
466
467/*********************************************************************
468 COMMON functions.
469*********************************************************************/
470
471/* List all local groups (aliases) */
472static NTSTATUS sam_enum_local_groups(struct winbindd_domain *domain,
473 TALLOC_CTX *mem_ctx,
474 uint32_t *pnum_info,
475 struct wb_acct_info **pinfo)
476{
477 struct rpc_pipe_client *samr_pipe;
478 struct policy_handle dom_pol;
479 struct wb_acct_info *info = NULL;
480 uint32_t num_info = 0;
481 TALLOC_CTX *tmp_ctx;
482 NTSTATUS status, result;
483 struct dcerpc_binding_handle *b = NULL;
484
485 DEBUG(3,("samr: enum local groups\n"));
486
487 ZERO_STRUCT(dom_pol);
488
489 if (pnum_info) {
490 *pnum_info = 0;
491 }
492
493 tmp_ctx = talloc_stackframe();
494 if (tmp_ctx == NULL) {
495 return NT_STATUS_NO_MEMORY;
496 }
497
498 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
499 if (!NT_STATUS_IS_OK(status)) {
500 goto done;
501 }
502
503 b = samr_pipe->binding_handle;
504
505 status = rpc_enum_local_groups(mem_ctx,
506 samr_pipe,
507 &dom_pol,
508 &num_info,
509 &info);
510 if (!NT_STATUS_IS_OK(status)) {
511 goto done;
512 }
513
514 if (pnum_info) {
515 *pnum_info = num_info;
516 }
517
518 if (pinfo) {
519 *pinfo = talloc_move(mem_ctx, &info);
520 }
521
522done:
523 if (b && is_valid_policy_hnd(&dom_pol)) {
524 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
525 }
526
527 TALLOC_FREE(tmp_ctx);
528 return status;
529}
530
531/* convert a single name to a sid in a domain */
532static NTSTATUS sam_name_to_sid(struct winbindd_domain *domain,
533 TALLOC_CTX *mem_ctx,
534 const char *domain_name,
535 const char *name,
536 uint32_t flags,
537 struct dom_sid *psid,
538 enum lsa_SidType *ptype)
539{
540 struct rpc_pipe_client *lsa_pipe;
541 struct policy_handle lsa_policy;
542 struct dom_sid sid;
543 enum lsa_SidType type;
544 TALLOC_CTX *tmp_ctx;
545 NTSTATUS status, result;
546 struct dcerpc_binding_handle *b = NULL;
547
548 DEBUG(3,("sam_name_to_sid\n"));
549
550 ZERO_STRUCT(lsa_policy);
551
552 tmp_ctx = talloc_stackframe();
553 if (tmp_ctx == NULL) {
554 return NT_STATUS_NO_MEMORY;
555 }
556
557 status = open_internal_lsa_conn(tmp_ctx, &lsa_pipe, &lsa_policy);
558 if (!NT_STATUS_IS_OK(status)) {
559 goto done;
560 }
561
562 b = lsa_pipe->binding_handle;
563
564 status = rpc_name_to_sid(tmp_ctx,
565 lsa_pipe,
566 &lsa_policy,
567 domain_name,
568 name,
569 flags,
570 &sid,
571 &type);
572 if (!NT_STATUS_IS_OK(status)) {
573 goto done;
574 }
575
576 if (psid) {
577 sid_copy(psid, &sid);
578 }
579 if (ptype) {
580 *ptype = type;
581 }
582
583done:
584 if (b && is_valid_policy_hnd(&lsa_policy)) {
585 dcerpc_lsa_Close(b, mem_ctx, &lsa_policy, &result);
586 }
587
588 TALLOC_FREE(tmp_ctx);
589 return status;
590}
591
592/* convert a domain SID to a user or group name */
593static NTSTATUS sam_sid_to_name(struct winbindd_domain *domain,
594 TALLOC_CTX *mem_ctx,
595 const struct dom_sid *sid,
596 char **pdomain_name,
597 char **pname,
598 enum lsa_SidType *ptype)
599{
600 struct rpc_pipe_client *lsa_pipe;
601 struct policy_handle lsa_policy;
602 char *domain_name = NULL;
603 char *name = NULL;
604 enum lsa_SidType type;
605 TALLOC_CTX *tmp_ctx;
606 NTSTATUS status, result;
607 struct dcerpc_binding_handle *b = NULL;
608
609 DEBUG(3,("sam_sid_to_name\n"));
610
611 ZERO_STRUCT(lsa_policy);
612
613 /* Paranoia check */
614 if (!sid_check_is_in_builtin(sid) &&
615 !sid_check_is_builtin(sid) &&
616 !sid_check_is_in_our_sam(sid) &&
617 !sid_check_is_our_sam(sid) &&
618 !sid_check_is_in_unix_users(sid) &&
619 !sid_check_is_unix_users(sid) &&
620 !sid_check_is_in_unix_groups(sid) &&
621 !sid_check_is_unix_groups(sid) &&
622 !sid_check_is_in_wellknown_domain(sid)) {
623 DEBUG(0, ("sam_sid_to_name: possible deadlock - trying to "
624 "lookup SID %s\n", sid_string_dbg(sid)));
625 return NT_STATUS_NONE_MAPPED;
626 }
627
628 tmp_ctx = talloc_stackframe();
629 if (tmp_ctx == NULL) {
630 return NT_STATUS_NO_MEMORY;
631 }
632
633 status = open_internal_lsa_conn(tmp_ctx, &lsa_pipe, &lsa_policy);
634 if (!NT_STATUS_IS_OK(status)) {
635 goto done;
636 }
637
638 b = lsa_pipe->binding_handle;
639
640 status = rpc_sid_to_name(tmp_ctx,
641 lsa_pipe,
642 &lsa_policy,
643 domain,
644 sid,
645 &domain_name,
646 &name,
647 &type);
648
649 if (ptype) {
650 *ptype = type;
651 }
652
653 if (pname) {
654 *pname = talloc_move(mem_ctx, &name);
655 }
656
657 if (pdomain_name) {
658 *pdomain_name = talloc_move(mem_ctx, &domain_name);
659 }
660
661done:
662 if (b && is_valid_policy_hnd(&lsa_policy)) {
663 dcerpc_lsa_Close(b, mem_ctx, &lsa_policy, &result);
664 }
665
666 TALLOC_FREE(tmp_ctx);
667 return status;
668}
669
670static NTSTATUS sam_rids_to_names(struct winbindd_domain *domain,
671 TALLOC_CTX *mem_ctx,
672 const struct dom_sid *domain_sid,
673 uint32_t *rids,
674 size_t num_rids,
675 char **pdomain_name,
676 char ***pnames,
677 enum lsa_SidType **ptypes)
678{
679 struct rpc_pipe_client *lsa_pipe;
680 struct policy_handle lsa_policy;
681 enum lsa_SidType *types = NULL;
682 char *domain_name = NULL;
683 char **names = NULL;
684 TALLOC_CTX *tmp_ctx;
685 NTSTATUS status, result;
686 struct dcerpc_binding_handle *b = NULL;
687
688 DEBUG(3,("sam_rids_to_names for %s\n", domain->name));
689
690 ZERO_STRUCT(lsa_policy);
691
692 /* Paranoia check */
693 if (!sid_check_is_builtin(domain_sid) &&
694 !sid_check_is_our_sam(domain_sid) &&
695 !sid_check_is_unix_users(domain_sid) &&
696 !sid_check_is_unix_groups(domain_sid) &&
697 !sid_check_is_in_wellknown_domain(domain_sid)) {
698 DEBUG(0, ("sam_rids_to_names: possible deadlock - trying to "
699 "lookup SID %s\n", sid_string_dbg(domain_sid)));
700 return NT_STATUS_NONE_MAPPED;
701 }
702
703 tmp_ctx = talloc_stackframe();
704 if (tmp_ctx == NULL) {
705 return NT_STATUS_NO_MEMORY;
706 }
707
708 status = open_internal_lsa_conn(tmp_ctx, &lsa_pipe, &lsa_policy);
709 if (!NT_STATUS_IS_OK(status)) {
710 goto done;
711 }
712
713 b = lsa_pipe->binding_handle;
714
715 status = rpc_rids_to_names(tmp_ctx,
716 lsa_pipe,
717 &lsa_policy,
718 domain,
719 domain_sid,
720 rids,
721 num_rids,
722 &domain_name,
723 &names,
724 &types);
725 if (!NT_STATUS_IS_OK(status)) {
726 goto done;
727 }
728
729 if (pdomain_name) {
730 *pdomain_name = talloc_move(mem_ctx, &domain_name);
731 }
732
733 if (ptypes) {
734 *ptypes = talloc_move(mem_ctx, &types);
735 }
736
737 if (pnames) {
738 *pnames = talloc_move(mem_ctx, &names);
739 }
740
741done:
742 if (b && is_valid_policy_hnd(&lsa_policy)) {
743 dcerpc_lsa_Close(b, mem_ctx, &lsa_policy, &result);
744 }
745
746 TALLOC_FREE(tmp_ctx);
747 return status;
748}
749
750static NTSTATUS sam_lockout_policy(struct winbindd_domain *domain,
751 TALLOC_CTX *mem_ctx,
752 struct samr_DomInfo12 *lockout_policy)
753{
754 struct rpc_pipe_client *samr_pipe;
755 struct policy_handle dom_pol;
756 union samr_DomainInfo *info = NULL;
757 TALLOC_CTX *tmp_ctx;
758 NTSTATUS status, result;
759 struct dcerpc_binding_handle *b = NULL;
760
761 DEBUG(3,("sam_lockout_policy\n"));
762
763 ZERO_STRUCT(dom_pol);
764
765 tmp_ctx = talloc_stackframe();
766 if (tmp_ctx == NULL) {
767 return NT_STATUS_NO_MEMORY;
768 }
769
770 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
771 if (!NT_STATUS_IS_OK(status)) {
772 goto error;
773 }
774
775 b = samr_pipe->binding_handle;
776
777 status = dcerpc_samr_QueryDomainInfo(b,
778 mem_ctx,
779 &dom_pol,
780 DomainLockoutInformation,
781 &info,
782 &result);
783 if (!NT_STATUS_IS_OK(status)) {
784 goto error;
785 }
786 if (!NT_STATUS_IS_OK(result)) {
787 status = result;
788 goto error;
789 }
790
791 *lockout_policy = info->info12;
792
793error:
794 if (b && is_valid_policy_hnd(&dom_pol)) {
795 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
796 }
797
798 TALLOC_FREE(tmp_ctx);
799 return status;
800}
801
802static NTSTATUS sam_password_policy(struct winbindd_domain *domain,
803 TALLOC_CTX *mem_ctx,
804 struct samr_DomInfo1 *passwd_policy)
805{
806 struct rpc_pipe_client *samr_pipe;
807 struct policy_handle dom_pol;
808 union samr_DomainInfo *info = NULL;
809 TALLOC_CTX *tmp_ctx;
810 NTSTATUS status, result;
811 struct dcerpc_binding_handle *b = NULL;
812
813 DEBUG(3,("sam_password_policy\n"));
814
815 ZERO_STRUCT(dom_pol);
816
817 tmp_ctx = talloc_stackframe();
818 if (tmp_ctx == NULL) {
819 return NT_STATUS_NO_MEMORY;
820 }
821
822 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
823 if (!NT_STATUS_IS_OK(status)) {
824 goto error;
825 }
826
827 b = samr_pipe->binding_handle;
828
829 status = dcerpc_samr_QueryDomainInfo(b,
830 mem_ctx,
831 &dom_pol,
832 DomainPasswordInformation,
833 &info,
834 &result);
835 if (!NT_STATUS_IS_OK(status)) {
836 goto error;
837 }
838 if (!NT_STATUS_IS_OK(result)) {
839 status = result;
840 goto error;
841 }
842
843 *passwd_policy = info->info1;
844
845error:
846 if (b && is_valid_policy_hnd(&dom_pol)) {
847 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
848 }
849
850 TALLOC_FREE(tmp_ctx);
851 return status;
852}
853
854/* Lookup groups a user is a member of. */
855static NTSTATUS sam_lookup_usergroups(struct winbindd_domain *domain,
856 TALLOC_CTX *mem_ctx,
857 const struct dom_sid *user_sid,
858 uint32_t *pnum_groups,
859 struct dom_sid **puser_grpsids)
860{
861 struct rpc_pipe_client *samr_pipe;
862 struct policy_handle dom_pol;
863 struct dom_sid *user_grpsids = NULL;
864 uint32_t num_groups = 0;
865 TALLOC_CTX *tmp_ctx;
866 NTSTATUS status, result;
867 struct dcerpc_binding_handle *b = NULL;
868
869 DEBUG(3,("sam_lookup_usergroups\n"));
870
871 ZERO_STRUCT(dom_pol);
872
873 if (pnum_groups) {
874 *pnum_groups = 0;
875 }
876
877 tmp_ctx = talloc_stackframe();
878 if (tmp_ctx == NULL) {
879 return NT_STATUS_NO_MEMORY;
880 }
881
882 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
883 if (!NT_STATUS_IS_OK(status)) {
884 goto done;
885 }
886
887 b = samr_pipe->binding_handle;
888
889 status = rpc_lookup_usergroups(tmp_ctx,
890 samr_pipe,
891 &dom_pol,
892 &domain->sid,
893 user_sid,
894 &num_groups,
895 &user_grpsids);
896 if (!NT_STATUS_IS_OK(status)) {
897 goto done;
898 }
899
900 if (pnum_groups) {
901 *pnum_groups = num_groups;
902 }
903
904 if (puser_grpsids) {
905 *puser_grpsids = talloc_move(mem_ctx, &user_grpsids);
906 }
907
908done:
909 if (b && is_valid_policy_hnd(&dom_pol)) {
910 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
911 }
912
913 TALLOC_FREE(tmp_ctx);
914 return status;
915}
916
917static NTSTATUS sam_lookup_useraliases(struct winbindd_domain *domain,
918 TALLOC_CTX *mem_ctx,
919 uint32_t num_sids,
920 const struct dom_sid *sids,
921 uint32_t *pnum_aliases,
922 uint32_t **palias_rids)
923{
924 struct rpc_pipe_client *samr_pipe;
925 struct policy_handle dom_pol;
926 uint32_t num_aliases = 0;
927 uint32_t *alias_rids = NULL;
928 TALLOC_CTX *tmp_ctx;
929 NTSTATUS status, result;
930 struct dcerpc_binding_handle *b = NULL;
931
932 DEBUG(3,("sam_lookup_useraliases\n"));
933
934 ZERO_STRUCT(dom_pol);
935
936 if (pnum_aliases) {
937 *pnum_aliases = 0;
938 }
939
940 tmp_ctx = talloc_stackframe();
941 if (tmp_ctx == NULL) {
942 return NT_STATUS_NO_MEMORY;
943 }
944
945 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
946 if (!NT_STATUS_IS_OK(status)) {
947 goto done;
948 }
949
950 b = samr_pipe->binding_handle;
951
952 status = rpc_lookup_useraliases(tmp_ctx,
953 samr_pipe,
954 &dom_pol,
955 num_sids,
956 sids,
957 &num_aliases,
958 &alias_rids);
959 if (!NT_STATUS_IS_OK(status)) {
960 goto done;
961 }
962
963 if (pnum_aliases) {
964 *pnum_aliases = num_aliases;
965 }
966
967 if (palias_rids) {
968 *palias_rids = talloc_move(mem_ctx, &alias_rids);
969 }
970
971done:
972 if (b && is_valid_policy_hnd(&dom_pol)) {
973 dcerpc_samr_Close(b, mem_ctx, &dom_pol, &result);
974 }
975
976 TALLOC_FREE(tmp_ctx);
977 return status;
978}
979
980/* find the sequence number for a domain */
981static NTSTATUS sam_sequence_number(struct winbindd_domain *domain,
982 uint32_t *pseq)
983{
984 struct rpc_pipe_client *samr_pipe;
985 struct policy_handle dom_pol;
986 uint32_t seq = DOM_SEQUENCE_NONE;
987 TALLOC_CTX *tmp_ctx;
988 NTSTATUS status, result;
989 struct dcerpc_binding_handle *b = NULL;
990
991 DEBUG(3,("samr: sequence number\n"));
992
993 ZERO_STRUCT(dom_pol);
994
995 if (pseq) {
996 *pseq = DOM_SEQUENCE_NONE;
997 }
998
999 tmp_ctx = talloc_stackframe();
1000 if (tmp_ctx == NULL) {
1001 return NT_STATUS_NO_MEMORY;
1002 }
1003
1004 status = open_internal_samr_conn(tmp_ctx, domain, &samr_pipe, &dom_pol);
1005 if (!NT_STATUS_IS_OK(status)) {
1006 goto done;
1007 }
1008
1009 b = samr_pipe->binding_handle;
1010
1011 status = rpc_sequence_number(tmp_ctx,
1012 samr_pipe,
1013 &dom_pol,
1014 domain->name,
1015 &seq);
1016 if (!NT_STATUS_IS_OK(status)) {
1017 goto done;
1018 }
1019
1020 if (pseq) {
1021 *pseq = seq;
1022 }
1023done:
1024 if (b && is_valid_policy_hnd(&dom_pol)) {
1025 dcerpc_samr_Close(b, tmp_ctx, &dom_pol, &result);
1026 }
1027
1028 TALLOC_FREE(tmp_ctx);
1029 return status;
1030}
1031
1032/* the rpc backend methods are exposed via this structure */
1033struct winbindd_methods builtin_passdb_methods = {
1034 .consistent = false,
1035
1036 .query_user_list = builtin_query_user_list,
1037 .enum_dom_groups = builtin_enum_dom_groups,
1038 .enum_local_groups = sam_enum_local_groups,
1039 .name_to_sid = sam_name_to_sid,
1040 .sid_to_name = sam_sid_to_name,
1041 .rids_to_names = sam_rids_to_names,
1042 .query_user = builtin_query_user,
1043 .lookup_usergroups = sam_lookup_usergroups,
1044 .lookup_useraliases = sam_lookup_useraliases,
1045 .lookup_groupmem = sam_lookup_groupmem,
1046 .sequence_number = sam_sequence_number,
1047 .lockout_policy = sam_lockout_policy,
1048 .password_policy = sam_password_policy,
1049 .trusted_domains = builtin_trusted_domains
1050};
1051
1052/* the rpc backend methods are exposed via this structure */
1053struct winbindd_methods sam_passdb_methods = {
1054 .consistent = false,
1055
1056 .query_user_list = sam_query_user_list,
1057 .enum_dom_groups = sam_enum_dom_groups,
1058 .enum_local_groups = sam_enum_local_groups,
1059 .name_to_sid = sam_name_to_sid,
1060 .sid_to_name = sam_sid_to_name,
1061 .rids_to_names = sam_rids_to_names,
1062 .query_user = sam_query_user,
1063 .lookup_usergroups = sam_lookup_usergroups,
1064 .lookup_useraliases = sam_lookup_useraliases,
1065 .lookup_groupmem = sam_lookup_groupmem,
1066 .sequence_number = sam_sequence_number,
1067 .lockout_policy = sam_lockout_policy,
1068 .password_policy = sam_password_policy,
1069 .trusted_domains = sam_trusted_domains
1070};
Note: See TracBrowser for help on using the repository browser.