?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
d3d8: Stop setting the device state in d3d8_device_SetPixelShaderConstant().
[wine.git] / dlls / advapi32 / lsa.c
blobd63142f730bf9f0a960379623ab9e2f90afe176a
1 /*
2 * Implementation of the Local Security Authority API
3 *
4 * Copyright 1999 Juergen Schmied
5 * Copyright 2002 Andriy Palamarchuk
6 * Copyright 2004 Mike McCormack
7 * Copyright 2005 Hans Leidekker
8 *
9 * This library is free software; you can redistribute it and/or
10 * modify it under the terms of the GNU Lesser General Public
11 * License as published by the Free Software Foundation; either
12 * version 2.1 of the License, or (at your option) any later version.
13 *
14 * This library is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * Lesser General Public License for more details.
18 *
19 * You should have received a copy of the GNU Lesser General Public
20 * License along with this library; if not, write to the Free Software
21 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
22 */
23
24 #include <stdarg.h>
25
26 #include "ntstatus.h"
27 #define WIN32_NO_STATUS
28 #include "windef.h"
29 #include "winbase.h"
30 #include "winreg.h"
31 #include "winternl.h"
32 #include "sddl.h"
33 #include "advapi32_misc.h"
34
35 #include "wine/debug.h"
36 #include "wine/unicode.h"
37
38 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
39
40 #define ADVAPI_ForceLocalComputer(ServerName, FailureCode) \
41 if (!ADVAPI_IsLocalComputer(ServerName)) \
42 { \
43 FIXME("Action Implemented for local computer only. " \
44 "Requested for server %s\n", debugstr_w(ServerName)); \
45 return FailureCode; \
46 }
47
48 static LPCSTR debugstr_us( const UNICODE_STRING *us )
49 {
50 if (!us) return "(null)";
51 return debugstr_wn(us->Buffer, us->Length / sizeof(WCHAR));
52 }
53
54 static void dumpLsaAttributes(const LSA_OBJECT_ATTRIBUTES *oa)
55 {
56 if (oa)
57 {
58 TRACE("\n\tlength=%u, rootdir=%p, objectname=%s\n\tattr=0x%08x, sid=%s qos=%p\n",
59 oa->Length, oa->RootDirectory,
60 oa->ObjectName?debugstr_w(oa->ObjectName->Buffer):"null",
61 oa->Attributes, debugstr_sid(oa->SecurityDescriptor),
62 oa->SecurityQualityOfService);
63 }
64 }
65
66 static void* ADVAPI_GetDomainName(unsigned sz, unsigned ofs)
67 {
68 HKEY key;
69 LONG ret;
70 BYTE* ptr = NULL;
71 UNICODE_STRING* ustr;
72
73 static const WCHAR wVNETSUP[] = {
74 'S','y','s','t','e','m','\\',
75 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
76 'S','e','r','v','i','c','e','s','\\',
77 'V','x','D','\\','V','N','E','T','S','U','P','\0'};
78
79 ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, wVNETSUP, 0, KEY_READ, &key);
80 if (ret == ERROR_SUCCESS)
81 {
82 DWORD size = 0;
83 static const WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
84
85 ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
86 if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
87 {
88 ptr = heap_alloc_zero(sz + size);
89 if (!ptr) return NULL;
90 ustr = (UNICODE_STRING*)(ptr + ofs);
91 ustr->MaximumLength = size;
92 ustr->Buffer = (WCHAR*)(ptr + sz);
93 ret = RegQueryValueExW(key, wg, NULL, NULL, (LPBYTE)ustr->Buffer, &size);
94 if (ret != ERROR_SUCCESS)
95 {
96 heap_free(ptr);
97 ptr = NULL;
98 }
99 else ustr->Length = size - sizeof(WCHAR);
100 }
101 RegCloseKey(key);
102 }
103 if (!ptr)
104 {
105 static const WCHAR wDomain[] = {'D','O','M','A','I','N','\0'};
106 ptr = heap_alloc_zero(sz + sizeof(wDomain));
107 if (!ptr) return NULL;
108 ustr = (UNICODE_STRING*)(ptr + ofs);
109 ustr->MaximumLength = sizeof(wDomain);
110 ustr->Buffer = (WCHAR*)(ptr + sz);
111 ustr->Length = sizeof(wDomain) - sizeof(WCHAR);
112 memcpy(ustr->Buffer, wDomain, sizeof(wDomain));
113 }
114 return ptr;
115 }
116
117 /******************************************************************************
118 * LsaAddAccountRights [ADVAPI32.@]
119 *
120 */
121 NTSTATUS WINAPI LsaAddAccountRights(
122 LSA_HANDLE policy,
123 PSID sid,
124 PLSA_UNICODE_STRING rights,
125 ULONG count)
126 {
127 FIXME("(%p,%p,%p,0x%08x) stub\n", policy, sid, rights, count);
128 return STATUS_SUCCESS;
129 }
130
131 /******************************************************************************
132 * LsaClose [ADVAPI32.@]
133 *
134 * Closes a handle to a Policy or TrustedDomain.
135 *
136 * PARAMS
137 * ObjectHandle [I] Handle to a Policy or TrustedDomain.
138 *
139 * RETURNS
140 * Success: STATUS_SUCCESS.
141 * Failure: NTSTATUS code.
142 */
143 NTSTATUS WINAPI LsaClose(IN LSA_HANDLE ObjectHandle)
144 {
145 FIXME("(%p) stub\n", ObjectHandle);
146 return STATUS_SUCCESS;
147 }
148
149 /******************************************************************************
150 * LsaCreateTrustedDomainEx [ADVAPI32.@]
151 *
152 */
153 NTSTATUS WINAPI LsaCreateTrustedDomainEx(
154 LSA_HANDLE policy,
155 PTRUSTED_DOMAIN_INFORMATION_EX domain_info,
156 PTRUSTED_DOMAIN_AUTH_INFORMATION auth_info,
157 ACCESS_MASK access,
158 PLSA_HANDLE domain)
159 {
160 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", policy, domain_info, auth_info,
161 access, domain);
162 return STATUS_SUCCESS;
163 }
164
165 /******************************************************************************
166 * LsaDeleteTrustedDomain [ADVAPI32.@]
167 *
168 */
169 NTSTATUS WINAPI LsaDeleteTrustedDomain(LSA_HANDLE policy, PSID sid)
170 {
171 FIXME("(%p,%p) stub\n", policy, sid);
172 return STATUS_SUCCESS;
173 }
174
175 /******************************************************************************
176 * LsaEnumerateAccountRights [ADVAPI32.@]
177 *
178 */
179 NTSTATUS WINAPI LsaEnumerateAccountRights(
180 LSA_HANDLE policy,
181 PSID sid,
182 PLSA_UNICODE_STRING *rights,
183 PULONG count)
184 {
185 FIXME("(%p,%p,%p,%p) stub\n", policy, sid, rights, count);
186 *rights = 0;
187 *count = 0;
188 return STATUS_OBJECT_NAME_NOT_FOUND;
189 }
190
191 /******************************************************************************
192 * LsaEnumerateAccountsWithUserRight [ADVAPI32.@]
193 *
194 */
195 NTSTATUS WINAPI LsaEnumerateAccountsWithUserRight(
196 LSA_HANDLE policy,
197 PLSA_UNICODE_STRING rights,
198 PVOID *buffer,
199 PULONG count)
200 {
201 FIXME("(%p,%p,%p,%p) stub\n", policy, rights, buffer, count);
202 return STATUS_NO_MORE_ENTRIES;
203 }
204
205 /******************************************************************************
206 * LsaEnumerateTrustedDomains [ADVAPI32.@]
207 *
208 * Returns the names and SIDs of trusted domains.
209 *
210 * PARAMS
211 * PolicyHandle [I] Handle to a Policy object.
212 * EnumerationContext [I] Pointer to an enumeration handle.
213 * Buffer [O] Contains the names and SIDs of trusted domains.
214 * PreferredMaximumLength[I] Preferred maximum size in bytes of Buffer.
215 * CountReturned [O] Number of elements in Buffer.
216 *
217 * RETURNS
218 * Success: STATUS_SUCCESS,
219 * STATUS_MORE_ENTRIES,
220 * STATUS_NO_MORE_ENTRIES
221 * Failure: NTSTATUS code.
222 *
223 * NOTES
224 * LsaEnumerateTrustedDomains can be called multiple times to enumerate
225 * all trusted domains.
226 */
227 NTSTATUS WINAPI LsaEnumerateTrustedDomains(
228 IN LSA_HANDLE PolicyHandle,
229 IN PLSA_ENUMERATION_HANDLE EnumerationContext,
230 OUT PVOID* Buffer,
231 IN ULONG PreferredMaximumLength,
232 OUT PULONG CountReturned)
233 {
234 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
235 Buffer, PreferredMaximumLength, CountReturned);
236
237 if (CountReturned) *CountReturned = 0;
238 return STATUS_SUCCESS;
239 }
240
241 /******************************************************************************
242 * LsaEnumerateTrustedDomainsEx [ADVAPI32.@]
243 *
244 */
245 NTSTATUS WINAPI LsaEnumerateTrustedDomainsEx(
246 LSA_HANDLE policy,
247 PLSA_ENUMERATION_HANDLE context,
248 PVOID *buffer,
249 ULONG length,
250 PULONG count)
251 {
252 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", policy, context, buffer, length, count);
253
254 if (count) *count = 0;
255 return STATUS_SUCCESS;
256 }
257
258 /******************************************************************************
259 * LsaFreeMemory [ADVAPI32.@]
260 *
261 * Frees memory allocated by a LSA function.
262 *
263 * PARAMS
264 * Buffer [I] Memory buffer to free.
265 *
266 * RETURNS
267 * Success: STATUS_SUCCESS.
268 * Failure: NTSTATUS code.
269 */
270 NTSTATUS WINAPI LsaFreeMemory(IN PVOID Buffer)
271 {
272 TRACE("(%p)\n", Buffer);
273
274 heap_free(Buffer);
275 return STATUS_SUCCESS;
276 }
277
278 /******************************************************************************
279 * LsaLookupNames [ADVAPI32.@]
280 *
281 * Returns the SIDs of an array of user, group, or local group names.
282 *
283 * PARAMS
284 * PolicyHandle [I] Handle to a Policy object.
285 * Count [I] Number of names in Names.
286 * Names [I] Array of names to lookup.
287 * ReferencedDomains [O] Array of domains where the names were found.
288 * Sids [O] Array of SIDs corresponding to Names.
289 *
290 * RETURNS
291 * Success: STATUS_SUCCESS,
292 * STATUS_SOME_NOT_MAPPED
293 * Failure: STATUS_NONE_MAPPED or NTSTATUS code.
294 */
295 NTSTATUS WINAPI LsaLookupNames(
296 IN LSA_HANDLE PolicyHandle,
297 IN ULONG Count,
298 IN PLSA_UNICODE_STRING Names,
299 OUT PLSA_REFERENCED_DOMAIN_LIST* ReferencedDomains,
300 OUT PLSA_TRANSLATED_SID* Sids)
301 {
302 FIXME("(%p,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Count, Names,
303 ReferencedDomains, Sids);
304
305 return STATUS_NONE_MAPPED;
306 }
307
308 static BOOL lookup_name( LSA_UNICODE_STRING *name, SID *sid, DWORD *sid_size, WCHAR *domain,
309 DWORD *domain_size, SID_NAME_USE *use, BOOL *handled )
310 {
311 BOOL ret;
312
313 ret = lookup_local_wellknown_name( name, sid, sid_size, domain, domain_size, use, handled );
314 if (!*handled)
315 ret = lookup_local_user_name( name, sid, sid_size, domain, domain_size, use, handled );
316
317 return ret;
318 }
319
320 /* Adds domain info to referenced domain list.
321 Domain list is stored as plain buffer, layout is:
322
323 LSA_REFERENCED_DOMAIN_LIST,
324 LSA_TRUST_INFORMATION array,
325 domain data array of
326 {
327 domain name data (WCHAR buffer),
328 SID data
329 }
330
331 Parameters:
332 list [I] referenced list pointer
333 domain [I] domain name string
334 data [IO] pointer to domain data array
335 */
336 static LONG lsa_reflist_add_domain(LSA_REFERENCED_DOMAIN_LIST *list, LSA_UNICODE_STRING *domain, char **data)
337 {
338 ULONG sid_size = 0,domain_size = 0;
339 BOOL handled = FALSE;
340 SID_NAME_USE use;
341 LONG i;
342
343 for (i = 0; i < list->Entries; i++)
344 {
345 /* try to reuse index */
346 if ((list->Domains[i].Name.Length == domain->Length) &&
347 (!strncmpiW(list->Domains[i].Name.Buffer, domain->Buffer, (domain->Length / sizeof(WCHAR)))))
348 {
349 return i;
350 }
351 }
352
353 /* no matching domain found, store name */
354 list->Domains[list->Entries].Name.Length = domain->Length;
355 list->Domains[list->Entries].Name.MaximumLength = domain->MaximumLength;
356 list->Domains[list->Entries].Name.Buffer = (WCHAR*)*data;
357 memcpy(list->Domains[list->Entries].Name.Buffer, domain->Buffer, domain->MaximumLength);
358 *data += domain->MaximumLength;
359
360 /* get and store SID data */
361 list->Domains[list->Entries].Sid = *data;
362 lookup_name(domain, NULL, &sid_size, NULL, &domain_size, &use, &handled);
363 domain_size = 0;
364 lookup_name(domain, list->Domains[list->Entries].Sid, &sid_size, NULL, &domain_size, &use, &handled);
365 *data += sid_size;
366
367 return list->Entries++;
368 }
369
370 /******************************************************************************
371 * LsaLookupNames2 [ADVAPI32.@]
372 *
373 */
374 NTSTATUS WINAPI LsaLookupNames2( LSA_HANDLE policy, ULONG flags, ULONG count,
375 PLSA_UNICODE_STRING names, PLSA_REFERENCED_DOMAIN_LIST *domains,
376 PLSA_TRANSLATED_SID2 *sids )
377 {
378 ULONG i, sid_size_total = 0, domain_size_max = 0, size, domainname_size_total = 0;
379 ULONG sid_size, domain_size, mapped;
380 LSA_UNICODE_STRING domain;
381 BOOL handled = FALSE;
382 char *domain_data;
383 SID_NAME_USE use;
384 SID *sid;
385
386 TRACE("(%p,0x%08x,0x%08x,%p,%p,%p)\n", policy, flags, count, names, domains, sids);
387
388 mapped = 0;
389 for (i = 0; i < count; i++)
390 {
391 handled = FALSE;
392 sid_size = domain_size = 0;
393 lookup_name( &names[i], NULL, &sid_size, NULL, &domain_size, &use, &handled );
394 if (handled)
395 {
396 sid_size_total += sid_size;
397 domainname_size_total += domain_size;
398 if (domain_size)
399 {
400 if (domain_size > domain_size_max)
401 domain_size_max = domain_size;
402 }
403 mapped++;
404 }
405 }
406 TRACE("mapped %u out of %u\n", mapped, count);
407
408 size = sizeof(LSA_TRANSLATED_SID2) * count + sid_size_total;
409 if (!(*sids = heap_alloc(size))) return STATUS_NO_MEMORY;
410
411 sid = (SID *)(*sids + count);
412
413 /* use maximum domain count */
414 if (!(*domains = heap_alloc(sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*count +
415 sid_size_total + domainname_size_total*sizeof(WCHAR))))
416 {
417 heap_free(*sids);
418 return STATUS_NO_MEMORY;
419 }
420 (*domains)->Entries = 0;
421 (*domains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*domains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
422 domain_data = (char*)(*domains)->Domains + sizeof(LSA_TRUST_INFORMATION)*count;
423
424 domain.Buffer = heap_alloc(domain_size_max*sizeof(WCHAR));
425 for (i = 0; i < count; i++)
426 {
427 domain.Length = domain_size_max*sizeof(WCHAR);
428 domain.MaximumLength = domain_size_max*sizeof(WCHAR);
429
430 (*sids)[i].Use = SidTypeUnknown;
431 (*sids)[i].DomainIndex = -1;
432 (*sids)[i].Flags = 0;
433
434 handled = FALSE;
435 sid_size = sid_size_total;
436 domain_size = domain_size_max;
437 lookup_name( &names[i], sid, &sid_size, domain.Buffer, &domain_size, &use, &handled );
438 if (handled)
439 {
440 (*sids)[i].Sid = sid;
441 (*sids)[i].Use = use;
442
443 sid = (SID *)((char *)sid + sid_size);
444 sid_size_total -= sid_size;
445 if (domain_size)
446 {
447 domain.Length = domain_size * sizeof(WCHAR);
448 domain.MaximumLength = (domain_size + 1) * sizeof(WCHAR);
449 (*sids)[i].DomainIndex = lsa_reflist_add_domain(*domains, &domain, &domain_data);
450 }
451 }
452 }
453 heap_free(domain.Buffer);
454
455 if (mapped == count) return STATUS_SUCCESS;
456 if (mapped > 0 && mapped < count) return STATUS_SOME_NOT_MAPPED;
457 return STATUS_NONE_MAPPED;
458 }
459
460 /******************************************************************************
461 * LsaLookupSids [ADVAPI32.@]
462 *
463 * Looks up the names that correspond to an array of SIDs.
464 *
465 * PARAMS
466 * PolicyHandle [I] Handle to a Policy object.
467 * Count [I] Number of SIDs in the Sids array.
468 * Sids [I] Array of SIDs to lookup.
469 * ReferencedDomains [O] Array of domains where the sids were found.
470 * Names [O] Array of names corresponding to Sids.
471 *
472 * RETURNS
473 * Success: STATUS_SUCCESS,
474 * STATUS_SOME_NOT_MAPPED
475 * Failure: STATUS_NONE_MAPPED or NTSTATUS code.
476 */
477 NTSTATUS WINAPI LsaLookupSids(
478 LSA_HANDLE PolicyHandle,
479 ULONG Count,
480 PSID *Sids,
481 LSA_REFERENCED_DOMAIN_LIST **ReferencedDomains,
482 LSA_TRANSLATED_NAME **Names)
483 {
484 ULONG i, mapped, name_fullsize, domain_fullsize;
485 ULONG name_size, domain_size;
486 LSA_UNICODE_STRING domain;
487 WCHAR *name_buffer;
488 char *domain_data;
489 SID_NAME_USE use;
490 WCHAR *strsid;
491
492 TRACE("(%p, %u, %p, %p, %p)\n", PolicyHandle, Count, Sids, ReferencedDomains, Names);
493
494 /* this length does not include actual string length yet */
495 name_fullsize = sizeof(LSA_TRANSLATED_NAME) * Count;
496 if (!(*Names = heap_alloc(name_fullsize))) return STATUS_NO_MEMORY;
497 /* maximum count of stored domain infos is Count, allocate it like that cause really needed
498 count could only be computed after sid data is retrieved */
499 domain_fullsize = sizeof(LSA_REFERENCED_DOMAIN_LIST) + sizeof(LSA_TRUST_INFORMATION)*Count;
500 if (!(*ReferencedDomains = heap_alloc(domain_fullsize)))
501 {
502 heap_free(*Names);
503 return STATUS_NO_MEMORY;
504 }
505 (*ReferencedDomains)->Entries = 0;
506 (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
507
508 /* Get full names data length and full length needed to store domain name and SID */
509 for (i = 0; i < Count; i++)
510 {
511 (*Names)[i].Use = SidTypeUnknown;
512 (*Names)[i].DomainIndex = -1;
513 RtlInitUnicodeStringEx(&(*Names)[i].Name, NULL);
514
515 memset(&(*ReferencedDomains)->Domains[i], 0, sizeof(LSA_TRUST_INFORMATION));
516
517 name_size = domain_size = 0;
518 if (!LookupAccountSidW(NULL, Sids[i], NULL, &name_size, NULL, &domain_size, &use) &&
519 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
520 {
521 if (name_size)
522 {
523 (*Names)[i].Name.Length = (name_size - 1) * sizeof(WCHAR);
524 (*Names)[i].Name.MaximumLength = name_size * sizeof(WCHAR);
525 }
526 else
527 {
528 (*Names)[i].Name.Length = 0;
529 (*Names)[i].Name.MaximumLength = sizeof(WCHAR);
530 }
531
532 name_fullsize += (*Names)[i].Name.MaximumLength;
533
534 /* This potentially allocates more than needed, cause different names will reuse same domain index.
535 Also it's not possible to store domain name length right here for the same reason. */
536 if (domain_size)
537 {
538 ULONG sid_size = 0;
539 BOOL handled = FALSE;
540 WCHAR *name;
541
542 domain_fullsize += domain_size * sizeof(WCHAR);
543
544 /* get domain SID size too */
545 name = heap_alloc(domain_size * sizeof(WCHAR));
546 *name = 0;
547 LookupAccountSidW(NULL, Sids[i], NULL, &name_size, name, &domain_size, &use);
548
549 domain.Buffer = name;
550 domain.Length = domain_size * sizeof(WCHAR);
551 domain.MaximumLength = domain_size * sizeof(WCHAR);
552
553 lookup_name(&domain, NULL, &sid_size, NULL, &domain_size, &use, &handled);
554 domain_fullsize += sid_size;
555
556 heap_free(name);
557 }
558 else
559 {
560 /* If we don't have a domain name, use a zero-length entry rather than a null value. */
561 domain_fullsize += sizeof(WCHAR);
562 domain.Length = 0;
563 domain.MaximumLength = sizeof(WCHAR);
564 }
565 }
566 else if (ConvertSidToStringSidW(Sids[i], &strsid))
567 {
568 (*Names)[i].Name.Length = strlenW(strsid) * sizeof(WCHAR);
569 (*Names)[i].Name.MaximumLength = (strlenW(strsid) + 1) * sizeof(WCHAR);
570 name_fullsize += (strlenW(strsid) + 1) * sizeof(WCHAR);
571
572 LocalFree(strsid);
573 }
574 }
575
576 /* now we have full length needed for both */
577 *Names = heap_realloc(*Names, name_fullsize);
578 name_buffer = (WCHAR*)((char*)*Names + sizeof(LSA_TRANSLATED_NAME)*Count);
579
580 *ReferencedDomains = heap_realloc(*ReferencedDomains, domain_fullsize);
581 /* fix pointer after reallocation */
582 (*ReferencedDomains)->Domains = (LSA_TRUST_INFORMATION*)((char*)*ReferencedDomains + sizeof(LSA_REFERENCED_DOMAIN_LIST));
583 domain_data = (char*)(*ReferencedDomains)->Domains + sizeof(LSA_TRUST_INFORMATION)*Count;
584
585 mapped = 0;
586 for (i = 0; i < Count; i++)
587 {
588 name_size = domain_size = 0;
589
590 (*Names)[i].Name.Buffer = name_buffer;
591
592 if (!LookupAccountSidW(NULL, Sids[i], NULL, &name_size, NULL, &domain_size, &use) &&
593 GetLastError() == ERROR_INSUFFICIENT_BUFFER)
594 {
595 mapped++;
596
597 if (domain_size)
598 {
599 domain.Length = (domain_size - 1) * sizeof(WCHAR);
600 domain.MaximumLength = domain_size * sizeof(WCHAR);
601 }
602 else
603 {
604 /* Use a zero-length buffer */
605 domain.Length = 0;
606 domain.MaximumLength = sizeof(WCHAR);
607 }
608
609 domain.Buffer = heap_alloc(domain.MaximumLength);
610
611 LookupAccountSidW(NULL, Sids[i], (*Names)[i].Name.Buffer, &name_size, domain.Buffer, &domain_size, &use);
612 (*Names)[i].Use = use;
613
614 (*Names)[i].DomainIndex = lsa_reflist_add_domain(*ReferencedDomains, &domain, &domain_data);
615 heap_free(domain.Buffer);
616 }
617 else if (ConvertSidToStringSidW(Sids[i], &strsid))
618 {
619 strcpyW((*Names)[i].Name.Buffer, strsid);
620 LocalFree(strsid);
621 }
622
623 name_buffer += strlenW(name_buffer) + 1;
624 }
625 TRACE("mapped %u out of %u\n", mapped, Count);
626
627 if (mapped == Count) return STATUS_SUCCESS;
628 if (mapped) return STATUS_SOME_NOT_MAPPED;
629 return STATUS_NONE_MAPPED;
630 }
631
632 /******************************************************************************
633 * LsaNtStatusToWinError [ADVAPI32.@]
634 *
635 * Converts an LSA NTSTATUS code to a Windows error code.
636 *
637 * PARAMS
638 * Status [I] NTSTATUS code.
639 *
640 * RETURNS
641 * Success: Corresponding Windows error code.
642 * Failure: ERROR_MR_MID_NOT_FOUND.
643 */
644 ULONG WINAPI LsaNtStatusToWinError(NTSTATUS Status)
645 {
646 return RtlNtStatusToDosError(Status);
647 }
648
649 /******************************************************************************
650 * LsaOpenPolicy [ADVAPI32.@]
651 *
652 * Opens a handle to the Policy object on a local or remote system.
653 *
654 * PARAMS
655 * SystemName [I] Name of the target system.
656 * ObjectAttributes [I] Connection attributes.
657 * DesiredAccess [I] Requested access rights.
658 * PolicyHandle [I/O] Handle to the Policy object.
659 *
660 * RETURNS
661 * Success: STATUS_SUCCESS.
662 * Failure: NTSTATUS code.
663 *
664 * NOTES
665 * Set SystemName to NULL to open the local Policy object.
666 */
667 NTSTATUS WINAPI LsaOpenPolicy(
668 IN PLSA_UNICODE_STRING SystemName,
669 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
670 IN ACCESS_MASK DesiredAccess,
671 IN OUT PLSA_HANDLE PolicyHandle)
672 {
673 FIXME("(%s,%p,0x%08x,%p) stub\n",
674 SystemName?debugstr_w(SystemName->Buffer):"(null)",
675 ObjectAttributes, DesiredAccess, PolicyHandle);
676
677 ADVAPI_ForceLocalComputer(SystemName ? SystemName->Buffer : NULL,
678 STATUS_ACCESS_VIOLATION);
679 dumpLsaAttributes(ObjectAttributes);
680
681 if(PolicyHandle) *PolicyHandle = (LSA_HANDLE)0xcafe;
682 return STATUS_SUCCESS;
683 }
684
685 /******************************************************************************
686 * LsaOpenTrustedDomainByName [ADVAPI32.@]
687 *
688 */
689 NTSTATUS WINAPI LsaOpenTrustedDomainByName(
690 LSA_HANDLE policy,
691 PLSA_UNICODE_STRING name,
692 ACCESS_MASK access,
693 PLSA_HANDLE handle)
694 {
695 FIXME("(%p,%p,0x%08x,%p) stub\n", policy, name, access, handle);
696 return STATUS_OBJECT_NAME_NOT_FOUND;
697 }
698
699 /******************************************************************************
700 * LsaQueryInformationPolicy [ADVAPI32.@]
701 *
702 * Returns information about a Policy object.
703 *
704 * PARAMS
705 * PolicyHandle [I] Handle to a Policy object.
706 * InformationClass [I] Type of information to retrieve.
707 * Buffer [O] Pointer to the requested information.
708 *
709 * RETURNS
710 * Success: STATUS_SUCCESS.
711 * Failure: NTSTATUS code.
712 */
713 NTSTATUS WINAPI LsaQueryInformationPolicy(
714 IN LSA_HANDLE PolicyHandle,
715 IN POLICY_INFORMATION_CLASS InformationClass,
716 OUT PVOID *Buffer)
717 {
718 TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
719
720 if(!Buffer) return STATUS_INVALID_PARAMETER;
721 switch (InformationClass)
722 {
723 case PolicyAuditEventsInformation: /* 2 */
724 {
725 PPOLICY_AUDIT_EVENTS_INFO p = heap_alloc_zero(sizeof(POLICY_AUDIT_EVENTS_INFO));
726 p->AuditingMode = FALSE; /* no auditing */
727 *Buffer = p;
728 }
729 break;
730 case PolicyPrimaryDomainInformation: /* 3 */
731 {
732 /* Only the domain name is valid for the local computer.
733 * All other fields are zero.
734 */
735 PPOLICY_PRIMARY_DOMAIN_INFO pinfo;
736
737 pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_PRIMARY_DOMAIN_INFO, Name));
738
739 TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
740
741 *Buffer = pinfo;
742 }
743 break;
744 case PolicyAccountDomainInformation: /* 5 */
745 {
746 struct di
747 {
748 POLICY_ACCOUNT_DOMAIN_INFO info;
749 SID sid;
750 DWORD padding[3];
751 WCHAR domain[MAX_COMPUTERNAME_LENGTH + 1];
752 };
753
754 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
755 struct di * xdi = heap_alloc_zero(sizeof(*xdi));
756
757 xdi->info.DomainName.MaximumLength = dwSize * sizeof(WCHAR);
758 xdi->info.DomainName.Buffer = xdi->domain;
759 if (GetComputerNameW(xdi->info.DomainName.Buffer, &dwSize))
760 xdi->info.DomainName.Length = dwSize * sizeof(WCHAR);
761
762 TRACE("setting name to %s\n", debugstr_w(xdi->info.DomainName.Buffer));
763
764 xdi->info.DomainSid = &xdi->sid;
765
766 if (!ADVAPI_GetComputerSid(&xdi->sid))
767 {
768 heap_free(xdi);
769
770 WARN("Computer SID not found\n");
771
772 return STATUS_UNSUCCESSFUL;
773 }
774
775 TRACE("setting SID to %s\n", debugstr_sid(&xdi->sid));
776
777 *Buffer = xdi;
778 }
779 break;
780 case PolicyDnsDomainInformation: /* 12 (0xc) */
781 {
782 struct
783 {
784 POLICY_DNS_DOMAIN_INFO info;
785 struct
786 {
787 SID sid;
788 DWORD sid_subauthority[3];
789 } domain_sid;
790 WCHAR domain_name[256];
791 WCHAR dns_domain_name[256];
792 WCHAR dns_forest_name[256];
793 } *xdi;
794 struct
795 {
796 SID sid;
797 DWORD sid_subauthority[3];
798 } computer_sid;
799 DWORD dwSize;
800
801 xdi = heap_alloc_zero(sizeof(*xdi));
802 if (!xdi) return STATUS_NO_MEMORY;
803
804 dwSize = 256;
805 if (GetComputerNameExW(ComputerNamePhysicalDnsDomain, xdi->domain_name, &dwSize))
806 {
807 WCHAR *dot;
808
809 dot = strrchrW(xdi->domain_name, '.');
810 if (dot) *dot = 0;
811 struprW(xdi->domain_name);
812 xdi->info.Name.Buffer = xdi->domain_name;
813 xdi->info.Name.Length = strlenW(xdi->domain_name) * sizeof(WCHAR);
814 xdi->info.Name.MaximumLength = xdi->info.Name.Length + sizeof(WCHAR);
815 TRACE("setting Name to %s\n", debugstr_w(xdi->info.Name.Buffer));
816 }
817
818 dwSize = 256;
819 if (GetComputerNameExW(ComputerNameDnsDomain, xdi->dns_domain_name, &dwSize))
820 {
821 xdi->info.DnsDomainName.Buffer = xdi->dns_domain_name;
822 xdi->info.DnsDomainName.Length = dwSize * sizeof(WCHAR);
823 xdi->info.DnsDomainName.MaximumLength = (dwSize + 1) * sizeof(WCHAR);
824 TRACE("setting DnsDomainName to %s\n", debugstr_w(xdi->info.DnsDomainName.Buffer));
825
826 xdi->info.DnsForestName.Buffer = xdi->dns_domain_name;
827 xdi->info.DnsForestName.Length = dwSize * sizeof(WCHAR);
828 xdi->info.DnsForestName.MaximumLength = (dwSize + 1) * sizeof(WCHAR);
829 TRACE("setting DnsForestName to %s\n", debugstr_w(xdi->info.DnsForestName.Buffer));
830 }
831
832 dwSize = sizeof(xdi->domain_sid);
833 if (ADVAPI_GetComputerSid(&computer_sid.sid) && GetWindowsAccountDomainSid(&computer_sid.sid, &xdi->domain_sid.sid, &dwSize))
834 {
835 xdi->info.Sid = &xdi->domain_sid.sid;
836 TRACE("setting SID to %s\n", debugstr_sid(&xdi->domain_sid.sid));
837 }
838
839 *Buffer = xdi;
840 }
841 break;
842 case PolicyAuditLogInformation:
843 case PolicyPdAccountInformation:
844 case PolicyLsaServerRoleInformation:
845 case PolicyReplicaSourceInformation:
846 case PolicyDefaultQuotaInformation:
847 case PolicyModificationInformation:
848 case PolicyAuditFullSetInformation:
849 case PolicyAuditFullQueryInformation:
850 {
851 FIXME("category %d not implemented\n", InformationClass);
852 return STATUS_UNSUCCESSFUL;
853 }
854 }
855 return STATUS_SUCCESS;
856 }
857
858 /******************************************************************************
859 * LsaQueryTrustedDomainInfo [ADVAPI32.@]
860 *
861 */
862 NTSTATUS WINAPI LsaQueryTrustedDomainInfo(
863 LSA_HANDLE policy,
864 PSID sid,
865 TRUSTED_INFORMATION_CLASS class,
866 PVOID *buffer)
867 {
868 FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer);
869 return STATUS_OBJECT_NAME_NOT_FOUND;
870 }
871
872 /******************************************************************************
873 * LsaQueryTrustedDomainInfoByName [ADVAPI32.@]
874 *
875 */
876 NTSTATUS WINAPI LsaQueryTrustedDomainInfoByName(
877 LSA_HANDLE policy,
878 PLSA_UNICODE_STRING name,
879 TRUSTED_INFORMATION_CLASS class,
880 PVOID *buffer)
881 {
882 FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer);
883 return STATUS_OBJECT_NAME_NOT_FOUND;
884 }
885
886 /******************************************************************************
887 * LsaRegisterPolicyChangeNotification [ADVAPI32.@]
888 *
889 */
890 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
891 POLICY_NOTIFICATION_INFORMATION_CLASS class,
892 HANDLE event)
893 {
894 FIXME("(%d,%p) stub\n", class, event);
895 return STATUS_UNSUCCESSFUL;
896 }
897
898 /******************************************************************************
899 * LsaRemoveAccountRights [ADVAPI32.@]
900 *
901 */
902 NTSTATUS WINAPI LsaRemoveAccountRights(
903 LSA_HANDLE policy,
904 PSID sid,
905 BOOLEAN all,
906 PLSA_UNICODE_STRING rights,
907 ULONG count)
908 {
909 FIXME("(%p,%p,%d,%p,0x%08x) stub\n", policy, sid, all, rights, count);
910 return STATUS_SUCCESS;
911 }
912
913 /******************************************************************************
914 * LsaRetrievePrivateData [ADVAPI32.@]
915 *
916 * Retrieves data stored by LsaStorePrivateData.
917 *
918 * PARAMS
919 * PolicyHandle [I] Handle to a Policy object.
920 * KeyName [I] Name of the key where the data is stored.
921 * PrivateData [O] Pointer to the private data.
922 *
923 * RETURNS
924 * Success: STATUS_SUCCESS.
925 * Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
926 */
927 NTSTATUS WINAPI LsaRetrievePrivateData(
928 IN LSA_HANDLE PolicyHandle,
929 IN PLSA_UNICODE_STRING KeyName,
930 OUT PLSA_UNICODE_STRING* PrivateData)
931 {
932 FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
933 return STATUS_OBJECT_NAME_NOT_FOUND;
934 }
935
936 /******************************************************************************
937 * LsaSetInformationPolicy [ADVAPI32.@]
938 *
939 * Modifies information in a Policy object.
940 *
941 * PARAMS
942 * PolicyHandle [I] Handle to a Policy object.
943 * InformationClass [I] Type of information to set.
944 * Buffer [I] Pointer to the information to set.
945 *
946 * RETURNS
947 * Success: STATUS_SUCCESS.
948 * Failure: NTSTATUS code.
949 */
950 NTSTATUS WINAPI LsaSetInformationPolicy(
951 IN LSA_HANDLE PolicyHandle,
952 IN POLICY_INFORMATION_CLASS InformationClass,
953 IN PVOID Buffer)
954 {
955 FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
956
957 return STATUS_UNSUCCESSFUL;
958 }
959
960 /******************************************************************************
961 * LsaSetSecret [ADVAPI32.@]
962 *
963 * Set old and new values on a secret handle
964 *
965 * PARAMS
966 * SecretHandle [I] Handle to a secret object.
967 * EncryptedCurrentValue [I] Pointer to encrypted new value, can be NULL
968 * EncryptedOldValue [I] Pointer to encrypted old value, can be NULL
969 *
970 * RETURNS
971 * Success: STATUS_SUCCESS
972 * Failure: NTSTATUS code.
973 */
974 NTSTATUS WINAPI LsaSetSecret(
975 IN LSA_HANDLE SecretHandle,
976 IN PLSA_UNICODE_STRING EncryptedCurrentValue,
977 IN PLSA_UNICODE_STRING EncryptedOldValue)
978 {
979 FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue,
980 EncryptedOldValue);
981 return STATUS_SUCCESS;
982 }
983
984 /******************************************************************************
985 * LsaSetTrustedDomainInfoByName [ADVAPI32.@]
986 *
987 */
988 NTSTATUS WINAPI LsaSetTrustedDomainInfoByName(
989 LSA_HANDLE policy,
990 PLSA_UNICODE_STRING name,
991 TRUSTED_INFORMATION_CLASS class,
992 PVOID buffer)
993 {
994 FIXME("(%p,%p,%d,%p) stub\n", policy, name, class, buffer);
995 return STATUS_SUCCESS;
996 }
997
998 /******************************************************************************
999 * LsaSetTrustedDomainInformation [ADVAPI32.@]
1000 *
1001 */
1002 NTSTATUS WINAPI LsaSetTrustedDomainInformation(
1003 LSA_HANDLE policy,
1004 PSID sid,
1005 TRUSTED_INFORMATION_CLASS class,
1006 PVOID buffer)
1007 {
1008 FIXME("(%p,%p,%d,%p) stub\n", policy, sid, class, buffer);
1009 return STATUS_SUCCESS;
1010 }
1011
1012 /******************************************************************************
1013 * LsaStorePrivateData [ADVAPI32.@]
1014 *
1015 * Stores or deletes a Policy object's data under the specified reg key.
1016 *
1017 * PARAMS
1018 * PolicyHandle [I] Handle to a Policy object.
1019 * KeyName [I] Name of the key where the data will be stored.
1020 * PrivateData [O] Pointer to the private data.
1021 *
1022 * RETURNS
1023 * Success: STATUS_SUCCESS.
1024 * Failure: STATUS_OBJECT_NAME_NOT_FOUND or NTSTATUS code.
1025 */
1026 NTSTATUS WINAPI LsaStorePrivateData(
1027 IN LSA_HANDLE PolicyHandle,
1028 IN PLSA_UNICODE_STRING KeyName,
1029 IN PLSA_UNICODE_STRING PrivateData)
1030 {
1031 FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
1032 return STATUS_OBJECT_NAME_NOT_FOUND;
1033 }
1034
1035 /******************************************************************************
1036 * LsaUnregisterPolicyChangeNotification [ADVAPI32.@]
1037 *
1038 */
1039 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
1040 POLICY_NOTIFICATION_INFORMATION_CLASS class,
1041 HANDLE event)
1042 {
1043 FIXME("(%d,%p) stub\n", class, event);
1044 return STATUS_SUCCESS;
1045 }
1046
1047 /******************************************************************************
1048 * LsaLookupPrivilegeName [ADVAPI32.@]
1049 *
1050 */
1051 NTSTATUS WINAPI LsaLookupPrivilegeName(LSA_HANDLE handle, LUID *luid, LSA_UNICODE_STRING **name)
1052 {
1053 const WCHAR *privnameW;
1054 DWORD length;
1055 WCHAR *strW;
1056
1057 TRACE("(%p,%p,%p)\n", handle, luid, name);
1058
1059 if (!luid || !handle)
1060 return STATUS_INVALID_PARAMETER;
1061
1062 *name = NULL;
1063
1064 if (!(privnameW = get_wellknown_privilege_name(luid)))
1065 return STATUS_NO_SUCH_PRIVILEGE;
1066
1067 length = strlenW(privnameW);
1068 *name = heap_alloc(sizeof(**name) + (length + 1) * sizeof(WCHAR));
1069 if (!*name)
1070 return STATUS_NO_MEMORY;
1071
1072 strW = (WCHAR *)(*name + 1);
1073 memcpy(strW, privnameW, length * sizeof(WCHAR));
1074 strW[length] = 0;
1075 RtlInitUnicodeString(*name, strW);
1076
1077 return STATUS_SUCCESS;
1078 }
1079
1080 /******************************************************************************
1081 * LsaLookupPrivilegeDisplayName [ADVAPI32.@]
1082 *
1083 */
1084 NTSTATUS WINAPI LsaLookupPrivilegeDisplayName(LSA_HANDLE handle, LSA_UNICODE_STRING *name,
1085 LSA_UNICODE_STRING **display_name, SHORT *language)
1086 {
1087 FIXME("(%p, %s, %p, %p)\n", handle, debugstr_us(name), display_name, language);
1088
1089 return STATUS_NO_SUCH_PRIVILEGE;
1090 }
1091
1092 /******************************************************************************
1093 * AuditQuerySystemPolicy [ADVAPI32.@]
1094 *
1095 */
1096 BOOLEAN WINAPI AuditQuerySystemPolicy(const GUID* guids, ULONG count, AUDIT_POLICY_INFORMATION** policy)
1097 {
1098
1099 FIXME("(%p, %d, %p)\n", guids, count, policy);
1100 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
1101 return FALSE;
1102 }
Windows API implementation