?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
First round of merging various UUID structures.
[Samba/gebeck_regimport.git] / source3 / rpc_server / srv_lsa_nt.c
blob0a8ad404cb3ccfd9d5c811e33d3c4c18c10815cd
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,
8 * Copyright (C) Rafal Szczesniak 2002,
9 * Copyright (C) Jim McDonough <jmcd@us.ibm.com> 2002.
10 *
11 * This program is free software; you can redistribute it and/or modify
12 * it under the terms of the GNU General Public License as published by
13 * the Free Software Foundation; either version 2 of the License, or
14 * (at your option) any later version.
15 *
16 * This program is distributed in the hope that it will be useful,
17 * but WITHOUT ANY WARRANTY; without even the implied warranty of
18 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19 * GNU General Public License for more details.
20 *
21 * You should have received a copy of the GNU General Public License
22 * along with this program; if not, write to the Free Software
23 * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
24 */
25
26 /* This is the implementation of the lsa server code. */
27
28 #include "includes.h"
29
30 #undef DBGC_CLASS
31 #define DBGC_CLASS DBGC_RPC_SRV
32
33 extern PRIVS privs[];
34
35 struct lsa_info {
36 DOM_SID sid;
37 uint32 access;
38 };
39
40 struct generic_mapping lsa_generic_mapping = {
41 POLICY_READ,
42 POLICY_WRITE,
43 POLICY_EXECUTE,
44 POLICY_ALL_ACCESS
45 };
46
47 /*******************************************************************
48 Function to free the per handle data.
49 ********************************************************************/
50
51 static void free_lsa_info(void *ptr)
52 {
53 struct lsa_info *lsa = (struct lsa_info *)ptr;
54
55 SAFE_FREE(lsa);
56 }
57
58 /***************************************************************************
59 Init dom_query
60 ***************************************************************************/
61
62 static void init_dom_query(DOM_QUERY *d_q, const char *dom_name, DOM_SID *dom_sid)
63 {
64 d_q->buffer_dom_name = (dom_name != NULL) ? 1 : 0; /* domain buffer pointer */
65 d_q->buffer_dom_sid = (dom_sid != NULL) ? 1 : 0; /* domain sid pointer */
66
67 /* this string is supposed to be non-null terminated. */
68 /* But the maxlen in this UNISTR2 must include the terminating null. */
69 init_unistr2(&d_q->uni_domain_name, dom_name, UNI_MAXLEN_TERMINATE);
70
71 /*
72 * I'm not sure why this really odd combination of length
73 * values works, but it does appear to. I need to look at
74 * this *much* more closely - but at the moment leave alone
75 * until it's understood. This allows a W2k client to join
76 * a domain with both odd and even length names... JRA.
77 */
78
79 /*
80 * IMPORTANT NOTE !!!!
81 * The two fields below probably are reversed in meaning, ie.
82 * the first field is probably the str_len, the second the max
83 * len. Both are measured in bytes anyway.
84 */
85
86 d_q->uni_dom_str_len = d_q->uni_domain_name.uni_max_len * 2;
87 d_q->uni_dom_max_len = d_q->uni_domain_name.uni_str_len * 2;
88
89 if (dom_sid != NULL)
90 init_dom_sid2(&d_q->dom_sid, dom_sid);
91 }
92
93 /***************************************************************************
94 init_dom_ref - adds a domain if it's not already in, returns the index.
95 ***************************************************************************/
96
97 static int init_dom_ref(DOM_R_REF *ref, char *dom_name, DOM_SID *dom_sid)
98 {
99 int num = 0;
100
101 if (dom_name != NULL) {
102 for (num = 0; num < ref->num_ref_doms_1; num++) {
103 fstring domname;
104 rpcstr_pull(domname, &ref->ref_dom[num].uni_dom_name, sizeof(domname), -1, 0);
105 if (strequal(domname, dom_name))
106 return num;
107 }
108 } else {
109 num = ref->num_ref_doms_1;
110 }
111
112 if (num >= MAX_REF_DOMAINS) {
113 /* index not found, already at maximum domain limit */
114 return -1;
115 }
116
117 ref->num_ref_doms_1 = num+1;
118 ref->ptr_ref_dom = 1;
119 ref->max_entries = MAX_REF_DOMAINS;
120 ref->num_ref_doms_2 = num+1;
121
122 ref->hdr_ref_dom[num].ptr_dom_sid = dom_sid != NULL ? 1 : 0;
123
124 init_unistr2(&ref->ref_dom[num].uni_dom_name, dom_name, UNI_FLAGS_NONE);
125 init_uni_hdr(&ref->hdr_ref_dom[num].hdr_dom_name, &ref->ref_dom[num].uni_dom_name);
126
127 init_dom_sid2(&ref->ref_dom[num].ref_dom, dom_sid );
128
129 return num;
130 }
131
132 /***************************************************************************
133 init_lsa_rid2s
134 ***************************************************************************/
135
136 static void init_lsa_rid2s(DOM_R_REF *ref, DOM_RID2 *rid2,
137 int num_entries, UNISTR2 *name,
138 uint32 *mapped_count, BOOL endian)
139 {
140 int i;
141 int total = 0;
142 *mapped_count = 0;
143
144 SMB_ASSERT(num_entries <= MAX_LOOKUP_SIDS);
145
146 become_root(); /* lookup_name can require root privs */
147
148 for (i = 0; i < num_entries; i++) {
149 BOOL status = False;
150 DOM_SID sid;
151 uint32 rid = 0xffffffff;
152 int dom_idx = -1;
153 pstring full_name;
154 fstring dom_name, user;
155 enum SID_NAME_USE name_type = SID_NAME_UNKNOWN;
156
157 /* Split name into domain and user component */
158
159 unistr2_to_ascii(full_name, &name[i], sizeof(full_name));
160 split_domain_name(full_name, dom_name, user);
161
162 /* Lookup name */
163
164 DEBUG(5, ("init_lsa_rid2s: looking up name %s\n", full_name));
165
166 status = lookup_name(dom_name, user, &sid, &name_type);
167
168 DEBUG(5, ("init_lsa_rid2s: %s\n", status ? "found" :
169 "not found"));
170
171 if (status && name_type != SID_NAME_UNKNOWN) {
172 sid_split_rid(&sid, &rid);
173 dom_idx = init_dom_ref(ref, dom_name, &sid);
174 (*mapped_count)++;
175 } else {
176 dom_idx = -1;
177 rid = 0xffffffff;
178 name_type = SID_NAME_UNKNOWN;
179 }
180
181 init_dom_rid2(&rid2[total], rid, name_type, dom_idx);
182 total++;
183 }
184
185 unbecome_root();
186 }
187
188 /***************************************************************************
189 init_reply_lookup_names
190 ***************************************************************************/
191
192 static void init_reply_lookup_names(LSA_R_LOOKUP_NAMES *r_l,
193 DOM_R_REF *ref, uint32 num_entries,
194 DOM_RID2 *rid2, uint32 mapped_count)
195 {
196 r_l->ptr_dom_ref = 1;
197 r_l->dom_ref = ref;
198
199 r_l->num_entries = num_entries;
200 r_l->ptr_entries = 1;
201 r_l->num_entries2 = num_entries;
202 r_l->dom_rid = rid2;
203
204 r_l->mapped_count = mapped_count;
205
206 if (mapped_count == 0)
207 r_l->status = NT_STATUS_NONE_MAPPED;
208 else
209 r_l->status = NT_STATUS_OK;
210 }
211
212 /***************************************************************************
213 Init lsa_trans_names.
214 ***************************************************************************/
215
216 static void init_lsa_trans_names(TALLOC_CTX *ctx, DOM_R_REF *ref, LSA_TRANS_NAME_ENUM *trn,
217 int num_entries, DOM_SID2 *sid,
218 uint32 *mapped_count)
219 {
220 int i;
221 int total = 0;
222 *mapped_count = 0;
223
224 /* Allocate memory for list of names */
225
226 if (num_entries > 0) {
227 if (!(trn->name = (LSA_TRANS_NAME *)talloc(ctx, sizeof(LSA_TRANS_NAME) *
228 num_entries))) {
229 DEBUG(0, ("init_lsa_trans_names(): out of memory\n"));
230 return;
231 }
232
233 if (!(trn->uni_name = (UNISTR2 *)talloc(ctx, sizeof(UNISTR2) *
234 num_entries))) {
235 DEBUG(0, ("init_lsa_trans_names(): out of memory\n"));
236 return;
237 }
238 }
239
240 become_root(); /* Need root to get to passdb to for local sids */
241
242 for (i = 0; i < num_entries; i++) {
243 BOOL status = False;
244 DOM_SID find_sid = sid[i].sid;
245 uint32 rid = 0xffffffff;
246 int dom_idx = -1;
247 fstring name, dom_name;
248 enum SID_NAME_USE sid_name_use = (enum SID_NAME_USE)0;
249
250 sid_to_string(name, &find_sid);
251 DEBUG(5, ("init_lsa_trans_names: looking up sid %s\n", name));
252
253 /* Lookup sid from winbindd */
254
255 memset(dom_name, '\0', sizeof(dom_name));
256 memset(name, '\0', sizeof(name));
257
258 status = lookup_sid(&find_sid, dom_name, name, &sid_name_use);
259
260 DEBUG(5, ("init_lsa_trans_names: %s\n", status ? "found" :
261 "not found"));
262
263 if (!status) {
264 sid_name_use = SID_NAME_UNKNOWN;
265 } else {
266 (*mapped_count)++;
267 }
268
269 /* Store domain sid in ref array */
270
271 if (find_sid.num_auths == 5) {
272 sid_split_rid(&find_sid, &rid);
273 }
274
275 dom_idx = init_dom_ref(ref, dom_name, &find_sid);
276
277 DEBUG(10,("init_lsa_trans_names: added user '%s\\%s' to "
278 "referenced list.\n", dom_name, name ));
279
280 init_lsa_trans_name(&trn->name[total], &trn->uni_name[total],
281 sid_name_use, name, dom_idx);
282 total++;
283 }
284
285 unbecome_root();
286
287 trn->num_entries = total;
288 trn->ptr_trans_names = 1;
289 trn->num_entries2 = total;
290 }
291
292 /***************************************************************************
293 Init_reply_lookup_sids.
294 ***************************************************************************/
295
296 static void init_reply_lookup_sids(LSA_R_LOOKUP_SIDS *r_l,
297 DOM_R_REF *ref, LSA_TRANS_NAME_ENUM *names,
298 uint32 mapped_count)
299 {
300 r_l->ptr_dom_ref = 1;
301 r_l->dom_ref = ref;
302 r_l->names = names;
303 r_l->mapped_count = mapped_count;
304
305 if (mapped_count == 0)
306 r_l->status = NT_STATUS_NONE_MAPPED;
307 else
308 r_l->status = NT_STATUS_OK;
309 }
310
311 static NTSTATUS lsa_get_generic_sd(TALLOC_CTX *mem_ctx, SEC_DESC **sd, size_t *sd_size)
312 {
313 extern DOM_SID global_sid_World;
314 extern DOM_SID global_sid_Builtin;
315 DOM_SID local_adm_sid;
316 DOM_SID adm_sid;
317
318 SEC_ACE ace[3];
319 SEC_ACCESS mask;
320
321 SEC_ACL *psa = NULL;
322
323 init_sec_access(&mask, POLICY_EXECUTE);
324 init_sec_ace(&ace[0], &global_sid_World, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
325
326 sid_copy(&adm_sid, get_global_sam_sid());
327 sid_append_rid(&adm_sid, DOMAIN_GROUP_RID_ADMINS);
328 init_sec_access(&mask, POLICY_ALL_ACCESS);
329 init_sec_ace(&ace[1], &adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
330
331 sid_copy(&local_adm_sid, &global_sid_Builtin);
332 sid_append_rid(&local_adm_sid, BUILTIN_ALIAS_RID_ADMINS);
333 init_sec_access(&mask, POLICY_ALL_ACCESS);
334 init_sec_ace(&ace[2], &local_adm_sid, SEC_ACE_TYPE_ACCESS_ALLOWED, mask, 0);
335
336 if((psa = make_sec_acl(mem_ctx, NT4_ACL_REVISION, 3, ace)) == NULL)
337 return NT_STATUS_NO_MEMORY;
338
339 if((*sd = make_sec_desc(mem_ctx, SEC_DESC_REVISION, SEC_DESC_SELF_RELATIVE, &adm_sid, NULL, NULL, psa, sd_size)) == NULL)
340 return NT_STATUS_NO_MEMORY;
341
342 return NT_STATUS_OK;
343 }
344
345 /***************************************************************************
346 Init_dns_dom_info.
347 ***************************************************************************/
348
349 static void init_dns_dom_info(LSA_DNS_DOM_INFO *r_l, const char *nb_name,
350 const char *dns_name, const char *forest_name,
351 GUID *dom_guid, DOM_SID *dom_sid)
352 {
353 if (nb_name && *nb_name) {
354 init_unistr2(&r_l->uni_nb_dom_name, nb_name, UNI_FLAGS_NONE);
355 init_uni_hdr(&r_l->hdr_nb_dom_name, &r_l->uni_nb_dom_name);
356 r_l->hdr_nb_dom_name.uni_max_len += 2;
357 r_l->uni_nb_dom_name.uni_max_len += 1;
358 }
359
360 if (dns_name && *dns_name) {
361 init_unistr2(&r_l->uni_dns_dom_name, dns_name, UNI_FLAGS_NONE);
362 init_uni_hdr(&r_l->hdr_dns_dom_name, &r_l->uni_dns_dom_name);
363 r_l->hdr_dns_dom_name.uni_max_len += 2;
364 r_l->uni_dns_dom_name.uni_max_len += 1;
365 }
366
367 if (forest_name && *forest_name) {
368 init_unistr2(&r_l->uni_forest_name, forest_name, UNI_FLAGS_NONE);
369 init_uni_hdr(&r_l->hdr_forest_name, &r_l->uni_forest_name);
370 r_l->hdr_forest_name.uni_max_len += 2;
371 r_l->uni_forest_name.uni_max_len += 1;
372 }
373
374 /* how do we init the guid ? probably should write an init fn */
375 if (dom_guid) {
376 memcpy(&r_l->dom_guid, dom_guid, sizeof(GUID));
377 }
378
379 if (dom_sid) {
380 r_l->ptr_dom_sid = 1;
381 init_dom_sid2(&r_l->dom_sid, dom_sid);
382 }
383 }
384
385 /***************************************************************************
386 _lsa_open_policy2.
387 ***************************************************************************/
388
389 NTSTATUS _lsa_open_policy2(pipes_struct *p, LSA_Q_OPEN_POL2 *q_u, LSA_R_OPEN_POL2 *r_u)
390 {
391 struct lsa_info *info;
392 SEC_DESC *psd = NULL;
393 size_t sd_size;
394 uint32 des_access=q_u->des_access;
395 uint32 acc_granted;
396 NTSTATUS status;
397
398
399 /* map the generic bits to the lsa policy ones */
400 se_map_generic(&des_access, &lsa_generic_mapping);
401
402 /* get the generic lsa policy SD until we store it */
403 lsa_get_generic_sd(p->mem_ctx, &psd, &sd_size);
404
405 if(!se_access_check(psd, p->pipe_user.nt_user_token, des_access, &acc_granted, &status)) {
406 if (geteuid() != 0) {
407 return status;
408 }
409 DEBUG(4,("ACCESS should be DENIED (granted: %#010x; required: %#010x)\n",
410 acc_granted, des_access));
411 DEBUGADD(4,("but overwritten by euid == 0\n"));
412 acc_granted = des_access;
413 }
414
415
416 /* associate the domain SID with the (unique) handle. */
417 if ((info = (struct lsa_info *)malloc(sizeof(struct lsa_info))) == NULL)
418 return NT_STATUS_NO_MEMORY;
419
420 ZERO_STRUCTP(info);
421 sid_copy(&info->sid,get_global_sam_sid());
422 info->access = acc_granted;
423
424 /* set up the LSA QUERY INFO response */
425 if (!create_policy_hnd(p, &r_u->pol, free_lsa_info, (void *)info))
426 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
427
428 return NT_STATUS_OK;
429 }
430
431 /***************************************************************************
432 _lsa_open_policy
433 ***************************************************************************/
434
435 NTSTATUS _lsa_open_policy(pipes_struct *p, LSA_Q_OPEN_POL *q_u, LSA_R_OPEN_POL *r_u)
436 {
437 struct lsa_info *info;
438 SEC_DESC *psd = NULL;
439 size_t sd_size;
440 uint32 des_access=q_u->des_access;
441 uint32 acc_granted;
442 NTSTATUS status;
443
444
445 /* map the generic bits to the lsa policy ones */
446 se_map_generic(&des_access, &lsa_generic_mapping);
447
448 /* get the generic lsa policy SD until we store it */
449 lsa_get_generic_sd(p->mem_ctx, &psd, &sd_size);
450
451 if(!se_access_check(psd, p->pipe_user.nt_user_token, des_access, &acc_granted, &status)) {
452 if (geteuid() != 0) {
453 return status;
454 }
455 DEBUG(4,("ACCESS should be DENIED (granted: %#010x; required: %#010x)\n",
456 acc_granted, des_access));
457 DEBUGADD(4,("but overwritten by euid == 0\n"));
458 acc_granted = des_access;
459 }
460
461 /* associate the domain SID with the (unique) handle. */
462 if ((info = (struct lsa_info *)malloc(sizeof(struct lsa_info))) == NULL)
463 return NT_STATUS_NO_MEMORY;
464
465 ZERO_STRUCTP(info);
466 sid_copy(&info->sid,get_global_sam_sid());
467 info->access = acc_granted;
468
469 /* set up the LSA QUERY INFO response */
470 if (!create_policy_hnd(p, &r_u->pol, free_lsa_info, (void *)info))
471 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
472
473 return NT_STATUS_OK;
474 }
475
476 /***************************************************************************
477 _lsa_enum_trust_dom - this needs fixing to do more than return NULL ! JRA.
478 ufff, done :) mimir
479 ***************************************************************************/
480
481 NTSTATUS _lsa_enum_trust_dom(pipes_struct *p, LSA_Q_ENUM_TRUST_DOM *q_u, LSA_R_ENUM_TRUST_DOM *r_u)
482 {
483 struct lsa_info *info;
484 uint32 enum_context = q_u->enum_context;
485
486 /*
487 * preferred length is set to 5 as a "our" preferred length
488 * nt sets this parameter to 2
489 * update (20.08.2002): it's not preferred length, but preferred size!
490 * it needs further investigation how to optimally choose this value
491 */
492 uint32 max_num_domains = q_u->preferred_len < 5 ? q_u->preferred_len : 10;
493 TRUSTDOM **trust_doms;
494 uint32 num_domains;
495 NTSTATUS nt_status;
496
497 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
498 return NT_STATUS_INVALID_HANDLE;
499
500 /* check if the user have enough rights */
501 if (!(info->access & POLICY_VIEW_LOCAL_INFORMATION))
502 return NT_STATUS_ACCESS_DENIED;
503
504 nt_status = secrets_get_trusted_domains(p->mem_ctx, (int *)&enum_context, max_num_domains, (int *)&num_domains, &trust_doms);
505
506 if (!NT_STATUS_IS_OK(nt_status) &&
507 !NT_STATUS_EQUAL(nt_status, STATUS_MORE_ENTRIES) &&
508 !NT_STATUS_EQUAL(nt_status, NT_STATUS_NO_MORE_ENTRIES)) {
509 return nt_status;
510 } else {
511 r_u->status = nt_status;
512 }
513
514 /* set up the lsa_enum_trust_dom response */
515 init_r_enum_trust_dom(p->mem_ctx, r_u, enum_context, max_num_domains, num_domains, trust_doms);
516
517 return r_u->status;
518 }
519
520 /***************************************************************************
521 _lsa_query_info. See the POLICY_INFOMATION_CLASS docs at msdn.
522 ***************************************************************************/
523
524 NTSTATUS _lsa_query_info(pipes_struct *p, LSA_Q_QUERY_INFO *q_u, LSA_R_QUERY_INFO *r_u)
525 {
526 struct lsa_info *handle;
527 LSA_INFO_UNION *info = &r_u->dom;
528 DOM_SID domain_sid;
529 const char *name;
530 DOM_SID *sid = NULL;
531
532 r_u->status = NT_STATUS_OK;
533
534 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle))
535 return NT_STATUS_INVALID_HANDLE;
536
537 switch (q_u->info_class) {
538 case 0x02:
539 {
540 unsigned int i;
541 /* check if the user have enough rights */
542 if (!(handle->access & POLICY_VIEW_AUDIT_INFORMATION))
543 return NT_STATUS_ACCESS_DENIED;
544
545 /* fake info: We audit everything. ;) */
546 info->id2.auditing_enabled = 1;
547 info->id2.count1 = 7;
548 info->id2.count2 = 7;
549 if ((info->id2.auditsettings = (uint32 *)talloc(p->mem_ctx,7*sizeof(uint32))) == NULL)
550 return NT_STATUS_NO_MEMORY;
551 for (i = 0; i < 7; i++)
552 info->id2.auditsettings[i] = 3;
553 break;
554 }
555 case 0x03:
556 /* check if the user have enough rights */
557 if (!(handle->access & POLICY_VIEW_LOCAL_INFORMATION))
558 return NT_STATUS_ACCESS_DENIED;
559
560 /* Request PolicyPrimaryDomainInformation. */
561 switch (lp_server_role()) {
562 case ROLE_DOMAIN_PDC:
563 case ROLE_DOMAIN_BDC:
564 name = get_global_sam_name();
565 sid = get_global_sam_sid();
566 break;
567 case ROLE_DOMAIN_MEMBER:
568 name = lp_workgroup();
569 /* We need to return the Domain SID here. */
570 if (secrets_fetch_domain_sid(lp_workgroup(), &domain_sid))
571 sid = &domain_sid;
572 else
573 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
574 break;
575 case ROLE_STANDALONE:
576 name = lp_workgroup();
577 sid = NULL;
578 break;
579 default:
580 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
581 }
582 init_dom_query(&r_u->dom.id3, name, sid);
583 break;
584 case 0x05:
585 /* check if the user have enough rights */
586 if (!(handle->access & POLICY_VIEW_LOCAL_INFORMATION))
587 return NT_STATUS_ACCESS_DENIED;
588
589 /* Request PolicyAccountDomainInformation. */
590 name = get_global_sam_name();
591 sid = get_global_sam_sid();
592 init_dom_query(&r_u->dom.id5, name, sid);
593 break;
594 case 0x06:
595 /* check if the user have enough rights */
596 if (!(handle->access & POLICY_VIEW_LOCAL_INFORMATION))
597 return NT_STATUS_ACCESS_DENIED;
598
599 switch (lp_server_role()) {
600 case ROLE_DOMAIN_BDC:
601 /*
602 * only a BDC is a backup controller
603 * of the domain, it controls.
604 */
605 info->id6.server_role = 2;
606 break;
607 default:
608 /*
609 * any other role is a primary
610 * of the domain, it controls.
611 */
612 info->id6.server_role = 3;
613 break;
614 }
615 break;
616 default:
617 DEBUG(0,("_lsa_query_info: unknown info level in Lsa Query: %d\n", q_u->info_class));
618 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
619 break;
620 }
621
622 if (NT_STATUS_IS_OK(r_u->status)) {
623 r_u->undoc_buffer = 0x22000000; /* bizarre */
624 r_u->info_class = q_u->info_class;
625 }
626
627 return r_u->status;
628 }
629
630 /***************************************************************************
631 _lsa_lookup_sids
632 ***************************************************************************/
633
634 NTSTATUS _lsa_lookup_sids(pipes_struct *p, LSA_Q_LOOKUP_SIDS *q_u, LSA_R_LOOKUP_SIDS *r_u)
635 {
636 struct lsa_info *handle;
637 DOM_SID2 *sid = q_u->sids.sid;
638 int num_entries = q_u->sids.num_entries;
639 DOM_R_REF *ref = NULL;
640 LSA_TRANS_NAME_ENUM *names = NULL;
641 uint32 mapped_count = 0;
642
643 if (num_entries > MAX_LOOKUP_SIDS) {
644 num_entries = MAX_LOOKUP_SIDS;
645 DEBUG(5,("_lsa_lookup_sids: truncating SID lookup list to %d\n", num_entries));
646 }
647
648 ref = (DOM_R_REF *)talloc_zero(p->mem_ctx, sizeof(DOM_R_REF));
649 names = (LSA_TRANS_NAME_ENUM *)talloc_zero(p->mem_ctx, sizeof(LSA_TRANS_NAME_ENUM));
650
651 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle)) {
652 r_u->status = NT_STATUS_INVALID_HANDLE;
653 goto done;
654 }
655
656 /* check if the user have enough rights */
657 if (!(handle->access & POLICY_LOOKUP_NAMES)) {
658 r_u->status = NT_STATUS_ACCESS_DENIED;
659 goto done;
660 }
661 if (!ref || !names)
662 return NT_STATUS_NO_MEMORY;
663
664 done:
665
666 /* set up the LSA Lookup SIDs response */
667 init_lsa_trans_names(p->mem_ctx, ref, names, num_entries, sid, &mapped_count);
668 init_reply_lookup_sids(r_u, ref, names, mapped_count);
669
670 return r_u->status;
671 }
672
673 /***************************************************************************
674 lsa_reply_lookup_names
675 ***************************************************************************/
676
677 NTSTATUS _lsa_lookup_names(pipes_struct *p,LSA_Q_LOOKUP_NAMES *q_u, LSA_R_LOOKUP_NAMES *r_u)
678 {
679 struct lsa_info *handle;
680 UNISTR2 *names = q_u->uni_name;
681 int num_entries = q_u->num_entries;
682 DOM_R_REF *ref;
683 DOM_RID2 *rids;
684 uint32 mapped_count = 0;
685
686 if (num_entries > MAX_LOOKUP_SIDS) {
687 num_entries = MAX_LOOKUP_SIDS;
688 DEBUG(5,("_lsa_lookup_names: truncating name lookup list to %d\n", num_entries));
689 }
690
691 ref = (DOM_R_REF *)talloc_zero(p->mem_ctx, sizeof(DOM_R_REF));
692 rids = (DOM_RID2 *)talloc_zero(p->mem_ctx, sizeof(DOM_RID2)*num_entries);
693
694 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle)) {
695 r_u->status = NT_STATUS_INVALID_HANDLE;
696 goto done;
697 }
698
699 /* check if the user have enough rights */
700 if (!(handle->access & POLICY_LOOKUP_NAMES)) {
701 r_u->status = NT_STATUS_ACCESS_DENIED;
702 goto done;
703 }
704
705 if (!ref || !rids)
706 return NT_STATUS_NO_MEMORY;
707
708 done:
709
710 /* set up the LSA Lookup RIDs response */
711 init_lsa_rid2s(ref, rids, num_entries, names, &mapped_count, p->endian);
712 init_reply_lookup_names(r_u, ref, num_entries, rids, mapped_count);
713
714 return r_u->status;
715 }
716
717 /***************************************************************************
718 _lsa_close. Also weird - needs to check if lsa handle is correct. JRA.
719 ***************************************************************************/
720
721 NTSTATUS _lsa_close(pipes_struct *p, LSA_Q_CLOSE *q_u, LSA_R_CLOSE *r_u)
722 {
723 if (!find_policy_by_hnd(p, &q_u->pol, NULL))
724 return NT_STATUS_INVALID_HANDLE;
725
726 close_policy_hnd(p, &q_u->pol);
727 return NT_STATUS_OK;
728 }
729
730 /***************************************************************************
731 "No more secrets Marty...." :-).
732 ***************************************************************************/
733
734 NTSTATUS _lsa_open_secret(pipes_struct *p, LSA_Q_OPEN_SECRET *q_u, LSA_R_OPEN_SECRET *r_u)
735 {
736 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
737 }
738
739 /***************************************************************************
740 _lsa_enum_privs.
741 ***************************************************************************/
742
743 NTSTATUS _lsa_enum_privs(pipes_struct *p, LSA_Q_ENUM_PRIVS *q_u, LSA_R_ENUM_PRIVS *r_u)
744 {
745 struct lsa_info *handle;
746 uint32 i;
747
748 uint32 enum_context=q_u->enum_context;
749 LSA_PRIV_ENTRY *entry;
750 LSA_PRIV_ENTRY *entries=NULL;
751
752 if (enum_context >= PRIV_ALL_INDEX)
753 return NT_STATUS_NO_MORE_ENTRIES;
754
755 entries = (LSA_PRIV_ENTRY *)talloc_zero(p->mem_ctx, sizeof(LSA_PRIV_ENTRY) * (PRIV_ALL_INDEX));
756 if (entries==NULL)
757 return NT_STATUS_NO_MEMORY;
758
759 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle))
760 return NT_STATUS_INVALID_HANDLE;
761
762 /* check if the user have enough rights */
763
764 /*
765 * I don't know if it's the right one. not documented.
766 */
767 if (!(handle->access & POLICY_VIEW_LOCAL_INFORMATION))
768 return NT_STATUS_ACCESS_DENIED;
769
770 entry = entries;
771
772 DEBUG(10,("_lsa_enum_privs: enum_context:%d total entries:%d\n", enum_context, PRIV_ALL_INDEX));
773
774 for (i = 0; i < PRIV_ALL_INDEX; i++, entry++) {
775 if( i<enum_context) {
776 init_unistr2(&entry->name, NULL, UNI_FLAGS_NONE);
777 init_uni_hdr(&entry->hdr_name, &entry->name);
778 entry->luid_low = 0;
779 entry->luid_high = 0;
780 } else {
781 init_unistr2(&entry->name, privs[i+1].priv, UNI_FLAGS_NONE);
782 init_uni_hdr(&entry->hdr_name, &entry->name);
783 entry->luid_low = privs[i+1].se_priv;
784 entry->luid_high = 0;
785 }
786 }
787
788 enum_context = PRIV_ALL_INDEX;
789 init_lsa_r_enum_privs(r_u, enum_context, PRIV_ALL_INDEX, entries);
790
791 return NT_STATUS_OK;
792 }
793
794 /***************************************************************************
795 _lsa_priv_get_dispname.
796 ***************************************************************************/
797
798 NTSTATUS _lsa_priv_get_dispname(pipes_struct *p, LSA_Q_PRIV_GET_DISPNAME *q_u, LSA_R_PRIV_GET_DISPNAME *r_u)
799 {
800 struct lsa_info *handle;
801 fstring name_asc;
802 int i=1;
803
804 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle))
805 return NT_STATUS_INVALID_HANDLE;
806
807 /* check if the user have enough rights */
808
809 /*
810 * I don't know if it's the right one. not documented.
811 */
812 if (!(handle->access & POLICY_VIEW_LOCAL_INFORMATION))
813 return NT_STATUS_ACCESS_DENIED;
814
815 unistr2_to_ascii(name_asc, &q_u->name, sizeof(name_asc));
816
817 DEBUG(10,("_lsa_priv_get_dispname: %s", name_asc));
818
819 while (privs[i].se_priv!=SE_PRIV_ALL && strcmp(name_asc, privs[i].priv))
820 i++;
821
822 if (privs[i].se_priv!=SE_PRIV_ALL) {
823 DEBUG(10,(": %s\n", privs[i].description));
824 init_unistr2(&r_u->desc, privs[i].description, UNI_FLAGS_NONE);
825 init_uni_hdr(&r_u->hdr_desc, &r_u->desc);
826
827 r_u->ptr_info=0xdeadbeef;
828 r_u->lang_id=q_u->lang_id;
829 return NT_STATUS_OK;
830 } else {
831 DEBUG(10,("_lsa_priv_get_dispname: doesn't exist\n"));
832 r_u->ptr_info=0;
833 return NT_STATUS_NO_SUCH_PRIVILEGE;
834 }
835 }
836
837 /***************************************************************************
838 _lsa_enum_accounts.
839 ***************************************************************************/
840
841 NTSTATUS _lsa_enum_accounts(pipes_struct *p, LSA_Q_ENUM_ACCOUNTS *q_u, LSA_R_ENUM_ACCOUNTS *r_u)
842 {
843 struct lsa_info *handle;
844 GROUP_MAP *map=NULL;
845 int num_entries=0;
846 LSA_SID_ENUM *sids=&r_u->sids;
847 int i=0,j=0;
848
849 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle))
850 return NT_STATUS_INVALID_HANDLE;
851
852 /* check if the user have enough rights */
853
854 /*
855 * I don't know if it's the right one. not documented.
856 */
857 if (!(handle->access & POLICY_VIEW_LOCAL_INFORMATION))
858 return NT_STATUS_ACCESS_DENIED;
859
860 /* get the list of mapped groups (domain, local, builtin) */
861 if(!pdb_enum_group_mapping(SID_NAME_UNKNOWN, &map, &num_entries, ENUM_ONLY_MAPPED))
862 return NT_STATUS_OK;
863
864 if (q_u->enum_context >= num_entries)
865 return NT_STATUS_NO_MORE_ENTRIES;
866
867 sids->ptr_sid = (uint32 *)talloc_zero(p->mem_ctx, (num_entries-q_u->enum_context)*sizeof(uint32));
868 sids->sid = (DOM_SID2 *)talloc_zero(p->mem_ctx, (num_entries-q_u->enum_context)*sizeof(DOM_SID2));
869
870 if (sids->ptr_sid==NULL || sids->sid==NULL) {
871 SAFE_FREE(map);
872 return NT_STATUS_NO_MEMORY;
873 }
874
875 for (i=q_u->enum_context, j=0; i<num_entries; i++) {
876 init_dom_sid2( &(*sids).sid[j], &map[i].sid);
877 (*sids).ptr_sid[j]=1;
878 j++;
879 }
880
881 SAFE_FREE(map);
882
883 init_lsa_r_enum_accounts(r_u, j);
884
885 return NT_STATUS_OK;
886 }
887
888
889 NTSTATUS _lsa_unk_get_connuser(pipes_struct *p, LSA_Q_UNK_GET_CONNUSER *q_u, LSA_R_UNK_GET_CONNUSER *r_u)
890 {
891 fstring username, domname;
892 user_struct *vuser = get_valid_user_struct(p->vuid);
893
894 if (vuser == NULL)
895 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
896
897 fstrcpy(username, vuser->user.smb_name);
898 fstrcpy(domname, vuser->user.domain);
899
900 r_u->ptr_user_name = 1;
901 init_unistr2(&r_u->uni2_user_name, username, UNI_STR_TERMINATE);
902 init_uni_hdr(&r_u->hdr_user_name, &r_u->uni2_user_name);
903
904 r_u->unk1 = 1;
905
906 r_u->ptr_dom_name = 1;
907 init_unistr2(&r_u->uni2_dom_name, domname, UNI_STR_TERMINATE);
908 init_uni_hdr(&r_u->hdr_dom_name, &r_u->uni2_dom_name);
909
910 r_u->status = NT_STATUS_OK;
911
912 return r_u->status;
913 }
914
915 /***************************************************************************
916
917 ***************************************************************************/
918
919 NTSTATUS _lsa_open_account(pipes_struct *p, LSA_Q_OPENACCOUNT *q_u, LSA_R_OPENACCOUNT *r_u)
920 {
921 struct lsa_info *handle;
922 struct lsa_info *info;
923
924 r_u->status = NT_STATUS_OK;
925
926 /* find the connection policy handle. */
927 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle))
928 return NT_STATUS_INVALID_HANDLE;
929
930 /* check if the user have enough rights */
931
932 /*
933 * I don't know if it's the right one. not documented.
934 * but guessed with rpcclient.
935 */
936 if (!(handle->access & POLICY_GET_PRIVATE_INFORMATION))
937 return NT_STATUS_ACCESS_DENIED;
938
939 /* associate the user/group SID with the (unique) handle. */
940 if ((info = (struct lsa_info *)malloc(sizeof(struct lsa_info))) == NULL)
941 return NT_STATUS_NO_MEMORY;
942
943 ZERO_STRUCTP(info);
944 info->sid = q_u->sid.sid;
945 info->access = q_u->access;
946
947 /* get a (unique) handle. open a policy on it. */
948 if (!create_policy_hnd(p, &r_u->pol, free_lsa_info, (void *)info))
949 return NT_STATUS_OBJECT_NAME_NOT_FOUND;
950
951 return r_u->status;
952 }
953
954 /***************************************************************************
955 For a given SID, enumerate all the privilege this account has.
956 ***************************************************************************/
957
958 NTSTATUS _lsa_enum_privsaccount(pipes_struct *p, prs_struct *ps, LSA_Q_ENUMPRIVSACCOUNT *q_u, LSA_R_ENUMPRIVSACCOUNT *r_u)
959 {
960 struct lsa_info *info=NULL;
961 GROUP_MAP map;
962 LUID_ATTR *set=NULL;
963
964 r_u->status = NT_STATUS_OK;
965
966 /* find the connection policy handle. */
967 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
968 return NT_STATUS_INVALID_HANDLE;
969
970 if (!pdb_getgrsid(&map, info->sid))
971 return NT_STATUS_NO_SUCH_GROUP;
972
973 #if 0 /* privileges currently not implemented! */
974 DEBUG(10,("_lsa_enum_privsaccount: %d privileges\n", map.priv_set->count));
975 if (map.priv_set->count!=0) {
976
977 set=(LUID_ATTR *)talloc(map.priv_set->mem_ctx, map.priv_set.count*sizeof(LUID_ATTR));
978 if (set == NULL) {
979 destroy_privilege(&map.priv_set);
980 return NT_STATUS_NO_MEMORY;
981 }
982
983 for (i = 0; i < map.priv_set.count; i++) {
984 set[i].luid.low = map.priv_set->set[i].luid.low;
985 set[i].luid.high = map.priv_set->set[i].luid.high;
986 set[i].attr = map.priv_set->set[i].attr;
987 DEBUG(10,("_lsa_enum_privsaccount: priv %d: %d:%d:%d\n", i,
988 set[i].luid.high, set[i].luid.low, set[i].attr));
989 }
990 }
991
992 init_lsa_r_enum_privsaccount(ps->mem_ctx, r_u, set, map.priv_set->count, 0);
993 destroy_privilege(&map.priv_set);
994 #endif
995
996 init_lsa_r_enum_privsaccount(ps->mem_ctx, r_u, set, 0, 0);
997
998 return r_u->status;
999 }
1000
1001 /***************************************************************************
1002
1003 ***************************************************************************/
1004
1005 NTSTATUS _lsa_getsystemaccount(pipes_struct *p, LSA_Q_GETSYSTEMACCOUNT *q_u, LSA_R_GETSYSTEMACCOUNT *r_u)
1006 {
1007 struct lsa_info *info=NULL;
1008 GROUP_MAP map;
1009 r_u->status = NT_STATUS_OK;
1010
1011 /* find the connection policy handle. */
1012 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
1013 return NT_STATUS_INVALID_HANDLE;
1014
1015 if (!pdb_getgrsid(&map, info->sid))
1016 return NT_STATUS_NO_SUCH_GROUP;
1017
1018 /*
1019 0x01 -> Log on locally
1020 0x02 -> Access this computer from network
1021 0x04 -> Log on as a batch job
1022 0x10 -> Log on as a service
1023
1024 they can be ORed together
1025 */
1026
1027 r_u->access = PR_LOG_ON_LOCALLY | PR_ACCESS_FROM_NETWORK;
1028
1029 return r_u->status;
1030 }
1031
1032 /***************************************************************************
1033 update the systemaccount information
1034 ***************************************************************************/
1035
1036 NTSTATUS _lsa_setsystemaccount(pipes_struct *p, LSA_Q_SETSYSTEMACCOUNT *q_u, LSA_R_SETSYSTEMACCOUNT *r_u)
1037 {
1038 struct lsa_info *info=NULL;
1039 GROUP_MAP map;
1040 r_u->status = NT_STATUS_OK;
1041
1042 /* find the connection policy handle. */
1043 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
1044 return NT_STATUS_INVALID_HANDLE;
1045
1046 if (!pdb_getgrsid(&map, info->sid))
1047 return NT_STATUS_NO_SUCH_GROUP;
1048
1049 if(!pdb_update_group_mapping_entry(&map))
1050 return NT_STATUS_NO_SUCH_GROUP;
1051
1052 return r_u->status;
1053 }
1054
1055 /***************************************************************************
1056 For a given SID, add some privileges.
1057 ***************************************************************************/
1058
1059 NTSTATUS _lsa_addprivs(pipes_struct *p, LSA_Q_ADDPRIVS *q_u, LSA_R_ADDPRIVS *r_u)
1060 {
1061 #if 0
1062 struct lsa_info *info = NULL;
1063 GROUP_MAP map;
1064 int i = 0;
1065 LUID_ATTR *luid_attr = NULL;
1066 PRIVILEGE_SET *set = NULL;
1067 #endif
1068
1069 r_u->status = NT_STATUS_OK;
1070
1071 #if 0 /* privileges are not implemented */
1072 /* find the connection policy handle. */
1073 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
1074 return NT_STATUS_INVALID_HANDLE;
1075
1076 if (!pdb_getgrsid(&map, info->sid))
1077 return NT_STATUS_NO_SUCH_GROUP;
1078
1079 set = &q_u->set;
1080
1081 for (i = 0; i < set->count; i++) {
1082 luid_attr = &set->set[i];
1083
1084 /* check if the privilege is already there */
1085 if (check_priv_in_privilege(map.priv_set, *luid_attr)){
1086 destroy_privilege(&map.priv_set);
1087 return NT_STATUS_NO_SUCH_PRIVILEGE;
1088 }
1089
1090 add_privilege(map.priv_set, *luid_attr);
1091 }
1092
1093 if(!pdb_update_group_mapping_entry(&map))
1094 return NT_STATUS_NO_SUCH_GROUP;
1095
1096 destroy_privilege(&map.priv_set);
1097
1098 #endif
1099 return r_u->status;
1100 }
1101
1102 /***************************************************************************
1103 For a given SID, remove some privileges.
1104 ***************************************************************************/
1105
1106 NTSTATUS _lsa_removeprivs(pipes_struct *p, LSA_Q_REMOVEPRIVS *q_u, LSA_R_REMOVEPRIVS *r_u)
1107 {
1108 #if 0
1109 struct lsa_info *info = NULL;
1110 GROUP_MAP map;
1111 int i=0;
1112 LUID_ATTR *luid_attr = NULL;
1113 PRIVILEGE_SET *set = NULL;
1114 #endif
1115
1116 r_u->status = NT_STATUS_OK;
1117
1118 #if 0 /* privileges are not implemented */
1119 /* find the connection policy handle. */
1120 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&info))
1121 return NT_STATUS_INVALID_HANDLE;
1122
1123 if (!pdb_getgrsid(&map, info->sid))
1124 return NT_STATUS_NO_SUCH_GROUP;
1125
1126 if (q_u->allrights != 0) {
1127 /* log it and return, until I see one myself don't do anything */
1128 DEBUG(5,("_lsa_removeprivs: trying to remove all privileges ?\n"));
1129 return NT_STATUS_OK;
1130 }
1131
1132 if (q_u->ptr == 0) {
1133 /* log it and return, until I see one myself don't do anything */
1134 DEBUG(5,("_lsa_removeprivs: no privileges to remove ?\n"));
1135 return NT_STATUS_OK;
1136 }
1137
1138 set = &q_u->set;
1139
1140 for (i = 0; i < set->count; i++) {
1141 luid_attr = &set->set[i];
1142
1143 /* if we don't have the privilege, we're trying to remove, give up */
1144 /* what else can we do ??? JFM. */
1145 if (!check_priv_in_privilege(map.priv_set, *luid_attr)){
1146 destroy_privilege(&map.priv_set);
1147 return NT_STATUS_NO_SUCH_PRIVILEGE;
1148 }
1149
1150 remove_privilege(map.priv_set, *luid_attr);
1151 }
1152
1153 if(!pdb_update_group_mapping_entry(&map))
1154 return NT_STATUS_NO_SUCH_GROUP;
1155
1156 destroy_privilege(&map.priv_set);
1157 #endif
1158 return r_u->status;
1159 }
1160
1161 /***************************************************************************
1162 For a given SID, remove some privileges.
1163 ***************************************************************************/
1164
1165 NTSTATUS _lsa_query_secobj(pipes_struct *p, LSA_Q_QUERY_SEC_OBJ *q_u, LSA_R_QUERY_SEC_OBJ *r_u)
1166 {
1167 struct lsa_info *handle=NULL;
1168 SEC_DESC *psd = NULL;
1169 size_t sd_size;
1170 NTSTATUS status;
1171
1172 r_u->status = NT_STATUS_OK;
1173
1174 /* find the connection policy handle. */
1175 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle))
1176 return NT_STATUS_INVALID_HANDLE;
1177
1178 /* check if the user have enough rights */
1179 if (!(handle->access & POLICY_VIEW_LOCAL_INFORMATION))
1180 return NT_STATUS_ACCESS_DENIED;
1181
1182
1183 switch (q_u->sec_info) {
1184 case 1:
1185 /* SD contains only the owner */
1186
1187 status=lsa_get_generic_sd(p->mem_ctx, &psd, &sd_size);
1188 if(!NT_STATUS_IS_OK(status))
1189 return NT_STATUS_NO_MEMORY;
1190
1191
1192 if((r_u->buf = make_sec_desc_buf(p->mem_ctx, sd_size, psd)) == NULL)
1193 return NT_STATUS_NO_MEMORY;
1194 break;
1195 case 4:
1196 /* SD contains only the ACL */
1197
1198 status=lsa_get_generic_sd(p->mem_ctx, &psd, &sd_size);
1199 if(!NT_STATUS_IS_OK(status))
1200 return NT_STATUS_NO_MEMORY;
1201
1202 if((r_u->buf = make_sec_desc_buf(p->mem_ctx, sd_size, psd)) == NULL)
1203 return NT_STATUS_NO_MEMORY;
1204 break;
1205 default:
1206 return NT_STATUS_INVALID_LEVEL;
1207 }
1208
1209 r_u->ptr=1;
1210
1211 return r_u->status;
1212 }
1213
1214
1215 NTSTATUS _lsa_query_info2(pipes_struct *p, LSA_Q_QUERY_INFO2 *q_u, LSA_R_QUERY_INFO2 *r_u)
1216 {
1217 struct lsa_info *handle;
1218 const char *nb_name;
1219 char *dns_name = NULL;
1220 char *forest_name = NULL;
1221 DOM_SID *sid = NULL;
1222 GUID guid;
1223 fstring dnsdomname;
1224
1225 ZERO_STRUCT(guid);
1226 r_u->status = NT_STATUS_OK;
1227
1228 if (!find_policy_by_hnd(p, &q_u->pol, (void **)&handle))
1229 return NT_STATUS_INVALID_HANDLE;
1230
1231 switch (q_u->info_class) {
1232 case 0x0c:
1233 /* check if the user have enough rights */
1234 if (!(handle->access & POLICY_VIEW_LOCAL_INFORMATION))
1235 return NT_STATUS_ACCESS_DENIED;
1236
1237 /* Request PolicyPrimaryDomainInformation. */
1238 switch (lp_server_role()) {
1239 case ROLE_DOMAIN_PDC:
1240 case ROLE_DOMAIN_BDC:
1241 nb_name = get_global_sam_name();
1242 /* ugly temp hack for these next two */
1243
1244 /* This should be a 'netbios domain -> DNS domain' mapping */
1245 dnsdomname[0] = '\0';
1246 get_mydomname(dnsdomname);
1247 strlower_m(dnsdomname);
1248
1249 dns_name = dnsdomname;
1250 forest_name = dnsdomname;
1251
1252 sid = get_global_sam_sid();
1253 secrets_fetch_domain_guid(lp_workgroup(), &guid);
1254 break;
1255 default:
1256 return NT_STATUS_CANT_ACCESS_DOMAIN_INFO;
1257 }
1258 init_dns_dom_info(&r_u->info.dns_dom_info, nb_name, dns_name,
1259 forest_name,&guid,sid);
1260 break;
1261 default:
1262 DEBUG(0,("_lsa_query_info2: unknown info level in Lsa Query: %d\n", q_u->info_class));
1263 r_u->status = NT_STATUS_INVALID_INFO_CLASS;
1264 break;
1265 }
1266
1267 if (NT_STATUS_IS_OK(r_u->status)) {
1268 r_u->ptr = 0x1;
1269 r_u->info_class = q_u->info_class;
1270 }
1271
1272 return r_u->status;
1273 }
reg import