?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Revert "Fix bug #7067 - Linux asynchronous IO (aio) can cause smbd to fail to respond...
[Samba.git] / source3 / rpc_server / srv_lsa_nt.c
blobe903f0e974e3502a5b1797c771ebb576631eccbe
1 /*
2 * Unix SMB/CIFS implementation.
3 * RPC Pipe client / server routines
4 * Copyright (C) Andrew Tridgell 1992-1997,
5 * Copyright (C) Luke Kenneth Casson Leighton 1996-1997,
6 * Copyright (C) Paul Ashton 1997,
7 * Copyright (C) Jeremy Allison 2001, 2006.
8 * Copyright (C) Rafal Szczesniak 2002,
9 * Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002,
10 * Copyright (C) Simo Sorce 2003.
11 * Copyright (C) Gerald (Jerry) Carter 2005.
12 * Copyright (C) Volker Lendecke 2005.
13 * Copyright (C) Guenther Deschner 2008.
14 *
15 * This program is free software; you can redistribute it and/or modify
16 * it under the terms of the GNU General Public License as published by
17 * the Free Software Foundation; either version 3 of the License, or
18 * (at your option) any later version.
19 *
20 * This program is distributed in the hope that it will be useful,
21 * but WITHOUT ANY WARRANTY; without even the implied warranty of
22 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
23 * GNU General Public License for more details.
24 *
25 * You should have received a copy of the GNU General Public License
26 * along with this program; if not, see <http://www.gnu.org/licenses/>.
27 */
28
29 /* This is the implementation of the lsa server code. */
30
31 #include "includes.h"
32 #include "../librpc/gen_ndr/srv_lsa.h"
33
34 #undef DBGC_CLASS
35 #define DBGC_CLASS DBGC_RPC_SRV
36
37 #define MAX_LOOKUP_SIDS 0x5000 /* 20480 */
38
39 extern PRIVS privs[];
40
41 enum lsa_handle_type { LSA_HANDLE_POLICY_TYPE = 1, LSA_HANDLE_ACCOUNT_TYPE };
42
43 struct lsa_info {
44 DOM_SID sid;
45 const char *name;
46 uint32 access;
47 enum lsa_handle_type type;
48 struct security_descriptor *sd;
49 };
50
51 const struct generic_mapping lsa_account_mapping = {
52 LSA_ACCOUNT_READ,
53 LSA_ACCOUNT_WRITE,
54 LSA_ACCOUNT_EXECUTE,
55 LSA_ACCOUNT_ALL_ACCESS
56 };
57
58 const struct generic_mapping lsa_policy_mapping = {
59 LSA_POLICY_READ,
60 LSA_POLICY_WRITE,
61 LSA_POLICY_EXECUTE,
62 LSA_POLICY_ALL_ACCESS
63 };
64
65 const struct generic_mapping lsa_secret_mapping = {
66 LSA_SECRET_READ,
67 LSA_SECRET_WRITE,
68 LSA_SECRET_EXECUTE,
69 LSA_SECRET_ALL_ACCESS
70 };
71
72 const struct generic_mapping lsa_trusted_domain_mapping = {
73 LSA_TRUSTED_DOMAIN_READ,
74 LSA_TRUSTED_DOMAIN_WRITE,
75 LSA_TRUSTED_DOMAIN_EXECUTE,
76 LSA_TRUSTED_DOMAIN_ALL_ACCESS
77 };
78
79 /***************************************************************************
80 init_lsa_ref_domain_list - adds a domain if it's not already in, returns the index.
81 ***************************************************************************/
82
83 static int init_lsa_ref_domain_list(TALLOC_CTX *mem_ctx,
84 struct lsa_RefDomainList *ref,
85 const char *dom_name,
86 DOM_SID *dom_sid)
87 {
88 int num = 0;
89
90 if (dom_name != NULL) {
91 for (num = 0; num < ref->count; num++) {
92 if (sid_equal(dom_sid, ref->domains[num].sid)) {
93 return num;
94 }
95 }
96 } else {
97 num = ref->count;
98 }
99
100 if (num >= LSA_REF_DOMAIN_LIST_MULTIPLIER) {
101 /* index not found, already at maximum domain limit */
102 return -1;
103 }
104
105 ref->count = num + 1;
106 ref->max_size = LSA_REF_DOMAIN_LIST_MULTIPLIER;
107
108 ref->domains = TALLOC_REALLOC_ARRAY(mem_ctx, ref->domains,
109 struct lsa_DomainInfo, ref->count);
110 if (!ref->domains) {
111 return -1;
112 }
113
114 ZERO_STRUCT(ref->domains[num]);
115
116 init_lsa_StringLarge(&ref->domains[num].name, dom_name);
117 ref->domains[num].sid = sid_dup_talloc(mem_ctx, dom_sid);
118 if (!ref->domains[num].sid) {
119 return -1;
120 }
121
122 return num;
123 }
124
125
126 /***************************************************************************
127 initialize a lsa_DomainInfo structure.
128 ***************************************************************************/
129
130 static void init_dom_query_3(struct lsa_DomainInfo *r,
131 const char *name,
132 DOM_SID *sid)
133 {
134 init_lsa_StringLarge(&r->name, name);
135 r->sid = sid;
136 }
137
138 /***************************************************************************
139 initialize a lsa_DomainInfo structure.
140 ***************************************************************************/
141
142 static void init_dom_query_5(struct lsa_DomainInfo *r,
143 const char *name,
144 DOM_SID *sid)
145 {
146 init_lsa_StringLarge(&r->name, name);
147 r->sid = sid;
148 }
149
150 /***************************************************************************
151 lookup_lsa_rids. Must be called as root for lookup_name to work.
152 ***************************************************************************/
153
154 static NTSTATUS lookup_lsa_rids(TALLOC_CTX *mem_ctx,
155 struct lsa_RefDomainList *ref,
156 struct lsa_TranslatedSid *prid,
157 uint32_t num_entries,
158 struct lsa_String *name,
159 int flags,
160 uint32_t *pmapped_count)
161 {
162 uint32 mapped_count, i;
163
164 SMB_ASSERT(num_entries <= MAX_LOOKUP_SIDS);
165
166 mapped_count = 0;
167 *pmapped_count = 0;
168
169 for (i = 0; i < num_entries; i++) {
170 DOM_SID sid;
171 uint32 rid;
172 int dom_idx;
173 const char *full_name;
174 const char *domain;
175 enum lsa_SidType type = SID_NAME_UNKNOWN;
176
177 /* Split name into domain and user component */
178
179 /* follow w2k8 behavior and return the builtin domain when no
180 * input has been passed in */
181
182 if (name[i].string) {
183 full_name = name[i].string;
184 } else {
185 full_name = "BUILTIN";
186 }
187
188 DEBUG(5, ("lookup_lsa_rids: looking up name %s\n", full_name));
189
190 /* We can ignore the result of lookup_name, it will not touch
191 "type" if it's not successful */
192
193 lookup_name(mem_ctx, full_name, flags, &domain, NULL,
194 &sid, &type);
195
196 switch (type) {
197 case SID_NAME_USER:
198 case SID_NAME_DOM_GRP:
199 case SID_NAME_DOMAIN:
200 case SID_NAME_ALIAS:
201 case SID_NAME_WKN_GRP:
202 DEBUG(5, ("init_lsa_rids: %s found\n", full_name));
203 /* Leave these unchanged */
204 break;
205 default:
206 /* Don't hand out anything but the list above */
207 DEBUG(5, ("init_lsa_rids: %s not found\n", full_name));
208 type = SID_NAME_UNKNOWN;
209 break;
210 }
211
212 rid = 0;
213 dom_idx = -1;
214
215 if (type != SID_NAME_UNKNOWN) {
216 if (type == SID_NAME_DOMAIN) {
217 rid = (uint32_t)-1;
218 } else {
219 sid_split_rid(&sid, &rid);
220 }
221 dom_idx = init_lsa_ref_domain_list(mem_ctx, ref, domain, &sid);
222 mapped_count++;
223 }
224
225 prid[i].sid_type = type;
226 prid[i].rid = rid;
227 prid[i].sid_index = dom_idx;
228 }
229
230 *pmapped_count = mapped_count;
231 return NT_STATUS_OK;
232 }
233
234 /***************************************************************************
235 lookup_lsa_sids. Must be called as root for lookup_name to work.
236 ***************************************************************************/
237
238 static NTSTATUS lookup_lsa_sids(TALLOC_CTX *mem_ctx,
239 struct lsa_RefDomainList *ref,
240 struct lsa_TranslatedSid3 *trans_sids,
241 uint32_t num_entries,
242 struct lsa_String *name,
243 int flags,
244 uint32 *pmapped_count)
245 {
246 uint32 mapped_count, i;
247
248 SMB_ASSERT(num_entries <= MAX_LOOKUP_SIDS);
249
250 mapped_count = 0;
251 *pmapped_count = 0;
252
253 for (i = 0; i < num_entries; i++) {
254 DOM_SID sid;
255 uint32 rid;
256 int dom_idx;
257 const char *full_name;
258 const char *domain;
259 enum lsa_SidType type = SID_NAME_UNKNOWN;
260
261 ZERO_STRUCT(sid);
262
263 /* Split name into domain and user component */
264
265 full_name = name[i].string;
266 if (full_name == NULL) {
267 return NT_STATUS_NO_MEMORY;
268 }
269
270 DEBUG(5, ("init_lsa_sids: looking up name %s\n", full_name));
271
272 /* We can ignore the result of lookup_name, it will not touch
273 "type" if it's not successful */
274
275 lookup_name(mem_ctx, full_name, flags, &domain, NULL,
276 &sid, &type);
277
278 switch (type) {
279 case SID_NAME_USER:
280 case SID_NAME_DOM_GRP:
281 case SID_NAME_DOMAIN:
282 case SID_NAME_ALIAS:
283 case SID_NAME_WKN_GRP:
284 DEBUG(5, ("init_lsa_sids: %s found\n", full_name));
285 /* Leave these unchanged */
286 break;
287 default:
288 /* Don't hand out anything but the list above */
289 DEBUG(5, ("init_lsa_sids: %s not found\n", full_name));
290 type = SID_NAME_UNKNOWN;
291 break;
292 }
293
294 rid = 0;
295 dom_idx = -1;
296
297 if (type != SID_NAME_UNKNOWN) {
298 DOM_SID domain_sid;
299 sid_copy(&domain_sid, &sid);
300 sid_split_rid(&domain_sid, &rid);
301 dom_idx = init_lsa_ref_domain_list(mem_ctx, ref, domain, &domain_sid);
302 mapped_count++;
303 }
304
305 /* Initialize the lsa_TranslatedSid3 return. */
306 trans_sids[i].sid_type = type;
307 trans_sids[i].sid = sid_dup_talloc(mem_ctx, &sid);
308 trans_sids[i].sid_index = dom_idx;
309 }
310
311 *pmapped_count = mapped_count;
312 return NT_STATUS_OK;
313 }
314
315 static NTSTATUS make_lsa_object_sd(TALLOC_CTX *mem_ctx, SEC_DESC **sd, size_t *sd_size,
316 const struct generic_mapping *map,
317 DOM_SID *sid, uint32_t sid_access)
318 {
319 DOM_SID adm_sid;
320 SEC_ACE ace[5];
321 size_t i = 0;
322
323 SEC_ACL *psa = NULL;
324
325 /* READ|EXECUTE access for Everyone */
326
327 init_sec_ace(&ace[i++], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED,
328 map->generic_execute | map->generic_read, 0);
329
330 /* Add Full Access 'BUILTIN\Administrators' and 'BUILTIN\Account Operators */
331
332 init_sec_ace(&ace[i++], &global_sid_Builtin_Administrators,
333 SEC_ACE_TYPE_ACCESS_ALLOWED, map->generic_all, 0);
334 init_sec_ace(&ace[i++], &global_sid_Builtin_Account_Operators,
335 SEC_ACE_TYPE_ACCESS_ALLOWED, map->generic_all, 0);
336
337 /* Add Full Access for Domain Admins */
338 sid_copy(&adm_sid, get_global_sam_sid());
339 sid_append_rid(&adm_sid, DOMAIN_GROUP_RID_ADMINS);
340 init_sec_ace(&ace[i++], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
341 map->generic_all, 0);
342
343 /* If we have a sid, give it some special access */
344
345 if (sid) {
346 init_sec_ace(&ace[i++], sid, SEC_ACE_TYPE_ACCESS_ALLOWED,
347 sid_access, 0);
348 }
349
350 if((psa = make_sec_acl(mem_ctx, NT4_ACL_REVISION, i, ace)) == NULL)
351 return NT_STATUS_NO_MEMORY;
352
353 if((*sd = make_sec_desc(mem_ctx, SECURITY_DESCRIPTOR_REVISION_1,
354 SEC_DESC_SELF_RELATIVE, &adm_sid, NULL, NULL,
355 psa, sd_size)) == NULL)
356 return NT_STATUS_NO_MEMORY;
357
358 return NT_STATUS_OK;
359 }
360
361
362 /***************************************************************************
363 _lsa_OpenPolicy2
364 ***************************************************************************/
365
366 NTSTATUS _lsa_OpenPolicy2(pipes_struct *p,
367 struct lsa_OpenPolicy2 *r)
368 {
369 struct lsa_info *info;
370 SEC_DESC *psd = NULL;
371 size_t sd_size;
372 uint32 des_access = r->in.access_mask;
373 uint32 acc_granted;
374 NTSTATUS status;
375
376 /* Work out max allowed. */
377 map_max_allowed_access(p->server_info->ptok,
378 &p->server_info->utok,
379 &des_access);
380
381 /* map the generic bits to the lsa policy ones */
382 se_map_generic(&des_access, &lsa_policy_mapping);
383
384 /* get the generic lsa policy SD until we store it */
385 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size, &lsa_policy_mapping,
386 NULL, 0);
387 if (!NT_STATUS_IS_OK(status)) {
388 return status;
389 }
390
391 status = access_check_object(psd, p->server_info->ptok,
392 NULL, 0, des_access,
393 &acc_granted, "_lsa_OpenPolicy2" );
394 if (!NT_STATUS_IS_OK(status)) {
395 return status;
396 }
397
398 /* associate the domain SID with the (unique) handle. */
399 info = TALLOC_ZERO_P(p->mem_ctx, struct lsa_info);
400 if (info == NULL) {
401 return NT_STATUS_NO_MEMORY;
402 }
403
404 sid_copy(&info->sid,get_global_sam_sid());
405 info->access = acc_granted;
406 info->type = LSA_HANDLE_POLICY_TYPE;
407
408 /* set up the LSA QUERY INFO response */
409 if (!create_policy_hnd(p, r->out.handle, info))
410 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
411
412 return NT_STATUS_OK;
413 }
414
415 /***************************************************************************
416 _lsa_OpenPolicy
417 ***************************************************************************/
418
419 NTSTATUS _lsa_OpenPolicy(pipes_struct *p,
420 struct lsa_OpenPolicy *r)
421 {
422 struct lsa_OpenPolicy2 o;
423
424 o.in.system_name = NULL; /* should be ignored */
425 o.in.attr = r->in.attr;
426 o.in.access_mask = r->in.access_mask;
427
428 o.out.handle = r->out.handle;
429
430 return _lsa_OpenPolicy2(p, &o);
431 }
432
433 /***************************************************************************
434 _lsa_EnumTrustDom - this needs fixing to do more than return NULL ! JRA.
435 ufff, done :) mimir
436 ***************************************************************************/
437
438 NTSTATUS _lsa_EnumTrustDom(pipes_struct *p,
439 struct lsa_EnumTrustDom *r)
440 {
441 struct lsa_info *info;
442 uint32_t count;
443 struct trustdom_info **domains;
444 struct lsa_DomainInfo *entries;
445 int i;
446 NTSTATUS nt_status;
447
448 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
449 return NT_STATUS_INVALID_HANDLE;
450
451 if (info->type != LSA_HANDLE_POLICY_TYPE) {
452 return NT_STATUS_INVALID_HANDLE;
453 }
454
455 /* check if the user has enough rights */
456 if (!(info->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
457 return NT_STATUS_ACCESS_DENIED;
458
459 become_root();
460 nt_status = pdb_enum_trusteddoms(p->mem_ctx, &count, &domains);
461 unbecome_root();
462
463 if (!NT_STATUS_IS_OK(nt_status)) {
464 return nt_status;
465 }
466
467 entries = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_DomainInfo, count);
468 if (!entries) {
469 return NT_STATUS_NO_MEMORY;
470 }
471
472 for (i=0; i<count; i++) {
473 init_lsa_StringLarge(&entries[i].name, domains[i]->name);
474 entries[i].sid = &domains[i]->sid;
475 }
476
477 if (*r->in.resume_handle >= count) {
478 *r->out.resume_handle = -1;
479 TALLOC_FREE(entries);
480 return NT_STATUS_NO_MORE_ENTRIES;
481 }
482
483 /* return the rest, limit by max_size. Note that we
484 use the w2k3 element size value of 60 */
485 r->out.domains->count = count - *r->in.resume_handle;
486 r->out.domains->count = MIN(r->out.domains->count,
487 1+(r->in.max_size/LSA_ENUM_TRUST_DOMAIN_MULTIPLIER));
488
489 r->out.domains->domains = entries + *r->in.resume_handle;
490
491 if (r->out.domains->count < count - *r->in.resume_handle) {
492 *r->out.resume_handle = *r->in.resume_handle + r->out.domains->count;
493 return STATUS_MORE_ENTRIES;
494 }
495
496 /* according to MS-LSAD 3.1.4.7.8 output resume handle MUST
497 * always be larger than the previous input resume handle, in
498 * particular when hitting the last query it is vital to set the
499 * resume handle correctly to avoid infinite client loops, as
500 * seen e.g. with Windows XP SP3 when resume handle is 0 and
501 * status is NT_STATUS_OK - gd */
502
503 *r->out.resume_handle = (uint32_t)-1;
504
505 return NT_STATUS_OK;
506 }
507
508 #define LSA_AUDIT_NUM_CATEGORIES_NT4 7
509 #define LSA_AUDIT_NUM_CATEGORIES_WIN2K 9
510 #define LSA_AUDIT_NUM_CATEGORIES LSA_AUDIT_NUM_CATEGORIES_NT4
511
512 /***************************************************************************
513 _lsa_QueryInfoPolicy
514 ***************************************************************************/
515
516 NTSTATUS _lsa_QueryInfoPolicy(pipes_struct *p,
517 struct lsa_QueryInfoPolicy *r)
518 {
519 NTSTATUS status = NT_STATUS_OK;
520 struct lsa_info *handle;
521 DOM_SID domain_sid;
522 const char *name;
523 DOM_SID *sid = NULL;
524 union lsa_PolicyInformation *info = NULL;
525 uint32_t acc_required = 0;
526
527 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
528 return NT_STATUS_INVALID_HANDLE;
529
530 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
531 return NT_STATUS_INVALID_HANDLE;
532 }
533
534 switch (r->in.level) {
535 case LSA_POLICY_INFO_AUDIT_LOG:
536 case LSA_POLICY_INFO_AUDIT_EVENTS:
537 acc_required = LSA_POLICY_VIEW_AUDIT_INFORMATION;
538 break;
539 case LSA_POLICY_INFO_DOMAIN:
540 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
541 break;
542 case LSA_POLICY_INFO_PD:
543 acc_required = LSA_POLICY_GET_PRIVATE_INFORMATION;
544 break;
545 case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
546 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
547 break;
548 case LSA_POLICY_INFO_ROLE:
549 case LSA_POLICY_INFO_REPLICA:
550 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
551 break;
552 case LSA_POLICY_INFO_QUOTA:
553 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
554 break;
555 case LSA_POLICY_INFO_MOD:
556 case LSA_POLICY_INFO_AUDIT_FULL_SET:
557 /* according to MS-LSAD 3.1.4.4.3 */
558 return NT_STATUS_INVALID_PARAMETER;
559 case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
560 acc_required = LSA_POLICY_VIEW_AUDIT_INFORMATION;
561 break;
562 case LSA_POLICY_INFO_DNS:
563 case LSA_POLICY_INFO_DNS_INT:
564 case LSA_POLICY_INFO_L_ACCOUNT_DOMAIN:
565 acc_required = LSA_POLICY_VIEW_LOCAL_INFORMATION;
566 break;
567 default:
568 break;
569 }
570
571 if (!(handle->access & acc_required)) {
572 /* return NT_STATUS_ACCESS_DENIED; */
573 }
574
575 info = TALLOC_ZERO_P(p->mem_ctx, union lsa_PolicyInformation);
576 if (!info) {
577 return NT_STATUS_NO_MEMORY;
578 }
579
580 switch (r->in.level) {
581 /* according to MS-LSAD 3.1.4.4.3 */
582 case LSA_POLICY_INFO_MOD:
583 case LSA_POLICY_INFO_AUDIT_FULL_SET:
584 case LSA_POLICY_INFO_AUDIT_FULL_QUERY:
585 return NT_STATUS_INVALID_PARAMETER;
586 case LSA_POLICY_INFO_AUDIT_LOG:
587 info->audit_log.percent_full = 0;
588 info->audit_log.maximum_log_size = 0;
589 info->audit_log.retention_time = 0;
590 info->audit_log.shutdown_in_progress = 0;
591 info->audit_log.time_to_shutdown = 0;
592 info->audit_log.next_audit_record = 0;
593 status = NT_STATUS_OK;
594 break;
595 case LSA_POLICY_INFO_PD:
596 info->pd.name.string = NULL;
597 status = NT_STATUS_OK;
598 break;
599 case LSA_POLICY_INFO_REPLICA:
600 info->replica.source.string = NULL;
601 info->replica.account.string = NULL;
602 status = NT_STATUS_OK;
603 break;
604 case LSA_POLICY_INFO_QUOTA:
605 info->quota.paged_pool = 0;
606 info->quota.non_paged_pool = 0;
607 info->quota.min_wss = 0;
608 info->quota.max_wss = 0;
609 info->quota.pagefile = 0;
610 info->quota.unknown = 0;
611 status = NT_STATUS_OK;
612 break;
613 case LSA_POLICY_INFO_AUDIT_EVENTS:
614 {
615
616 uint32 policy_def = LSA_AUDIT_POLICY_ALL;
617
618 /* check if the user has enough rights */
619 if (!(handle->access & LSA_POLICY_VIEW_AUDIT_INFORMATION)) {
620 DEBUG(10,("_lsa_QueryInfoPolicy: insufficient access rights\n"));
621 return NT_STATUS_ACCESS_DENIED;
622 }
623
624 /* fake info: We audit everything. ;) */
625
626 info->audit_events.auditing_mode = true;
627 info->audit_events.count = LSA_AUDIT_NUM_CATEGORIES;
628 info->audit_events.settings = TALLOC_ZERO_ARRAY(p->mem_ctx,
629 enum lsa_PolicyAuditPolicy,
630 info->audit_events.count);
631 if (!info->audit_events.settings) {
632 return NT_STATUS_NO_MEMORY;
633 }
634
635 info->audit_events.settings[LSA_AUDIT_CATEGORY_ACCOUNT_MANAGEMENT] = policy_def;
636 info->audit_events.settings[LSA_AUDIT_CATEGORY_FILE_AND_OBJECT_ACCESS] = policy_def;
637 info->audit_events.settings[LSA_AUDIT_CATEGORY_LOGON] = policy_def;
638 info->audit_events.settings[LSA_AUDIT_CATEGORY_PROCCESS_TRACKING] = policy_def;
639 info->audit_events.settings[LSA_AUDIT_CATEGORY_SECURITY_POLICY_CHANGES] = policy_def;
640 info->audit_events.settings[LSA_AUDIT_CATEGORY_SYSTEM] = policy_def;
641 info->audit_events.settings[LSA_AUDIT_CATEGORY_USE_OF_USER_RIGHTS] = policy_def;
642
643 break;
644 }
645 case LSA_POLICY_INFO_DOMAIN:
646 /* check if the user has enough rights */
647 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
648 return NT_STATUS_ACCESS_DENIED;
649
650 /* Request PolicyPrimaryDomainInformation. */
651 switch (lp_server_role()) {
652 case ROLE_DOMAIN_PDC:
653 case ROLE_DOMAIN_BDC:
654 name = get_global_sam_name();
655 sid = sid_dup_talloc(p->mem_ctx, get_global_sam_sid());
656 if (!sid) {
657 return NT_STATUS_NO_MEMORY;
658 }
659 break;
660 case ROLE_DOMAIN_MEMBER:
661 name = lp_workgroup();
662 /* We need to return the Domain SID here. */
663 if (secrets_fetch_domain_sid(lp_workgroup(), &domain_sid)) {
664 sid = sid_dup_talloc(p->mem_ctx, &domain_sid);
665 if (!sid) {
666 return NT_STATUS_NO_MEMORY;
667 }
668 } else {
669 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
670 }
671 break;
672 case ROLE_STANDALONE:
673 name = lp_workgroup();
674 sid = NULL;
675 break;
676 default:
677 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
678 }
679 init_dom_query_3(&info->domain, name, sid);
680 break;
681 case LSA_POLICY_INFO_ACCOUNT_DOMAIN:
682 /* check if the user has enough rights */
683 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
684 return NT_STATUS_ACCESS_DENIED;
685
686 /* Request PolicyAccountDomainInformation. */
687 name = get_global_sam_name();
688 sid = get_global_sam_sid();
689
690 init_dom_query_5(&info->account_domain, name, sid);
691 break;
692 case LSA_POLICY_INFO_ROLE:
693 /* check if the user has enough rights */
694 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
695 return NT_STATUS_ACCESS_DENIED;
696
697 switch (lp_server_role()) {
698 case ROLE_DOMAIN_BDC:
699 /*
700 * only a BDC is a backup controller
701 * of the domain, it controls.
702 */
703 info->role.role = LSA_ROLE_BACKUP;
704 break;
705 default:
706 /*
707 * any other role is a primary
708 * of the domain, it controls.
709 */
710 info->role.role = LSA_ROLE_PRIMARY;
711 break;
712 }
713 break;
714 case LSA_POLICY_INFO_DNS:
715 case LSA_POLICY_INFO_DNS_INT: {
716 struct pdb_domain_info *dominfo;
717
718 if ((pdb_capabilities() & PDB_CAP_ADS) == 0) {
719 DEBUG(10, ("Not replying to LSA_POLICY_INFO_DNS "
720 "without ADS passdb backend\n"));
721 status = NT_STATUS_INVALID_INFO_CLASS;
722 break;
723 }
724
725 dominfo = pdb_get_domain_info(info);
726 if (dominfo == NULL) {
727 status = NT_STATUS_NO_MEMORY;
728 break;
729 }
730
731 init_lsa_StringLarge(&info->dns.name,
732 dominfo->name);
733 init_lsa_StringLarge(&info->dns.dns_domain,
734 dominfo->dns_domain);
735 init_lsa_StringLarge(&info->dns.dns_forest,
736 dominfo->dns_forest);
737 info->dns.domain_guid = dominfo->guid;
738 info->dns.sid = &dominfo->sid;
739 break;
740 }
741 default:
742 DEBUG(0,("_lsa_QueryInfoPolicy: unknown info level in Lsa Query: %d\n",
743 r->in.level));
744 status = NT_STATUS_INVALID_INFO_CLASS;
745 break;
746 }
747
748 *r->out.info = info;
749
750 return status;
751 }
752
753 /***************************************************************************
754 _lsa_QueryInfoPolicy2
755 ***************************************************************************/
756
757 NTSTATUS _lsa_QueryInfoPolicy2(pipes_struct *p,
758 struct lsa_QueryInfoPolicy2 *r2)
759 {
760 struct lsa_QueryInfoPolicy r;
761
762 if ((pdb_capabilities() & PDB_CAP_ADS) == 0) {
763 p->rng_fault_state = True;
764 return NT_STATUS_NOT_IMPLEMENTED;
765 }
766
767 ZERO_STRUCT(r);
768 r.in.handle = r2->in.handle;
769 r.in.level = r2->in.level;
770 r.out.info = r2->out.info;
771
772 return _lsa_QueryInfoPolicy(p, &r);
773 }
774
775 /***************************************************************************
776 _lsa_lookup_sids_internal
777 ***************************************************************************/
778
779 static NTSTATUS _lsa_lookup_sids_internal(pipes_struct *p,
780 TALLOC_CTX *mem_ctx,
781 uint16_t level, /* input */
782 int num_sids, /* input */
783 struct lsa_SidPtr *sid, /* input */
784 struct lsa_RefDomainList **pp_ref, /* input/output */
785 struct lsa_TranslatedName2 **pp_names,/* input/output */
786 uint32_t *pp_mapped_count) /* input/output */
787 {
788 NTSTATUS status;
789 int i;
790 const DOM_SID **sids = NULL;
791 struct lsa_RefDomainList *ref = NULL;
792 uint32 mapped_count = 0;
793 struct lsa_dom_info *dom_infos = NULL;
794 struct lsa_name_info *name_infos = NULL;
795 struct lsa_TranslatedName2 *names = NULL;
796
797 *pp_mapped_count = 0;
798 *pp_names = NULL;
799 *pp_ref = NULL;
800
801 if (num_sids == 0) {
802 return NT_STATUS_OK;
803 }
804
805 sids = TALLOC_ARRAY(p->mem_ctx, const DOM_SID *, num_sids);
806 ref = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
807
808 if (sids == NULL || ref == NULL) {
809 return NT_STATUS_NO_MEMORY;
810 }
811
812 for (i=0; i<num_sids; i++) {
813 sids[i] = sid[i].sid;
814 }
815
816 status = lookup_sids(p->mem_ctx, num_sids, sids, level,
817 &dom_infos, &name_infos);
818
819 if (!NT_STATUS_IS_OK(status)) {
820 return status;
821 }
822
823 names = TALLOC_ARRAY(p->mem_ctx, struct lsa_TranslatedName2, num_sids);
824 if (names == NULL) {
825 return NT_STATUS_NO_MEMORY;
826 }
827
828 for (i=0; i<LSA_REF_DOMAIN_LIST_MULTIPLIER; i++) {
829
830 if (!dom_infos[i].valid) {
831 break;
832 }
833
834 if (init_lsa_ref_domain_list(mem_ctx, ref,
835 dom_infos[i].name,
836 &dom_infos[i].sid) != i) {
837 DEBUG(0, ("Domain %s mentioned twice??\n",
838 dom_infos[i].name));
839 return NT_STATUS_INTERNAL_ERROR;
840 }
841 }
842
843 for (i=0; i<num_sids; i++) {
844 struct lsa_name_info *name = &name_infos[i];
845
846 if (name->type == SID_NAME_UNKNOWN) {
847 fstring tmp;
848 name->dom_idx = -1;
849 /* Unknown sids should return the string
850 * representation of the SID. Windows 2003 behaves
851 * rather erratic here, in many cases it returns the
852 * RID as 8 bytes hex, in others it returns the full
853 * SID. We (Jerry/VL) could not figure out which the
854 * hard cases are, so leave it with the SID. */
855 name->name = talloc_asprintf(p->mem_ctx, "%s",
856 sid_to_fstring(tmp,
857 sids[i]));
858 if (name->name == NULL) {
859 return NT_STATUS_NO_MEMORY;
860 }
861 } else {
862 mapped_count += 1;
863 }
864
865 names[i].sid_type = name->type;
866 names[i].name.string = name->name;
867 names[i].sid_index = name->dom_idx;
868 names[i].unknown = 0;
869 }
870
871 status = NT_STATUS_NONE_MAPPED;
872 if (mapped_count > 0) {
873 status = (mapped_count < num_sids) ?
874 STATUS_SOME_UNMAPPED : NT_STATUS_OK;
875 }
876
877 DEBUG(10, ("num_sids %d, mapped_count %d, status %s\n",
878 num_sids, mapped_count, nt_errstr(status)));
879
880 *pp_mapped_count = mapped_count;
881 *pp_names = names;
882 *pp_ref = ref;
883
884 return status;
885 }
886
887 /***************************************************************************
888 _lsa_LookupSids
889 ***************************************************************************/
890
891 NTSTATUS _lsa_LookupSids(pipes_struct *p,
892 struct lsa_LookupSids *r)
893 {
894 NTSTATUS status;
895 struct lsa_info *handle;
896 int num_sids = r->in.sids->num_sids;
897 uint32 mapped_count = 0;
898 struct lsa_RefDomainList *domains = NULL;
899 struct lsa_TranslatedName *names_out = NULL;
900 struct lsa_TranslatedName2 *names = NULL;
901 int i;
902
903 if ((r->in.level < 1) || (r->in.level > 6)) {
904 return NT_STATUS_INVALID_PARAMETER;
905 }
906
907 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle)) {
908 return NT_STATUS_INVALID_HANDLE;
909 }
910
911 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
912 return NT_STATUS_INVALID_HANDLE;
913 }
914
915 /* check if the user has enough rights */
916 if (!(handle->access & LSA_POLICY_LOOKUP_NAMES)) {
917 return NT_STATUS_ACCESS_DENIED;
918 }
919
920 if (num_sids > MAX_LOOKUP_SIDS) {
921 DEBUG(5,("_lsa_LookupSids: limit of %d exceeded, requested %d\n",
922 MAX_LOOKUP_SIDS, num_sids));
923 return NT_STATUS_NONE_MAPPED;
924 }
925
926 status = _lsa_lookup_sids_internal(p,
927 p->mem_ctx,
928 r->in.level,
929 num_sids,
930 r->in.sids->sids,
931 &domains,
932 &names,
933 &mapped_count);
934
935 /* Only return here when there is a real error.
936 NT_STATUS_NONE_MAPPED is a special case as it indicates that none of
937 the requested sids could be resolved. Older versions of XP (pre SP3)
938 rely that we return with the string representations of those SIDs in
939 that case. If we don't, XP crashes - Guenther
940 */
941
942 if (NT_STATUS_IS_ERR(status) &&
943 !NT_STATUS_EQUAL(status, NT_STATUS_NONE_MAPPED)) {
944 return status;
945 }
946
947 /* Convert from lsa_TranslatedName2 to lsa_TranslatedName */
948 names_out = TALLOC_ARRAY(p->mem_ctx, struct lsa_TranslatedName,
949 num_sids);
950 if (!names_out) {
951 return NT_STATUS_NO_MEMORY;
952 }
953
954 for (i=0; i<num_sids; i++) {
955 names_out[i].sid_type = names[i].sid_type;
956 names_out[i].name = names[i].name;
957 names_out[i].sid_index = names[i].sid_index;
958 }
959
960 *r->out.domains = domains;
961 r->out.names->count = num_sids;
962 r->out.names->names = names_out;
963 *r->out.count = mapped_count;
964
965 return status;
966 }
967
968 /***************************************************************************
969 _lsa_LookupSids2
970 ***************************************************************************/
971
972 NTSTATUS _lsa_LookupSids2(pipes_struct *p,
973 struct lsa_LookupSids2 *r)
974 {
975 NTSTATUS status;
976 struct lsa_info *handle;
977 int num_sids = r->in.sids->num_sids;
978 uint32 mapped_count = 0;
979 struct lsa_RefDomainList *domains = NULL;
980 struct lsa_TranslatedName2 *names = NULL;
981 bool check_policy = true;
982
983 switch (p->hdr_req.opnum) {
984 case NDR_LSA_LOOKUPSIDS3:
985 check_policy = false;
986 break;
987 case NDR_LSA_LOOKUPSIDS2:
988 default:
989 check_policy = true;
990 }
991
992 if ((r->in.level < 1) || (r->in.level > 6)) {
993 return NT_STATUS_INVALID_PARAMETER;
994 }
995
996 if (check_policy) {
997 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle)) {
998 return NT_STATUS_INVALID_HANDLE;
999 }
1000
1001 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1002 return NT_STATUS_INVALID_HANDLE;
1003 }
1004
1005 /* check if the user has enough rights */
1006 if (!(handle->access & LSA_POLICY_LOOKUP_NAMES)) {
1007 return NT_STATUS_ACCESS_DENIED;
1008 }
1009 }
1010
1011 if (num_sids > MAX_LOOKUP_SIDS) {
1012 DEBUG(5,("_lsa_LookupSids2: limit of %d exceeded, requested %d\n",
1013 MAX_LOOKUP_SIDS, num_sids));
1014 return NT_STATUS_NONE_MAPPED;
1015 }
1016
1017 status = _lsa_lookup_sids_internal(p,
1018 p->mem_ctx,
1019 r->in.level,
1020 num_sids,
1021 r->in.sids->sids,
1022 &domains,
1023 &names,
1024 &mapped_count);
1025
1026 *r->out.domains = domains;
1027 r->out.names->count = num_sids;
1028 r->out.names->names = names;
1029 *r->out.count = mapped_count;
1030
1031 return status;
1032 }
1033
1034 /***************************************************************************
1035 _lsa_LookupSids3
1036 ***************************************************************************/
1037
1038 NTSTATUS _lsa_LookupSids3(pipes_struct *p,
1039 struct lsa_LookupSids3 *r)
1040 {
1041 struct lsa_LookupSids2 q;
1042
1043 /* No policy handle on this call. Restrict to crypto connections. */
1044 if (p->auth.auth_type != PIPE_AUTH_TYPE_SCHANNEL) {
1045 DEBUG(0,("_lsa_LookupSids3: client %s not using schannel for netlogon\n",
1046 get_remote_machine_name() ));
1047 return NT_STATUS_INVALID_PARAMETER;
1048 }
1049
1050 q.in.handle = NULL;
1051 q.in.sids = r->in.sids;
1052 q.in.level = r->in.level;
1053 q.in.lookup_options = r->in.lookup_options;
1054 q.in.client_revision = r->in.client_revision;
1055 q.in.names = r->in.names;
1056 q.in.count = r->in.count;
1057
1058 q.out.domains = r->out.domains;
1059 q.out.names = r->out.names;
1060 q.out.count = r->out.count;
1061
1062 return _lsa_LookupSids2(p, &q);
1063 }
1064
1065 /***************************************************************************
1066 ***************************************************************************/
1067
1068 static int lsa_lookup_level_to_flags(enum lsa_LookupNamesLevel level)
1069 {
1070 int flags;
1071
1072 switch (level) {
1073 case LSA_LOOKUP_NAMES_ALL: /* 1 */
1074 flags = LOOKUP_NAME_ALL;
1075 break;
1076 case LSA_LOOKUP_NAMES_DOMAINS_ONLY: /* 2 */
1077 flags = LOOKUP_NAME_DOMAIN|LOOKUP_NAME_REMOTE|LOOKUP_NAME_ISOLATED;
1078 break;
1079 case LSA_LOOKUP_NAMES_PRIMARY_DOMAIN_ONLY: /* 3 */
1080 flags = LOOKUP_NAME_DOMAIN|LOOKUP_NAME_ISOLATED;
1081 break;
1082 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY: /* 4 */
1083 case LSA_LOOKUP_NAMES_FOREST_TRUSTS_ONLY: /* 5 */
1084 case LSA_LOOKUP_NAMES_UPLEVEL_TRUSTS_ONLY2: /* 6 */
1085 case LSA_LOOKUP_NAMES_RODC_REFERRAL_TO_FULL_DC: /* 7 */
1086 default:
1087 flags = LOOKUP_NAME_NONE;
1088 break;
1089 }
1090
1091 return flags;
1092 }
1093
1094 /***************************************************************************
1095 _lsa_LookupNames
1096 ***************************************************************************/
1097
1098 NTSTATUS _lsa_LookupNames(pipes_struct *p,
1099 struct lsa_LookupNames *r)
1100 {
1101 NTSTATUS status = NT_STATUS_NONE_MAPPED;
1102 struct lsa_info *handle;
1103 struct lsa_String *names = r->in.names;
1104 uint32 num_entries = r->in.num_names;
1105 struct lsa_RefDomainList *domains = NULL;
1106 struct lsa_TranslatedSid *rids = NULL;
1107 uint32 mapped_count = 0;
1108 int flags = 0;
1109
1110 if (num_entries > MAX_LOOKUP_SIDS) {
1111 num_entries = MAX_LOOKUP_SIDS;
1112 DEBUG(5,("_lsa_LookupNames: truncating name lookup list to %d\n",
1113 num_entries));
1114 }
1115
1116 flags = lsa_lookup_level_to_flags(r->in.level);
1117
1118 domains = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
1119 if (!domains) {
1120 return NT_STATUS_NO_MEMORY;
1121 }
1122
1123 if (num_entries) {
1124 rids = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_TranslatedSid,
1125 num_entries);
1126 if (!rids) {
1127 return NT_STATUS_NO_MEMORY;
1128 }
1129 } else {
1130 rids = NULL;
1131 }
1132
1133 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle)) {
1134 status = NT_STATUS_INVALID_HANDLE;
1135 goto done;
1136 }
1137
1138 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1139 return NT_STATUS_INVALID_HANDLE;
1140 }
1141
1142 /* check if the user has enough rights */
1143 if (!(handle->access & LSA_POLICY_LOOKUP_NAMES)) {
1144 status = NT_STATUS_ACCESS_DENIED;
1145 goto done;
1146 }
1147
1148 /* set up the LSA Lookup RIDs response */
1149 become_root(); /* lookup_name can require root privs */
1150 status = lookup_lsa_rids(p->mem_ctx, domains, rids, num_entries,
1151 names, flags, &mapped_count);
1152 unbecome_root();
1153
1154 done:
1155
1156 if (NT_STATUS_IS_OK(status) && (num_entries != 0) ) {
1157 if (mapped_count == 0) {
1158 status = NT_STATUS_NONE_MAPPED;
1159 } else if (mapped_count != num_entries) {
1160 status = STATUS_SOME_UNMAPPED;
1161 }
1162 }
1163
1164 *r->out.count = mapped_count;
1165 *r->out.domains = domains;
1166 r->out.sids->sids = rids;
1167 r->out.sids->count = num_entries;
1168
1169 return status;
1170 }
1171
1172 /***************************************************************************
1173 _lsa_LookupNames2
1174 ***************************************************************************/
1175
1176 NTSTATUS _lsa_LookupNames2(pipes_struct *p,
1177 struct lsa_LookupNames2 *r)
1178 {
1179 NTSTATUS status;
1180 struct lsa_LookupNames q;
1181 struct lsa_TransSidArray2 *sid_array2 = r->in.sids;
1182 struct lsa_TransSidArray *sid_array = NULL;
1183 uint32_t i;
1184
1185 sid_array = TALLOC_ZERO_P(p->mem_ctx, struct lsa_TransSidArray);
1186 if (!sid_array) {
1187 return NT_STATUS_NO_MEMORY;
1188 }
1189
1190 q.in.handle = r->in.handle;
1191 q.in.num_names = r->in.num_names;
1192 q.in.names = r->in.names;
1193 q.in.level = r->in.level;
1194 q.in.sids = sid_array;
1195 q.in.count = r->in.count;
1196 /* we do not know what this is for */
1197 /* = r->in.unknown1; */
1198 /* = r->in.unknown2; */
1199
1200 q.out.domains = r->out.domains;
1201 q.out.sids = sid_array;
1202 q.out.count = r->out.count;
1203
1204 status = _lsa_LookupNames(p, &q);
1205
1206 sid_array2->count = sid_array->count;
1207 sid_array2->sids = TALLOC_ARRAY(p->mem_ctx, struct lsa_TranslatedSid2, sid_array->count);
1208 if (!sid_array2->sids) {
1209 return NT_STATUS_NO_MEMORY;
1210 }
1211
1212 for (i=0; i<sid_array->count; i++) {
1213 sid_array2->sids[i].sid_type = sid_array->sids[i].sid_type;
1214 sid_array2->sids[i].rid = sid_array->sids[i].rid;
1215 sid_array2->sids[i].sid_index = sid_array->sids[i].sid_index;
1216 sid_array2->sids[i].unknown = 0;
1217 }
1218
1219 r->out.sids = sid_array2;
1220
1221 return status;
1222 }
1223
1224 /***************************************************************************
1225 _lsa_LookupNames3
1226 ***************************************************************************/
1227
1228 NTSTATUS _lsa_LookupNames3(pipes_struct *p,
1229 struct lsa_LookupNames3 *r)
1230 {
1231 NTSTATUS status;
1232 struct lsa_info *handle;
1233 struct lsa_String *names = r->in.names;
1234 uint32 num_entries = r->in.num_names;
1235 struct lsa_RefDomainList *domains = NULL;
1236 struct lsa_TranslatedSid3 *trans_sids = NULL;
1237 uint32 mapped_count = 0;
1238 int flags = 0;
1239 bool check_policy = true;
1240
1241 switch (p->hdr_req.opnum) {
1242 case NDR_LSA_LOOKUPNAMES4:
1243 check_policy = false;
1244 break;
1245 case NDR_LSA_LOOKUPNAMES3:
1246 default:
1247 check_policy = true;
1248 }
1249
1250 if (num_entries > MAX_LOOKUP_SIDS) {
1251 num_entries = MAX_LOOKUP_SIDS;
1252 DEBUG(5,("_lsa_LookupNames3: truncating name lookup list to %d\n", num_entries));
1253 }
1254
1255 /* Probably the lookup_level is some sort of bitmask. */
1256 if (r->in.level == 1) {
1257 flags = LOOKUP_NAME_ALL;
1258 }
1259
1260 domains = TALLOC_ZERO_P(p->mem_ctx, struct lsa_RefDomainList);
1261 if (!domains) {
1262 return NT_STATUS_NO_MEMORY;
1263 }
1264
1265 if (num_entries) {
1266 trans_sids = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_TranslatedSid3,
1267 num_entries);
1268 if (!trans_sids) {
1269 return NT_STATUS_NO_MEMORY;
1270 }
1271 } else {
1272 trans_sids = NULL;
1273 }
1274
1275 if (check_policy) {
1276
1277 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle)) {
1278 status = NT_STATUS_INVALID_HANDLE;
1279 goto done;
1280 }
1281
1282 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1283 return NT_STATUS_INVALID_HANDLE;
1284 }
1285
1286 /* check if the user has enough rights */
1287 if (!(handle->access & LSA_POLICY_LOOKUP_NAMES)) {
1288 status = NT_STATUS_ACCESS_DENIED;
1289 goto done;
1290 }
1291 }
1292
1293 /* set up the LSA Lookup SIDs response */
1294 become_root(); /* lookup_name can require root privs */
1295 status = lookup_lsa_sids(p->mem_ctx, domains, trans_sids, num_entries,
1296 names, flags, &mapped_count);
1297 unbecome_root();
1298
1299 done:
1300
1301 if (NT_STATUS_IS_OK(status)) {
1302 if (mapped_count == 0) {
1303 status = NT_STATUS_NONE_MAPPED;
1304 } else if (mapped_count != num_entries) {
1305 status = STATUS_SOME_UNMAPPED;
1306 }
1307 }
1308
1309 *r->out.count = mapped_count;
1310 *r->out.domains = domains;
1311 r->out.sids->sids = trans_sids;
1312 r->out.sids->count = num_entries;
1313
1314 return status;
1315 }
1316
1317 /***************************************************************************
1318 _lsa_LookupNames4
1319 ***************************************************************************/
1320
1321 NTSTATUS _lsa_LookupNames4(pipes_struct *p,
1322 struct lsa_LookupNames4 *r)
1323 {
1324 struct lsa_LookupNames3 q;
1325
1326 /* No policy handle on this call. Restrict to crypto connections. */
1327 if (p->auth.auth_type != PIPE_AUTH_TYPE_SCHANNEL) {
1328 DEBUG(0,("_lsa_lookup_names4: client %s not using schannel for netlogon\n",
1329 get_remote_machine_name() ));
1330 return NT_STATUS_INVALID_PARAMETER;
1331 }
1332
1333 q.in.handle = NULL;
1334 q.in.num_names = r->in.num_names;
1335 q.in.names = r->in.names;
1336 q.in.level = r->in.level;
1337 q.in.lookup_options = r->in.lookup_options;
1338 q.in.client_revision = r->in.client_revision;
1339 q.in.sids = r->in.sids;
1340 q.in.count = r->in.count;
1341
1342 q.out.domains = r->out.domains;
1343 q.out.sids = r->out.sids;
1344 q.out.count = r->out.count;
1345
1346 return _lsa_LookupNames3(p, &q);
1347 }
1348
1349 /***************************************************************************
1350 _lsa_close. Also weird - needs to check if lsa handle is correct. JRA.
1351 ***************************************************************************/
1352
1353 NTSTATUS _lsa_Close(pipes_struct *p, struct lsa_Close *r)
1354 {
1355 if (!find_policy_by_hnd(p, r->in.handle, NULL)) {
1356 return NT_STATUS_INVALID_HANDLE;
1357 }
1358
1359 close_policy_hnd(p, r->in.handle);
1360 ZERO_STRUCTP(r->out.handle);
1361 return NT_STATUS_OK;
1362 }
1363
1364 /***************************************************************************
1365 ***************************************************************************/
1366
1367 NTSTATUS _lsa_OpenSecret(pipes_struct *p, struct lsa_OpenSecret *r)
1368 {
1369 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1370 }
1371
1372 /***************************************************************************
1373 ***************************************************************************/
1374
1375 NTSTATUS _lsa_OpenTrustedDomain(pipes_struct *p, struct lsa_OpenTrustedDomain *r)
1376 {
1377 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1378 }
1379
1380 /***************************************************************************
1381 ***************************************************************************/
1382
1383 NTSTATUS _lsa_CreateTrustedDomain(pipes_struct *p, struct lsa_CreateTrustedDomain *r)
1384 {
1385 return NT_STATUS_ACCESS_DENIED;
1386 }
1387
1388 /***************************************************************************
1389 ***************************************************************************/
1390
1391 NTSTATUS _lsa_CreateSecret(pipes_struct *p, struct lsa_CreateSecret *r)
1392 {
1393 return NT_STATUS_ACCESS_DENIED;
1394 }
1395
1396 /***************************************************************************
1397 ***************************************************************************/
1398
1399 NTSTATUS _lsa_SetSecret(pipes_struct *p, struct lsa_SetSecret *r)
1400 {
1401 return NT_STATUS_ACCESS_DENIED;
1402 }
1403
1404 /***************************************************************************
1405 _lsa_DeleteObject
1406 ***************************************************************************/
1407
1408 NTSTATUS _lsa_DeleteObject(pipes_struct *p,
1409 struct lsa_DeleteObject *r)
1410 {
1411 NTSTATUS status;
1412 struct lsa_info *info = NULL;
1413
1414 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info)) {
1415 return NT_STATUS_INVALID_HANDLE;
1416 }
1417
1418 if (!(info->access & STD_RIGHT_DELETE_ACCESS)) {
1419 return NT_STATUS_ACCESS_DENIED;
1420 }
1421
1422 switch (info->type) {
1423 case LSA_HANDLE_ACCOUNT_TYPE:
1424 status = privilege_delete_account(&info->sid);
1425 if (!NT_STATUS_IS_OK(status)) {
1426 DEBUG(10,("_lsa_DeleteObject: privilege_delete_account gave: %s\n",
1427 nt_errstr(status)));
1428 return status;
1429 }
1430 break;
1431 default:
1432 return NT_STATUS_INVALID_HANDLE;
1433 }
1434
1435 close_policy_hnd(p, r->in.handle);
1436 ZERO_STRUCTP(r->out.handle);
1437
1438 return status;
1439 }
1440
1441 /***************************************************************************
1442 _lsa_EnumPrivs
1443 ***************************************************************************/
1444
1445 NTSTATUS _lsa_EnumPrivs(pipes_struct *p,
1446 struct lsa_EnumPrivs *r)
1447 {
1448 struct lsa_info *handle;
1449 uint32 i;
1450 uint32 enum_context = *r->in.resume_handle;
1451 int num_privs = count_all_privileges();
1452 struct lsa_PrivEntry *entries = NULL;
1453 LUID_ATTR luid;
1454
1455 /* remember that the enum_context starts at 0 and not 1 */
1456
1457 if ( enum_context >= num_privs )
1458 return NT_STATUS_NO_MORE_ENTRIES;
1459
1460 DEBUG(10,("_lsa_EnumPrivs: enum_context:%d total entries:%d\n",
1461 enum_context, num_privs));
1462
1463 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1464 return NT_STATUS_INVALID_HANDLE;
1465
1466 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1467 return NT_STATUS_INVALID_HANDLE;
1468 }
1469
1470 /* check if the user has enough rights
1471 I don't know if it's the right one. not documented. */
1472
1473 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
1474 return NT_STATUS_ACCESS_DENIED;
1475
1476 if (num_privs) {
1477 entries = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_PrivEntry, num_privs);
1478 if (!entries) {
1479 return NT_STATUS_NO_MEMORY;
1480 }
1481 } else {
1482 entries = NULL;
1483 }
1484
1485 for (i = 0; i < num_privs; i++) {
1486 if( i < enum_context) {
1487
1488 init_lsa_StringLarge(&entries[i].name, NULL);
1489
1490 entries[i].luid.low = 0;
1491 entries[i].luid.high = 0;
1492 } else {
1493
1494 init_lsa_StringLarge(&entries[i].name, privs[i].name);
1495
1496 luid = get_privilege_luid( &privs[i].se_priv );
1497
1498 entries[i].luid.low = luid.luid.low;
1499 entries[i].luid.high = luid.luid.high;
1500 }
1501 }
1502
1503 enum_context = num_privs;
1504
1505 *r->out.resume_handle = enum_context;
1506 r->out.privs->count = num_privs;
1507 r->out.privs->privs = entries;
1508
1509 return NT_STATUS_OK;
1510 }
1511
1512 /***************************************************************************
1513 _lsa_LookupPrivDisplayName
1514 ***************************************************************************/
1515
1516 NTSTATUS _lsa_LookupPrivDisplayName(pipes_struct *p,
1517 struct lsa_LookupPrivDisplayName *r)
1518 {
1519 struct lsa_info *handle;
1520 const char *description;
1521 struct lsa_StringLarge *lsa_name;
1522
1523 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1524 return NT_STATUS_INVALID_HANDLE;
1525
1526 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1527 return NT_STATUS_INVALID_HANDLE;
1528 }
1529
1530 /* check if the user has enough rights */
1531
1532 /*
1533 * I don't know if it's the right one. not documented.
1534 */
1535 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
1536 return NT_STATUS_ACCESS_DENIED;
1537
1538 DEBUG(10,("_lsa_LookupPrivDisplayName: name = %s\n", r->in.name->string));
1539
1540 description = get_privilege_dispname(r->in.name->string);
1541 if (!description) {
1542 DEBUG(10,("_lsa_LookupPrivDisplayName: doesn't exist\n"));
1543 return NT_STATUS_NO_SUCH_PRIVILEGE;
1544 }
1545
1546 DEBUG(10,("_lsa_LookupPrivDisplayName: display name = %s\n", description));
1547
1548 lsa_name = TALLOC_ZERO_P(p->mem_ctx, struct lsa_StringLarge);
1549 if (!lsa_name) {
1550 return NT_STATUS_NO_MEMORY;
1551 }
1552
1553 init_lsa_StringLarge(lsa_name, description);
1554
1555 *r->out.returned_language_id = r->in.language_id;
1556 *r->out.disp_name = lsa_name;
1557
1558 return NT_STATUS_OK;
1559 }
1560
1561 /***************************************************************************
1562 _lsa_EnumAccounts
1563 ***************************************************************************/
1564
1565 NTSTATUS _lsa_EnumAccounts(pipes_struct *p,
1566 struct lsa_EnumAccounts *r)
1567 {
1568 struct lsa_info *handle;
1569 DOM_SID *sid_list;
1570 int i, j, num_entries;
1571 NTSTATUS status;
1572 struct lsa_SidPtr *sids = NULL;
1573
1574 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1575 return NT_STATUS_INVALID_HANDLE;
1576
1577 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1578 return NT_STATUS_INVALID_HANDLE;
1579 }
1580
1581 if (!(handle->access & LSA_POLICY_VIEW_LOCAL_INFORMATION))
1582 return NT_STATUS_ACCESS_DENIED;
1583
1584 sid_list = NULL;
1585 num_entries = 0;
1586
1587 /* The only way we can currently find out all the SIDs that have been
1588 privileged is to scan all privileges */
1589
1590 status = privilege_enumerate_accounts(&sid_list, &num_entries);
1591 if (!NT_STATUS_IS_OK(status)) {
1592 return status;
1593 }
1594
1595 if (*r->in.resume_handle >= num_entries) {
1596 return NT_STATUS_NO_MORE_ENTRIES;
1597 }
1598
1599 if (num_entries - *r->in.resume_handle) {
1600 sids = TALLOC_ZERO_ARRAY(p->mem_ctx, struct lsa_SidPtr,
1601 num_entries - *r->in.resume_handle);
1602 if (!sids) {
1603 talloc_free(sid_list);
1604 return NT_STATUS_NO_MEMORY;
1605 }
1606
1607 for (i = *r->in.resume_handle, j = 0; i < num_entries; i++, j++) {
1608 sids[j].sid = sid_dup_talloc(p->mem_ctx, &sid_list[i]);
1609 if (!sids[j].sid) {
1610 talloc_free(sid_list);
1611 return NT_STATUS_NO_MEMORY;
1612 }
1613 }
1614 }
1615
1616 talloc_free(sid_list);
1617
1618 *r->out.resume_handle = num_entries;
1619 r->out.sids->num_sids = num_entries;
1620 r->out.sids->sids = sids;
1621
1622 return NT_STATUS_OK;
1623 }
1624
1625 /***************************************************************************
1626 _lsa_GetUserName
1627 ***************************************************************************/
1628
1629 NTSTATUS _lsa_GetUserName(pipes_struct *p,
1630 struct lsa_GetUserName *r)
1631 {
1632 const char *username, *domname;
1633 struct lsa_String *account_name = NULL;
1634 struct lsa_String *authority_name = NULL;
1635
1636 if (r->in.account_name &&
1637 *r->in.account_name) {
1638 return NT_STATUS_INVALID_PARAMETER;
1639 }
1640
1641 if (r->in.authority_name &&
1642 *r->in.authority_name) {
1643 return NT_STATUS_INVALID_PARAMETER;
1644 }
1645
1646 if (p->server_info->guest) {
1647 /*
1648 * I'm 99% sure this is not the right place to do this,
1649 * global_sid_Anonymous should probably be put into the token
1650 * instead of the guest id -- vl
1651 */
1652 if (!lookup_sid(p->mem_ctx, &global_sid_Anonymous,
1653 &domname, &username, NULL)) {
1654 return NT_STATUS_NO_MEMORY;
1655 }
1656 } else {
1657 username = p->server_info->sanitized_username;
1658 domname = pdb_get_domain(p->server_info->sam_account);
1659 }
1660
1661 account_name = TALLOC_P(p->mem_ctx, struct lsa_String);
1662 if (!account_name) {
1663 return NT_STATUS_NO_MEMORY;
1664 }
1665 init_lsa_String(account_name, username);
1666
1667 if (r->out.authority_name) {
1668 authority_name = TALLOC_P(p->mem_ctx, struct lsa_String);
1669 if (!authority_name) {
1670 return NT_STATUS_NO_MEMORY;
1671 }
1672 init_lsa_String(authority_name, domname);
1673 }
1674
1675 *r->out.account_name = account_name;
1676 if (r->out.authority_name) {
1677 *r->out.authority_name = authority_name;
1678 }
1679
1680 return NT_STATUS_OK;
1681 }
1682
1683 /***************************************************************************
1684 _lsa_CreateAccount
1685 ***************************************************************************/
1686
1687 NTSTATUS _lsa_CreateAccount(pipes_struct *p,
1688 struct lsa_CreateAccount *r)
1689 {
1690 NTSTATUS status;
1691 struct lsa_info *handle;
1692 struct lsa_info *info;
1693 uint32_t acc_granted;
1694 struct security_descriptor *psd;
1695 size_t sd_size;
1696
1697 /* find the connection policy handle. */
1698 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1699 return NT_STATUS_INVALID_HANDLE;
1700
1701 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1702 return NT_STATUS_INVALID_HANDLE;
1703 }
1704
1705 /* check if the user has enough rights */
1706
1707 if (!(handle->access & LSA_POLICY_CREATE_ACCOUNT)) {
1708 return NT_STATUS_ACCESS_DENIED;
1709 }
1710
1711 /* Work out max allowed. */
1712 map_max_allowed_access(p->server_info->ptok,
1713 &p->server_info->utok,
1714 &r->in.access_mask);
1715
1716 /* map the generic bits to the lsa policy ones */
1717 se_map_generic(&r->in.access_mask, &lsa_account_mapping);
1718
1719 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
1720 &lsa_account_mapping,
1721 r->in.sid, LSA_POLICY_ALL_ACCESS);
1722 if (!NT_STATUS_IS_OK(status)) {
1723 return status;
1724 }
1725
1726 status = access_check_object(psd, p->server_info->ptok,
1727 NULL, 0, r->in.access_mask,
1728 &acc_granted, "_lsa_CreateAccount");
1729 if (!NT_STATUS_IS_OK(status)) {
1730 return status;
1731 }
1732
1733 if ( is_privileged_sid( r->in.sid ) )
1734 return NT_STATUS_OBJECT_NAME_COLLISION;
1735
1736 /* associate the user/group SID with the (unique) handle. */
1737
1738 info = TALLOC_ZERO_P(p->mem_ctx, struct lsa_info);
1739 if (info == NULL) {
1740 return NT_STATUS_NO_MEMORY;
1741 }
1742
1743 info->sid = *r->in.sid;
1744 info->access = acc_granted;
1745 info->type = LSA_HANDLE_ACCOUNT_TYPE;
1746
1747 /* get a (unique) handle. open a policy on it. */
1748 if (!create_policy_hnd(p, r->out.acct_handle, info))
1749 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1750
1751 return privilege_create_account( &info->sid );
1752 }
1753
1754 /***************************************************************************
1755 _lsa_OpenAccount
1756 ***************************************************************************/
1757
1758 NTSTATUS _lsa_OpenAccount(pipes_struct *p,
1759 struct lsa_OpenAccount *r)
1760 {
1761 struct lsa_info *handle;
1762 struct lsa_info *info;
1763 SEC_DESC *psd = NULL;
1764 size_t sd_size;
1765 uint32_t des_access = r->in.access_mask;
1766 uint32_t acc_granted;
1767 NTSTATUS status;
1768
1769 /* find the connection policy handle. */
1770 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
1771 return NT_STATUS_INVALID_HANDLE;
1772
1773 if (handle->type != LSA_HANDLE_POLICY_TYPE) {
1774 return NT_STATUS_INVALID_HANDLE;
1775 }
1776
1777 /* des_access is for the account here, not the policy
1778 * handle - so don't check against policy handle. */
1779
1780 /* Work out max allowed. */
1781 map_max_allowed_access(p->server_info->ptok,
1782 &p->server_info->utok,
1783 &des_access);
1784
1785 /* map the generic bits to the lsa account ones */
1786 se_map_generic(&des_access, &lsa_account_mapping);
1787
1788 /* get the generic lsa account SD until we store it */
1789 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
1790 &lsa_account_mapping,
1791 r->in.sid, LSA_ACCOUNT_ALL_ACCESS);
1792 if (!NT_STATUS_IS_OK(status)) {
1793 return status;
1794 }
1795
1796 status = access_check_object(psd, p->server_info->ptok,
1797 NULL, 0, des_access,
1798 &acc_granted, "_lsa_OpenAccount" );
1799 if (!NT_STATUS_IS_OK(status)) {
1800 return status;
1801 }
1802
1803 /* TODO: Fis the parsing routine before reenabling this check! */
1804 #if 0
1805 if (!lookup_sid(&handle->sid, dom_name, name, &type))
1806 return NT_STATUS_ACCESS_DENIED;
1807 #endif
1808 /* associate the user/group SID with the (unique) handle. */
1809 info = TALLOC_ZERO_P(p->mem_ctx, struct lsa_info);
1810 if (info == NULL) {
1811 return NT_STATUS_NO_MEMORY;
1812 }
1813
1814 info->sid = *r->in.sid;
1815 info->access = acc_granted;
1816 info->type = LSA_HANDLE_ACCOUNT_TYPE;
1817
1818 /* get a (unique) handle. open a policy on it. */
1819 if (!create_policy_hnd(p, r->out.acct_handle, info))
1820 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
1821
1822 return NT_STATUS_OK;
1823 }
1824
1825 /***************************************************************************
1826 _lsa_EnumPrivsAccount
1827 For a given SID, enumerate all the privilege this account has.
1828 ***************************************************************************/
1829
1830 NTSTATUS _lsa_EnumPrivsAccount(pipes_struct *p,
1831 struct lsa_EnumPrivsAccount *r)
1832 {
1833 NTSTATUS status = NT_STATUS_OK;
1834 struct lsa_info *info=NULL;
1835 SE_PRIV mask;
1836 PRIVILEGE_SET privileges;
1837 struct lsa_PrivilegeSet *priv_set = NULL;
1838 struct lsa_LUIDAttribute *luid_attrs = NULL;
1839 int i;
1840
1841 /* find the connection policy handle. */
1842 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
1843 return NT_STATUS_INVALID_HANDLE;
1844
1845 if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
1846 return NT_STATUS_INVALID_HANDLE;
1847 }
1848
1849 if (!(info->access & LSA_ACCOUNT_VIEW))
1850 return NT_STATUS_ACCESS_DENIED;
1851
1852 get_privileges_for_sids(&mask, &info->sid, 1);
1853
1854 privilege_set_init( &privileges );
1855
1856 priv_set = TALLOC_ZERO_P(p->mem_ctx, struct lsa_PrivilegeSet);
1857 if (!priv_set) {
1858 status = NT_STATUS_NO_MEMORY;
1859 goto done;
1860 }
1861
1862 if ( se_priv_to_privilege_set( &privileges, &mask ) ) {
1863
1864 DEBUG(10,("_lsa_EnumPrivsAccount: %s has %d privileges\n",
1865 sid_string_dbg(&info->sid),
1866 privileges.count));
1867
1868 luid_attrs = TALLOC_ZERO_ARRAY(p->mem_ctx,
1869 struct lsa_LUIDAttribute,
1870 privileges.count);
1871 if (!luid_attrs) {
1872 status = NT_STATUS_NO_MEMORY;
1873 goto done;
1874 }
1875
1876 for (i=0; i<privileges.count; i++) {
1877 luid_attrs[i].luid.low = privileges.set[i].luid.low;
1878 luid_attrs[i].luid.high = privileges.set[i].luid.high;
1879 luid_attrs[i].attribute = privileges.set[i].attr;
1880 }
1881
1882 priv_set->count = privileges.count;
1883 priv_set->unknown = 0;
1884 priv_set->set = luid_attrs;
1885
1886 } else {
1887 priv_set->count = 0;
1888 priv_set->unknown = 0;
1889 priv_set->set = NULL;
1890 }
1891
1892 *r->out.privs = priv_set;
1893
1894 done:
1895 privilege_set_free( &privileges );
1896
1897 return status;
1898 }
1899
1900 /***************************************************************************
1901 _lsa_GetSystemAccessAccount
1902 ***************************************************************************/
1903
1904 NTSTATUS _lsa_GetSystemAccessAccount(pipes_struct *p,
1905 struct lsa_GetSystemAccessAccount *r)
1906 {
1907 NTSTATUS status;
1908 struct lsa_info *info = NULL;
1909 struct lsa_EnumPrivsAccount e;
1910 struct lsa_PrivilegeSet *privset;
1911
1912 /* find the connection policy handle. */
1913
1914 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
1915 return NT_STATUS_INVALID_HANDLE;
1916
1917 if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
1918 return NT_STATUS_INVALID_HANDLE;
1919 }
1920
1921 if (!(info->access & LSA_ACCOUNT_VIEW))
1922 return NT_STATUS_ACCESS_DENIED;
1923
1924 privset = talloc_zero(p->mem_ctx, struct lsa_PrivilegeSet);
1925 if (!privset) {
1926 return NT_STATUS_NO_MEMORY;
1927 }
1928
1929 e.in.handle = r->in.handle;
1930 e.out.privs = &privset;
1931
1932 status = _lsa_EnumPrivsAccount(p, &e);
1933 if (!NT_STATUS_IS_OK(status)) {
1934 DEBUG(10,("_lsa_GetSystemAccessAccount: "
1935 "failed to call _lsa_EnumPrivsAccount(): %s\n",
1936 nt_errstr(status)));
1937 return status;
1938 }
1939
1940 /* Samba4 would iterate over the privset to merge the policy mode bits,
1941 * not sure samba3 can do the same here, so just return what we did in
1942 * the past - gd */
1943
1944 /*
1945 0x01 -> Log on locally
1946 0x02 -> Access this computer from network
1947 0x04 -> Log on as a batch job
1948 0x10 -> Log on as a service
1949
1950 they can be ORed together
1951 */
1952
1953 *r->out.access_mask = LSA_POLICY_MODE_INTERACTIVE |
1954 LSA_POLICY_MODE_NETWORK;
1955
1956 return NT_STATUS_OK;
1957 }
1958
1959 /***************************************************************************
1960 update the systemaccount information
1961 ***************************************************************************/
1962
1963 NTSTATUS _lsa_SetSystemAccessAccount(pipes_struct *p,
1964 struct lsa_SetSystemAccessAccount *r)
1965 {
1966 struct lsa_info *info=NULL;
1967 GROUP_MAP map;
1968
1969 /* find the connection policy handle. */
1970 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
1971 return NT_STATUS_INVALID_HANDLE;
1972
1973 if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
1974 return NT_STATUS_INVALID_HANDLE;
1975 }
1976
1977 if (!(info->access & LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS)) {
1978 return NT_STATUS_ACCESS_DENIED;
1979 }
1980
1981 if (!pdb_getgrsid(&map, info->sid))
1982 return NT_STATUS_NO_SUCH_GROUP;
1983
1984 return pdb_update_group_mapping_entry(&map);
1985 }
1986
1987 /***************************************************************************
1988 _lsa_AddPrivilegesToAccount
1989 For a given SID, add some privileges.
1990 ***************************************************************************/
1991
1992 NTSTATUS _lsa_AddPrivilegesToAccount(pipes_struct *p,
1993 struct lsa_AddPrivilegesToAccount *r)
1994 {
1995 struct lsa_info *info = NULL;
1996 SE_PRIV mask;
1997 struct lsa_PrivilegeSet *set = NULL;
1998
1999 /* find the connection policy handle. */
2000 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2001 return NT_STATUS_INVALID_HANDLE;
2002
2003 if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
2004 return NT_STATUS_INVALID_HANDLE;
2005 }
2006
2007 if (!(info->access & LSA_ACCOUNT_ADJUST_PRIVILEGES)) {
2008 return NT_STATUS_ACCESS_DENIED;
2009 }
2010
2011 set = r->in.privs;
2012 if ( !privilege_set_to_se_priv( &mask, set ) )
2013 return NT_STATUS_NO_SUCH_PRIVILEGE;
2014
2015 if ( !grant_privilege( &info->sid, &mask ) ) {
2016 DEBUG(3,("_lsa_AddPrivilegesToAccount: grant_privilege(%s) failed!\n",
2017 sid_string_dbg(&info->sid) ));
2018 DEBUG(3,("Privilege mask:\n"));
2019 dump_se_priv( DBGC_ALL, 3, &mask );
2020 return NT_STATUS_NO_SUCH_PRIVILEGE;
2021 }
2022
2023 return NT_STATUS_OK;
2024 }
2025
2026 /***************************************************************************
2027 _lsa_RemovePrivilegesFromAccount
2028 For a given SID, remove some privileges.
2029 ***************************************************************************/
2030
2031 NTSTATUS _lsa_RemovePrivilegesFromAccount(pipes_struct *p,
2032 struct lsa_RemovePrivilegesFromAccount *r)
2033 {
2034 struct lsa_info *info = NULL;
2035 SE_PRIV mask;
2036 struct lsa_PrivilegeSet *set = NULL;
2037
2038 /* find the connection policy handle. */
2039 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2040 return NT_STATUS_INVALID_HANDLE;
2041
2042 if (info->type != LSA_HANDLE_ACCOUNT_TYPE) {
2043 return NT_STATUS_INVALID_HANDLE;
2044 }
2045
2046 if (!(info->access & LSA_ACCOUNT_ADJUST_PRIVILEGES)) {
2047 return NT_STATUS_ACCESS_DENIED;
2048 }
2049
2050 set = r->in.privs;
2051
2052 if ( !privilege_set_to_se_priv( &mask, set ) )
2053 return NT_STATUS_NO_SUCH_PRIVILEGE;
2054
2055 if ( !revoke_privilege( &info->sid, &mask ) ) {
2056 DEBUG(3,("_lsa_RemovePrivilegesFromAccount: revoke_privilege(%s) failed!\n",
2057 sid_string_dbg(&info->sid) ));
2058 DEBUG(3,("Privilege mask:\n"));
2059 dump_se_priv( DBGC_ALL, 3, &mask );
2060 return NT_STATUS_NO_SUCH_PRIVILEGE;
2061 }
2062
2063 return NT_STATUS_OK;
2064 }
2065
2066 /***************************************************************************
2067 _lsa_LookupPrivName
2068 ***************************************************************************/
2069
2070 NTSTATUS _lsa_LookupPrivName(pipes_struct *p,
2071 struct lsa_LookupPrivName *r)
2072 {
2073 struct lsa_info *info = NULL;
2074 const char *name;
2075 struct lsa_StringLarge *lsa_name;
2076
2077 /* find the connection policy handle. */
2078 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info)) {
2079 return NT_STATUS_INVALID_HANDLE;
2080 }
2081
2082 if (info->type != LSA_HANDLE_POLICY_TYPE) {
2083 return NT_STATUS_INVALID_HANDLE;
2084 }
2085
2086 if (!(info->access & LSA_POLICY_VIEW_LOCAL_INFORMATION)) {
2087 return NT_STATUS_ACCESS_DENIED;
2088 }
2089
2090 name = luid_to_privilege_name((LUID *)r->in.luid);
2091 if (!name) {
2092 return NT_STATUS_NO_SUCH_PRIVILEGE;
2093 }
2094
2095 lsa_name = TALLOC_ZERO_P(p->mem_ctx, struct lsa_StringLarge);
2096 if (!lsa_name) {
2097 return NT_STATUS_NO_MEMORY;
2098 }
2099
2100 lsa_name->string = talloc_strdup(lsa_name, name);
2101 if (!lsa_name->string) {
2102 TALLOC_FREE(lsa_name);
2103 return NT_STATUS_NO_MEMORY;
2104 }
2105
2106 *r->out.name = lsa_name;
2107
2108 return NT_STATUS_OK;
2109 }
2110
2111 /***************************************************************************
2112 _lsa_QuerySecurity
2113 ***************************************************************************/
2114
2115 NTSTATUS _lsa_QuerySecurity(pipes_struct *p,
2116 struct lsa_QuerySecurity *r)
2117 {
2118 struct lsa_info *handle=NULL;
2119 SEC_DESC *psd = NULL;
2120 size_t sd_size;
2121 NTSTATUS status;
2122
2123 /* find the connection policy handle. */
2124 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&handle))
2125 return NT_STATUS_INVALID_HANDLE;
2126
2127 switch (handle->type) {
2128 case LSA_HANDLE_POLICY_TYPE:
2129 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
2130 &lsa_policy_mapping, NULL, 0);
2131 break;
2132 case LSA_HANDLE_ACCOUNT_TYPE:
2133 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
2134 &lsa_account_mapping,
2135 &handle->sid, LSA_ACCOUNT_ALL_ACCESS);
2136 break;
2137 default:
2138 status = NT_STATUS_INVALID_HANDLE;
2139 break;
2140 }
2141
2142 if (!NT_STATUS_IS_OK(status)) {
2143 return status;
2144 }
2145
2146 *r->out.sdbuf = make_sec_desc_buf(p->mem_ctx, sd_size, psd);
2147 if (!*r->out.sdbuf) {
2148 return NT_STATUS_NO_MEMORY;
2149 }
2150
2151 return status;
2152 }
2153
2154 /***************************************************************************
2155 _lsa_AddAccountRights
2156 ***************************************************************************/
2157
2158 NTSTATUS _lsa_AddAccountRights(pipes_struct *p,
2159 struct lsa_AddAccountRights *r)
2160 {
2161 struct lsa_info *info = NULL;
2162 int i = 0;
2163 uint32_t acc_granted = 0;
2164 SEC_DESC *psd = NULL;
2165 size_t sd_size;
2166 DOM_SID sid;
2167 NTSTATUS status;
2168
2169 /* find the connection policy handle. */
2170 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2171 return NT_STATUS_INVALID_HANDLE;
2172
2173 if (info->type != LSA_HANDLE_POLICY_TYPE) {
2174 return NT_STATUS_INVALID_HANDLE;
2175 }
2176
2177 /* get the generic lsa account SD for this SID until we store it */
2178 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
2179 &lsa_account_mapping,
2180 r->in.sid, LSA_ACCOUNT_ALL_ACCESS);
2181 if (!NT_STATUS_IS_OK(status)) {
2182 return status;
2183 }
2184
2185 /*
2186 * From the MS DOCs. If the sid doesn't exist, ask for LSA_POLICY_CREATE_ACCOUNT
2187 * on the policy handle. If it does, ask for
2188 * LSA_ACCOUNT_ADJUST_PRIVILEGES|LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS|LSA_ACCOUNT_VIEW,
2189 * on the account sid. We don't check here so just use the latter. JRA.
2190 */
2191
2192 status = access_check_object(psd, p->server_info->ptok,
2193 NULL, 0,
2194 LSA_ACCOUNT_ADJUST_PRIVILEGES|LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS|LSA_ACCOUNT_VIEW,
2195 &acc_granted, "_lsa_AddAccountRights" );
2196 if (!NT_STATUS_IS_OK(status)) {
2197 return status;
2198 }
2199
2200 /* according to an NT4 PDC, you can add privileges to SIDs even without
2201 call_lsa_create_account() first. And you can use any arbitrary SID. */
2202
2203 sid_copy( &sid, r->in.sid );
2204
2205 for ( i=0; i < r->in.rights->count; i++ ) {
2206
2207 const char *privname = r->in.rights->names[i].string;
2208
2209 /* only try to add non-null strings */
2210
2211 if ( !privname )
2212 continue;
2213
2214 if ( !grant_privilege_by_name( &sid, privname ) ) {
2215 DEBUG(2,("_lsa_AddAccountRights: Failed to add privilege [%s]\n",
2216 privname ));
2217 return NT_STATUS_NO_SUCH_PRIVILEGE;
2218 }
2219 }
2220
2221 return NT_STATUS_OK;
2222 }
2223
2224 /***************************************************************************
2225 _lsa_RemoveAccountRights
2226 ***************************************************************************/
2227
2228 NTSTATUS _lsa_RemoveAccountRights(pipes_struct *p,
2229 struct lsa_RemoveAccountRights *r)
2230 {
2231 struct lsa_info *info = NULL;
2232 int i = 0;
2233 SEC_DESC *psd = NULL;
2234 size_t sd_size;
2235 DOM_SID sid;
2236 const char *privname = NULL;
2237 uint32_t acc_granted = 0;
2238 NTSTATUS status;
2239
2240 /* find the connection policy handle. */
2241 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2242 return NT_STATUS_INVALID_HANDLE;
2243
2244 if (info->type != LSA_HANDLE_POLICY_TYPE) {
2245 return NT_STATUS_INVALID_HANDLE;
2246 }
2247
2248 /* get the generic lsa account SD for this SID until we store it */
2249 status = make_lsa_object_sd(p->mem_ctx, &psd, &sd_size,
2250 &lsa_account_mapping,
2251 r->in.sid, LSA_ACCOUNT_ALL_ACCESS);
2252 if (!NT_STATUS_IS_OK(status)) {
2253 return status;
2254 }
2255
2256 /*
2257 * From the MS DOCs. We need
2258 * LSA_ACCOUNT_ADJUST_PRIVILEGES|LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS|LSA_ACCOUNT_VIEW
2259 * and DELETE on the account sid.
2260 */
2261
2262 status = access_check_object(psd, p->server_info->ptok,
2263 NULL, 0,
2264 LSA_ACCOUNT_ADJUST_PRIVILEGES|LSA_ACCOUNT_ADJUST_SYSTEM_ACCESS|
2265 LSA_ACCOUNT_VIEW|STD_RIGHT_DELETE_ACCESS,
2266 &acc_granted, "_lsa_RemoveAccountRights");
2267 if (!NT_STATUS_IS_OK(status)) {
2268 return status;
2269 }
2270
2271 sid_copy( &sid, r->in.sid );
2272
2273 if ( r->in.remove_all ) {
2274 if ( !revoke_all_privileges( &sid ) )
2275 return NT_STATUS_ACCESS_DENIED;
2276
2277 return NT_STATUS_OK;
2278 }
2279
2280 for ( i=0; i < r->in.rights->count; i++ ) {
2281
2282 privname = r->in.rights->names[i].string;
2283
2284 /* only try to add non-null strings */
2285
2286 if ( !privname )
2287 continue;
2288
2289 if ( !revoke_privilege_by_name( &sid, privname ) ) {
2290 DEBUG(2,("_lsa_RemoveAccountRights: Failed to revoke privilege [%s]\n",
2291 privname ));
2292 return NT_STATUS_NO_SUCH_PRIVILEGE;
2293 }
2294 }
2295
2296 return NT_STATUS_OK;
2297 }
2298
2299 /*******************************************************************
2300 ********************************************************************/
2301
2302 static NTSTATUS init_lsa_right_set(TALLOC_CTX *mem_ctx,
2303 struct lsa_RightSet *r,
2304 PRIVILEGE_SET *privileges)
2305 {
2306 uint32 i;
2307 const char *privname;
2308 const char **privname_array = NULL;
2309 int num_priv = 0;
2310
2311 for (i=0; i<privileges->count; i++) {
2312
2313 privname = luid_to_privilege_name(&privileges->set[i].luid);
2314 if (privname) {
2315 if (!add_string_to_array(mem_ctx, privname,
2316 &privname_array, &num_priv)) {
2317 return NT_STATUS_NO_MEMORY;
2318 }
2319 }
2320 }
2321
2322 if (num_priv) {
2323
2324 r->names = TALLOC_ZERO_ARRAY(mem_ctx, struct lsa_StringLarge,
2325 num_priv);
2326 if (!r->names) {
2327 return NT_STATUS_NO_MEMORY;
2328 }
2329
2330 for (i=0; i<num_priv; i++) {
2331 init_lsa_StringLarge(&r->names[i], privname_array[i]);
2332 }
2333
2334 r->count = num_priv;
2335 }
2336
2337 return NT_STATUS_OK;
2338 }
2339
2340 /***************************************************************************
2341 _lsa_EnumAccountRights
2342 ***************************************************************************/
2343
2344 NTSTATUS _lsa_EnumAccountRights(pipes_struct *p,
2345 struct lsa_EnumAccountRights *r)
2346 {
2347 NTSTATUS status;
2348 struct lsa_info *info = NULL;
2349 DOM_SID sid;
2350 PRIVILEGE_SET privileges;
2351 SE_PRIV mask;
2352
2353 /* find the connection policy handle. */
2354
2355 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2356 return NT_STATUS_INVALID_HANDLE;
2357
2358 if (info->type != LSA_HANDLE_POLICY_TYPE) {
2359 return NT_STATUS_INVALID_HANDLE;
2360 }
2361
2362 if (!(info->access & LSA_ACCOUNT_VIEW)) {
2363 return NT_STATUS_ACCESS_DENIED;
2364 }
2365
2366 /* according to an NT4 PDC, you can add privileges to SIDs even without
2367 call_lsa_create_account() first. And you can use any arbitrary SID. */
2368
2369 sid_copy( &sid, r->in.sid );
2370
2371 /* according to MS-LSAD 3.1.4.5.10 it is required to return
2372 * NT_STATUS_OBJECT_NAME_NOT_FOUND if the account sid was not found in
2373 * the lsa database */
2374
2375 if (!get_privileges_for_sids(&mask, &sid, 1)) {
2376 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
2377 }
2378
2379 status = privilege_set_init(&privileges);
2380 if (!NT_STATUS_IS_OK(status)) {
2381 return status;
2382 }
2383
2384 se_priv_to_privilege_set(&privileges, &mask);
2385
2386 DEBUG(10,("_lsa_EnumAccountRights: %s has %d privileges\n",
2387 sid_string_dbg(&sid), privileges.count));
2388
2389 status = init_lsa_right_set(p->mem_ctx, r->out.rights, &privileges);
2390
2391 privilege_set_free( &privileges );
2392
2393 return status;
2394 }
2395
2396 /***************************************************************************
2397 _lsa_LookupPrivValue
2398 ***************************************************************************/
2399
2400 NTSTATUS _lsa_LookupPrivValue(pipes_struct *p,
2401 struct lsa_LookupPrivValue *r)
2402 {
2403 struct lsa_info *info = NULL;
2404 const char *name = NULL;
2405 LUID_ATTR priv_luid;
2406 SE_PRIV mask;
2407
2408 /* find the connection policy handle. */
2409
2410 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info))
2411 return NT_STATUS_INVALID_HANDLE;
2412
2413 if (info->type != LSA_HANDLE_POLICY_TYPE) {
2414 return NT_STATUS_INVALID_HANDLE;
2415 }
2416
2417 if (!(info->access & LSA_POLICY_LOOKUP_NAMES))
2418 return NT_STATUS_ACCESS_DENIED;
2419
2420 name = r->in.name->string;
2421
2422 DEBUG(10,("_lsa_lookup_priv_value: name = %s\n", name));
2423
2424 if ( !se_priv_from_name( name, &mask ) )
2425 return NT_STATUS_NO_SUCH_PRIVILEGE;
2426
2427 priv_luid = get_privilege_luid( &mask );
2428
2429 r->out.luid->low = priv_luid.luid.low;
2430 r->out.luid->high = priv_luid.luid.high;
2431
2432 return NT_STATUS_OK;
2433 }
2434
2435 /***************************************************************************
2436 _lsa_EnumAccountsWithUserRight
2437 ***************************************************************************/
2438
2439 NTSTATUS _lsa_EnumAccountsWithUserRight(pipes_struct *p,
2440 struct lsa_EnumAccountsWithUserRight *r)
2441 {
2442 NTSTATUS status;
2443 struct lsa_info *info = NULL;
2444 struct dom_sid *sids = NULL;
2445 int num_sids = 0;
2446 uint32_t i;
2447 SE_PRIV mask;
2448
2449 if (!find_policy_by_hnd(p, r->in.handle, (void **)(void *)&info)) {
2450 return NT_STATUS_INVALID_HANDLE;
2451 }
2452
2453 if (info->type != LSA_HANDLE_POLICY_TYPE) {
2454 return NT_STATUS_INVALID_HANDLE;
2455 }
2456
2457 if (!(info->access & LSA_POLICY_LOOKUP_NAMES)) {
2458 return NT_STATUS_ACCESS_DENIED;
2459 }
2460
2461 if (!r->in.name || !r->in.name->string) {
2462 return NT_STATUS_NO_SUCH_PRIVILEGE;
2463 }
2464
2465 if (!se_priv_from_name(r->in.name->string, &mask)) {
2466 return NT_STATUS_NO_SUCH_PRIVILEGE;
2467 }
2468
2469 status = privilege_enum_sids(&mask, p->mem_ctx,
2470 &sids, &num_sids);
2471 if (!NT_STATUS_IS_OK(status)) {
2472 return status;
2473 }
2474
2475 r->out.sids->num_sids = num_sids;
2476 r->out.sids->sids = talloc_array(p->mem_ctx, struct lsa_SidPtr,
2477 r->out.sids->num_sids);
2478
2479 for (i=0; i < r->out.sids->num_sids; i++) {
2480 r->out.sids->sids[i].sid = sid_dup_talloc(r->out.sids->sids,
2481 &sids[i]);
2482 if (!r->out.sids->sids[i].sid) {
2483 TALLOC_FREE(r->out.sids->sids);
2484 r->out.sids->num_sids = 0;
2485 return NT_STATUS_NO_MEMORY;
2486 }
2487 }
2488
2489 return NT_STATUS_OK;
2490 }
2491
2492 /***************************************************************************
2493 _lsa_Delete
2494 ***************************************************************************/
2495
2496 NTSTATUS _lsa_Delete(pipes_struct *p,
2497 struct lsa_Delete *r)
2498 {
2499 return NT_STATUS_NOT_SUPPORTED;
2500 }
2501
2502 /*
2503 * From here on the server routines are just dummy ones to make smbd link with
2504 * librpc/gen_ndr/srv_lsa.c. These routines are actually never called, we are
2505 * pulling the server stubs across one by one.
2506 */
2507
2508 NTSTATUS _lsa_SetSecObj(pipes_struct *p, struct lsa_SetSecObj *r)
2509 {
2510 p->rng_fault_state = True;
2511 return NT_STATUS_NOT_IMPLEMENTED;
2512 }
2513
2514 NTSTATUS _lsa_ChangePassword(pipes_struct *p, struct lsa_ChangePassword *r)
2515 {
2516 p->rng_fault_state = True;
2517 return NT_STATUS_NOT_IMPLEMENTED;
2518 }
2519
2520 NTSTATUS _lsa_SetInfoPolicy(pipes_struct *p, struct lsa_SetInfoPolicy *r)
2521 {
2522 p->rng_fault_state = True;
2523 return NT_STATUS_NOT_IMPLEMENTED;
2524 }
2525
2526 NTSTATUS _lsa_ClearAuditLog(pipes_struct *p, struct lsa_ClearAuditLog *r)
2527 {
2528 p->rng_fault_state = True;
2529 return NT_STATUS_NOT_IMPLEMENTED;
2530 }
2531
2532 NTSTATUS _lsa_GetQuotasForAccount(pipes_struct *p, struct lsa_GetQuotasForAccount *r)
2533 {
2534 p->rng_fault_state = True;
2535 return NT_STATUS_NOT_IMPLEMENTED;
2536 }
2537
2538 NTSTATUS _lsa_SetQuotasForAccount(pipes_struct *p, struct lsa_SetQuotasForAccount *r)
2539 {
2540 p->rng_fault_state = True;
2541 return NT_STATUS_NOT_IMPLEMENTED;
2542 }
2543
2544 NTSTATUS _lsa_QueryTrustedDomainInfo(pipes_struct *p, struct lsa_QueryTrustedDomainInfo *r)
2545 {
2546 p->rng_fault_state = True;
2547 return NT_STATUS_NOT_IMPLEMENTED;
2548 }
2549
2550 NTSTATUS _lsa_SetInformationTrustedDomain(pipes_struct *p, struct lsa_SetInformationTrustedDomain *r)
2551 {
2552 p->rng_fault_state = True;
2553 return NT_STATUS_NOT_IMPLEMENTED;
2554 }
2555
2556 NTSTATUS _lsa_QuerySecret(pipes_struct *p, struct lsa_QuerySecret *r)
2557 {
2558 p->rng_fault_state = True;
2559 return NT_STATUS_NOT_IMPLEMENTED;
2560 }
2561
2562 NTSTATUS _lsa_QueryTrustedDomainInfoBySid(pipes_struct *p, struct lsa_QueryTrustedDomainInfoBySid *r)
2563 {
2564 p->rng_fault_state = True;
2565 return NT_STATUS_NOT_IMPLEMENTED;
2566 }
2567
2568 NTSTATUS _lsa_SetTrustedDomainInfo(pipes_struct *p, struct lsa_SetTrustedDomainInfo *r)
2569 {
2570 p->rng_fault_state = True;
2571 return NT_STATUS_NOT_IMPLEMENTED;
2572 }
2573
2574 NTSTATUS _lsa_DeleteTrustedDomain(pipes_struct *p, struct lsa_DeleteTrustedDomain *r)
2575 {
2576 p->rng_fault_state = True;
2577 return NT_STATUS_NOT_IMPLEMENTED;
2578 }
2579
2580 NTSTATUS _lsa_StorePrivateData(pipes_struct *p, struct lsa_StorePrivateData *r)
2581 {
2582 p->rng_fault_state = True;
2583 return NT_STATUS_NOT_IMPLEMENTED;
2584 }
2585
2586 NTSTATUS _lsa_RetrievePrivateData(pipes_struct *p, struct lsa_RetrievePrivateData *r)
2587 {
2588 p->rng_fault_state = True;
2589 return NT_STATUS_NOT_IMPLEMENTED;
2590 }
2591
2592 NTSTATUS _lsa_SetInfoPolicy2(pipes_struct *p, struct lsa_SetInfoPolicy2 *r)
2593 {
2594 p->rng_fault_state = True;
2595 return NT_STATUS_NOT_IMPLEMENTED;
2596 }
2597
2598 NTSTATUS _lsa_QueryTrustedDomainInfoByName(pipes_struct *p, struct lsa_QueryTrustedDomainInfoByName *r)
2599 {
2600 p->rng_fault_state = True;
2601 return NT_STATUS_NOT_IMPLEMENTED;
2602 }
2603
2604 NTSTATUS _lsa_SetTrustedDomainInfoByName(pipes_struct *p, struct lsa_SetTrustedDomainInfoByName *r)
2605 {
2606 p->rng_fault_state = True;
2607 return NT_STATUS_NOT_IMPLEMENTED;
2608 }
2609
2610 NTSTATUS _lsa_EnumTrustedDomainsEx(pipes_struct *p, struct lsa_EnumTrustedDomainsEx *r)
2611 {
2612 p->rng_fault_state = True;
2613 return NT_STATUS_NOT_IMPLEMENTED;
2614 }
2615
2616 NTSTATUS _lsa_CreateTrustedDomainEx(pipes_struct *p, struct lsa_CreateTrustedDomainEx *r)
2617 {
2618 p->rng_fault_state = True;
2619 return NT_STATUS_NOT_IMPLEMENTED;
2620 }
2621
2622 NTSTATUS _lsa_CloseTrustedDomainEx(pipes_struct *p, struct lsa_CloseTrustedDomainEx *r)
2623 {
2624 p->rng_fault_state = True;
2625 return NT_STATUS_NOT_IMPLEMENTED;
2626 }
2627
2628 NTSTATUS _lsa_QueryDomainInformationPolicy(pipes_struct *p, struct lsa_QueryDomainInformationPolicy *r)
2629 {
2630 p->rng_fault_state = True;
2631 return NT_STATUS_NOT_IMPLEMENTED;
2632 }
2633
2634 NTSTATUS _lsa_SetDomainInformationPolicy(pipes_struct *p, struct lsa_SetDomainInformationPolicy *r)
2635 {
2636 p->rng_fault_state = True;
2637 return NT_STATUS_NOT_IMPLEMENTED;
2638 }
2639
2640 NTSTATUS _lsa_OpenTrustedDomainByName(pipes_struct *p, struct lsa_OpenTrustedDomainByName *r)
2641 {
2642 p->rng_fault_state = True;
2643 return NT_STATUS_NOT_IMPLEMENTED;
2644 }
2645
2646 NTSTATUS _lsa_TestCall(pipes_struct *p, struct lsa_TestCall *r)
2647 {
2648 p->rng_fault_state = True;
2649 return NT_STATUS_NOT_IMPLEMENTED;
2650 }
2651
2652 NTSTATUS _lsa_CreateTrustedDomainEx2(pipes_struct *p, struct lsa_CreateTrustedDomainEx2 *r)
2653 {
2654 p->rng_fault_state = True;
2655 return NT_STATUS_NOT_IMPLEMENTED;
2656 }
2657
2658 NTSTATUS _lsa_CREDRWRITE(pipes_struct *p, struct lsa_CREDRWRITE *r)
2659 {
2660 p->rng_fault_state = True;
2661 return NT_STATUS_NOT_IMPLEMENTED;
2662 }
2663
2664 NTSTATUS _lsa_CREDRREAD(pipes_struct *p, struct lsa_CREDRREAD *r)
2665 {
2666 p->rng_fault_state = True;
2667 return NT_STATUS_NOT_IMPLEMENTED;
2668 }
2669
2670 NTSTATUS _lsa_CREDRENUMERATE(pipes_struct *p, struct lsa_CREDRENUMERATE *r)
2671 {
2672 p->rng_fault_state = True;
2673 return NT_STATUS_NOT_IMPLEMENTED;
2674 }
2675
2676 NTSTATUS _lsa_CREDRWRITEDOMAINCREDENTIALS(pipes_struct *p, struct lsa_CREDRWRITEDOMAINCREDENTIALS *r)
2677 {
2678 p->rng_fault_state = True;
2679 return NT_STATUS_NOT_IMPLEMENTED;
2680 }
2681
2682 NTSTATUS _lsa_CREDRREADDOMAINCREDENTIALS(pipes_struct *p, struct lsa_CREDRREADDOMAINCREDENTIALS *r)
2683 {
2684 p->rng_fault_state = True;
2685 return NT_STATUS_NOT_IMPLEMENTED;
2686 }
2687
2688 NTSTATUS _lsa_CREDRDELETE(pipes_struct *p, struct lsa_CREDRDELETE *r)
2689 {
2690 p->rng_fault_state = True;
2691 return NT_STATUS_NOT_IMPLEMENTED;
2692 }
2693
2694 NTSTATUS _lsa_CREDRGETTARGETINFO(pipes_struct *p, struct lsa_CREDRGETTARGETINFO *r)
2695 {
2696 p->rng_fault_state = True;
2697 return NT_STATUS_NOT_IMPLEMENTED;
2698 }
2699
2700 NTSTATUS _lsa_CREDRPROFILELOADED(pipes_struct *p, struct lsa_CREDRPROFILELOADED *r)
2701 {
2702 p->rng_fault_state = True;
2703 return NT_STATUS_NOT_IMPLEMENTED;
2704 }
2705
2706 NTSTATUS _lsa_CREDRGETSESSIONTYPES(pipes_struct *p, struct lsa_CREDRGETSESSIONTYPES *r)
2707 {
2708 p->rng_fault_state = True;
2709 return NT_STATUS_NOT_IMPLEMENTED;
2710 }
2711
2712 NTSTATUS _lsa_LSARREGISTERAUDITEVENT(pipes_struct *p, struct lsa_LSARREGISTERAUDITEVENT *r)
2713 {
2714 p->rng_fault_state = True;
2715 return NT_STATUS_NOT_IMPLEMENTED;
2716 }
2717
2718 NTSTATUS _lsa_LSARGENAUDITEVENT(pipes_struct *p, struct lsa_LSARGENAUDITEVENT *r)
2719 {
2720 p->rng_fault_state = True;
2721 return NT_STATUS_NOT_IMPLEMENTED;
2722 }
2723
2724 NTSTATUS _lsa_LSARUNREGISTERAUDITEVENT(pipes_struct *p, struct lsa_LSARUNREGISTERAUDITEVENT *r)
2725 {
2726 p->rng_fault_state = True;
2727 return NT_STATUS_NOT_IMPLEMENTED;
2728 }
2729
2730 NTSTATUS _lsa_lsaRQueryForestTrustInformation(pipes_struct *p, struct lsa_lsaRQueryForestTrustInformation *r)
2731 {
2732 p->rng_fault_state = True;
2733 return NT_STATUS_NOT_IMPLEMENTED;
2734 }
2735
2736 NTSTATUS _lsa_LSARSETFORESTTRUSTINFORMATION(pipes_struct *p, struct lsa_LSARSETFORESTTRUSTINFORMATION *r)
2737 {
2738 p->rng_fault_state = True;
2739 return NT_STATUS_NOT_IMPLEMENTED;
2740 }
2741
2742 NTSTATUS _lsa_CREDRRENAME(pipes_struct *p, struct lsa_CREDRRENAME *r)
2743 {
2744 p->rng_fault_state = True;
2745 return NT_STATUS_NOT_IMPLEMENTED;
2746 }
2747
2748 NTSTATUS _lsa_LSAROPENPOLICYSCE(pipes_struct *p, struct lsa_LSAROPENPOLICYSCE *r)
2749 {
2750 p->rng_fault_state = True;
2751 return NT_STATUS_NOT_IMPLEMENTED;
2752 }
2753
2754 NTSTATUS _lsa_LSARADTREGISTERSECURITYEVENTSOURCE(pipes_struct *p, struct lsa_LSARADTREGISTERSECURITYEVENTSOURCE *r)
2755 {
2756 p->rng_fault_state = True;
2757 return NT_STATUS_NOT_IMPLEMENTED;
2758 }
2759
2760 NTSTATUS _lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE(pipes_struct *p, struct lsa_LSARADTUNREGISTERSECURITYEVENTSOURCE *r)
2761 {
2762 p->rng_fault_state = True;
2763 return NT_STATUS_NOT_IMPLEMENTED;
2764 }
2765
2766 NTSTATUS _lsa_LSARADTREPORTSECURITYEVENT(pipes_struct *p, struct lsa_LSARADTREPORTSECURITYEVENT *r)
2767 {
2768 p->rng_fault_state = True;
2769 return NT_STATUS_NOT_IMPLEMENTED;
2770 }
Samba GIT mirror