projects / reactos.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
[ADVAPI32/LSASRV]
[reactos.git] / reactos / dll / win32 / advapi32 / sec / lsa.c
1 /*
2 * COPYRIGHT: See COPYING in the top level directory
3 * PROJECT: ReactOS system libraries
4 * FILE: dll/win32/advapi32/sec/lsa.c
5 * PURPOSE: Local security authority functions
6 * PROGRAMMER: Emanuele Aliberti
7 * UPDATE HISTORY:
8 * 19990322 EA created
9 * 19990515 EA stubs
10 * 20030202 KJK compressed stubs
11 *
12 */
13 #include <advapi32.h>
14 #include "wine/debug.h"
15 #include "wine/unicode.h"
16
17 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
18
19 /* imported from wine 1.1.14 */
20 static void* ADVAPI_GetDomainName(unsigned sz, unsigned ofs)
21 {
22 HKEY key;
23 LONG ret;
24 BYTE* ptr = NULL;
25 UNICODE_STRING* ustr;
26
27 static const WCHAR wVNETSUP[] = {
28 'S','y','s','t','e','m','\\',
29 'C','u','r','r','e','n','t','C','o','n','t','r','o','l','S','e','t','\\',
30 'S','e','r','v','i','c','e','s','\\',
31 'V','x','D','\\','V','N','E','T','S','U','P','\0'};
32
33 ret = RegOpenKeyExW(HKEY_LOCAL_MACHINE, wVNETSUP, 0, KEY_READ, &key);
34 if (ret == ERROR_SUCCESS)
35 {
36 DWORD size = 0;
37 static const WCHAR wg[] = { 'W','o','r','k','g','r','o','u','p',0 };
38
39 ret = RegQueryValueExW(key, wg, NULL, NULL, NULL, &size);
40 if (ret == ERROR_MORE_DATA || ret == ERROR_SUCCESS)
41 {
42 ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sz + size);
43 if (!ptr) return NULL;
44 ustr = (UNICODE_STRING*)(ptr + ofs);
45 ustr->MaximumLength = size;
46 ustr->Buffer = (WCHAR*)(ptr + sz);
47 ret = RegQueryValueExW(key, wg, NULL, NULL, (LPBYTE)ustr->Buffer, &size);
48 if (ret != ERROR_SUCCESS)
49 {
50 HeapFree(GetProcessHeap(), 0, ptr);
51 ptr = NULL;
52 }
53 else ustr->Length = size - sizeof(WCHAR);
54 }
55 RegCloseKey(key);
56 }
57 if (!ptr)
58 {
59 static const WCHAR wDomain[] = {'D','O','M','A','I','N','\0'};
60 ptr = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY,
61 sz + sizeof(wDomain));
62 if (!ptr) return NULL;
63 ustr = (UNICODE_STRING*)(ptr + ofs);
64 ustr->MaximumLength = sizeof(wDomain);
65 ustr->Buffer = (WCHAR*)(ptr + sz);
66 ustr->Length = sizeof(wDomain) - sizeof(WCHAR);
67 memcpy(ustr->Buffer, wDomain, sizeof(wDomain));
68 }
69 return ptr;
70 }
71
72
73 static BOOL LsapIsLocalComputer(PLSA_UNICODE_STRING ServerName)
74 {
75 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
76 BOOL Result;
77 LPWSTR buf;
78
79 if (ServerName == NULL || ServerName->Length == 0 || ServerName->Buffer == NULL)
80 return TRUE;
81
82 buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
83 Result = GetComputerNameW(buf, &dwSize);
84 if (Result && (ServerName->Buffer[0] == '\\') && (ServerName->Buffer[1] == '\\'))
85 ServerName += 2;
86 Result = Result && !lstrcmpW(ServerName->Buffer, buf);
87 HeapFree(GetProcessHeap(), 0, buf);
88
89 return Result;
90 }
91
92
93 handle_t __RPC_USER
94 PLSAPR_SERVER_NAME_bind(PLSAPR_SERVER_NAME pszSystemName)
95 {
96 handle_t hBinding = NULL;
97 LPWSTR pszStringBinding;
98 RPC_STATUS status;
99
100 TRACE("PLSAPR_SERVER_NAME_bind() called\n");
101
102 status = RpcStringBindingComposeW(NULL,
103 L"ncacn_np",
104 pszSystemName,
105 L"\\pipe\\lsarpc",
106 NULL,
107 &pszStringBinding);
108 if (status)
109 {
110 TRACE("RpcStringBindingCompose returned 0x%x\n", status);
111 return NULL;
112 }
113
114 /* Set the binding handle that will be used to bind to the server. */
115 status = RpcBindingFromStringBindingW(pszStringBinding,
116 &hBinding);
117 if (status)
118 {
119 TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
120 }
121
122 status = RpcStringFreeW(&pszStringBinding);
123 if (status)
124 {
125 TRACE("RpcStringFree returned 0x%x\n", status);
126 }
127
128 return hBinding;
129 }
130
131
132 void __RPC_USER
133 PLSAPR_SERVER_NAME_unbind(PLSAPR_SERVER_NAME pszSystemName,
134 handle_t hBinding)
135 {
136 RPC_STATUS status;
137
138 TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
139
140 status = RpcBindingFree(&hBinding);
141 if (status)
142 {
143 TRACE("RpcBindingFree returned 0x%x\n", status);
144 }
145 }
146
147
148 /*
149 * @implemented
150 */
151 NTSTATUS WINAPI
152 LsaClose(LSA_HANDLE ObjectHandle)
153 {
154 NTSTATUS Status;
155
156 TRACE("LsaClose(0x%p) called\n", ObjectHandle);
157
158 RpcTryExcept
159 {
160 Status = LsarClose((PLSAPR_HANDLE)&ObjectHandle);
161 }
162 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
163 {
164 Status = I_RpcMapWin32Status(RpcExceptionCode());
165 }
166 RpcEndExcept;
167
168 return Status;
169 }
170
171
172 /*
173 * @implemented
174 */
175 NTSTATUS WINAPI
176 LsaDelete(LSA_HANDLE ObjectHandle)
177 {
178 NTSTATUS Status;
179
180 TRACE("LsaDelete(0x%p) called\n", ObjectHandle);
181
182 RpcTryExcept
183 {
184 Status = LsarDelete((LSAPR_HANDLE)ObjectHandle);
185 }
186 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
187 {
188 Status = I_RpcMapWin32Status(RpcExceptionCode());
189 }
190 RpcEndExcept;
191
192 return Status;
193 }
194
195
196 /*
197 * @unimplemented
198 */
199 NTSTATUS
200 WINAPI
201 LsaAddAccountRights(
202 LSA_HANDLE PolicyHandle,
203 PSID AccountSid,
204 PLSA_UNICODE_STRING UserRights,
205 ULONG CountOfRights)
206 {
207 FIXME("(%p,%p,%p,0x%08x) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
208 return STATUS_OBJECT_NAME_NOT_FOUND;
209 }
210
211 /*
212 * @unimplemented
213 */
214 NTSTATUS
215 WINAPI
216 LsaCreateTrustedDomainEx(
217 LSA_HANDLE PolicyHandle,
218 PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
219 PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
220 ACCESS_MASK DesiredAccess,
221 PLSA_HANDLE TrustedDomainHandle)
222 {
223 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
224 DesiredAccess, TrustedDomainHandle);
225 return STATUS_SUCCESS;
226 }
227
228 /*
229 * @unimplemented
230 */
231 NTSTATUS
232 WINAPI
233 LsaDeleteTrustedDomain(
234 LSA_HANDLE PolicyHandle,
235 PSID TrustedDomainSid)
236 {
237 FIXME("(%p,%p) stub\n", PolicyHandle, TrustedDomainSid);
238 return STATUS_SUCCESS;
239 }
240
241 /*
242 * @implemented
243 */
244 NTSTATUS
245 WINAPI
246 LsaEnumerateAccountRights(
247 LSA_HANDLE PolicyHandle,
248 PSID AccountSid,
249 PLSA_UNICODE_STRING *UserRights,
250 PULONG CountOfRights)
251 {
252 LSAPR_USER_RIGHT_SET UserRightsSet;
253 NTSTATUS Status;
254
255 TRACE("(%p,%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
256
257 UserRightsSet.Entries = 0;
258 UserRightsSet.UserRights = NULL;
259
260 RpcTryExcept
261 {
262 Status = LsarEnmuerateAccountRights((LSAPR_HANDLE)PolicyHandle,
263 AccountSid,
264 &UserRightsSet);
265
266 *CountOfRights = UserRightsSet.Entries;
267 *UserRights = (PUNICODE_STRING)UserRightsSet.UserRights;
268 }
269 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
270 {
271 Status = I_RpcMapWin32Status(RpcExceptionCode());
272
273 if (UserRightsSet.UserRights != NULL)
274 {
275 MIDL_user_free(UserRightsSet.UserRights);
276 }
277 }
278 RpcEndExcept;
279
280 return Status;
281 }
282
283 /*
284 * @unimplemented
285 */
286 NTSTATUS
287 WINAPI
288 LsaEnumerateAccountsWithUserRight(
289 LSA_HANDLE PolicyHandle,
290 OPTIONAL PLSA_UNICODE_STRING UserRights,
291 PVOID *EnumerationBuffer,
292 PULONG CountReturned)
293 {
294 FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, UserRights, EnumerationBuffer, CountReturned);
295 return STATUS_NO_MORE_ENTRIES;
296 }
297
298 /*
299 * @unimplemented
300 */
301 NTSTATUS
302 WINAPI
303 LsaEnumerateTrustedDomains(
304 LSA_HANDLE PolicyHandle,
305 PLSA_ENUMERATION_HANDLE EnumerationContext,
306 PVOID *Buffer,
307 ULONG PreferedMaximumLength,
308 PULONG CountReturned)
309 {
310 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
311 Buffer, PreferedMaximumLength, CountReturned);
312
313 if (CountReturned) *CountReturned = 0;
314 return STATUS_SUCCESS;
315 }
316
317 /*
318 * @unimplemented
319 */
320 NTSTATUS
321 WINAPI
322 LsaEnumerateTrustedDomainsEx(
323 LSA_HANDLE PolicyHandle,
324 PLSA_ENUMERATION_HANDLE EnumerationContext,
325 PVOID *Buffer,
326 ULONG PreferedMaximumLength,
327 PULONG CountReturned)
328 {
329 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext, Buffer,
330 PreferedMaximumLength, CountReturned);
331 if (CountReturned) *CountReturned = 0;
332 return STATUS_SUCCESS;
333 }
334
335 /*
336 * @implemented
337 */
338 NTSTATUS
339 WINAPI
340 LsaFreeMemory(PVOID Buffer)
341 {
342 TRACE("(%p)\n", Buffer);
343 return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
344 }
345
346 /*
347 * @implemented
348 */
349 NTSTATUS
350 WINAPI
351 LsaLookupNames(
352 LSA_HANDLE PolicyHandle,
353 ULONG Count,
354 PLSA_UNICODE_STRING Names,
355 PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
356 PLSA_TRANSLATED_SID *Sids)
357 {
358 PLSA_TRANSLATED_SID2 Sids2;
359 LSA_TRANSLATED_SID *TranslatedSids;
360 ULONG i;
361 NTSTATUS Status;
362
363 TRACE("(%p,0x%08x,%p,%p,%p)\n", PolicyHandle, Count, Names,
364 ReferencedDomains, Sids);
365
366 /* Call LsaLookupNames2, which supersedes this function */
367 Status = LsaLookupNames2(PolicyHandle, Count, 0, Names, ReferencedDomains, &Sids2);
368 if (!NT_SUCCESS(Status))
369 return Status;
370
371 /* Translate the returned structure */
372 TranslatedSids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID));
373 if (!TranslatedSids)
374 {
375 LsaFreeMemory(Sids2);
376 return SCESTATUS_NOT_ENOUGH_RESOURCE;
377 }
378 RtlZeroMemory(Sids, Count * sizeof(PLSA_TRANSLATED_SID));
379 for (i = 0; i < Count; i++)
380 {
381 TranslatedSids[i].Use = Sids2[i].Use;
382 if (Sids2[i].Use != SidTypeInvalid && Sids2[i].Use != SidTypeUnknown)
383 {
384 TranslatedSids[i].DomainIndex = Sids2[i].DomainIndex;
385 if (Sids2[i].Use != SidTypeDomain)
386 TranslatedSids[i].RelativeId = *GetSidSubAuthority(Sids2[i].Sid, 0);
387 }
388 }
389 LsaFreeMemory(Sids2);
390
391 *Sids = TranslatedSids;
392
393 return Status;
394 }
395
396 /*
397 * @unimplemented
398 */
399 NTSTATUS
400 WINAPI
401 LsaLookupNames2(
402 LSA_HANDLE PolicyHandle,
403 ULONG Flags,
404 ULONG Count,
405 PLSA_UNICODE_STRING Names,
406 PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
407 PLSA_TRANSLATED_SID2 *Sids)
408 {
409 FIXME("(%p,0x%08x,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Flags,
410 Count, Names, ReferencedDomains, Sids);
411 if (Names != NULL && Count > 0)
412 {
413 *ReferencedDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_REFERENCED_DOMAIN_LIST));
414 *Sids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID2));
415 return STATUS_SOME_NOT_MAPPED;
416 }
417 return STATUS_NONE_MAPPED;
418 }
419
420 /*
421 * @unmplemented
422 */
423 NTSTATUS
424 WINAPI
425 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle,
426 IN PLUID Value,
427 OUT PUNICODE_STRING *Name)
428 {
429 PRPC_UNICODE_STRING NameBuffer = NULL;
430 NTSTATUS Status;
431
432 TRACE("(%p,%p,%p) stub\n", PolicyHandle, Value, Name);
433
434 RpcTryExcept
435 {
436 Status = LsarLookupPrivilegeName(PolicyHandle,
437 Value,
438 &NameBuffer);
439
440 *Name = (PUNICODE_STRING)NameBuffer;
441 }
442 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
443 {
444 if (NameBuffer != NULL)
445 MIDL_user_free(NameBuffer);
446
447 Status = I_RpcMapWin32Status(RpcExceptionCode());
448 }
449 RpcEndExcept;
450
451 return Status;
452 }
453
454 /*
455 * @implemented
456 */
457 NTSTATUS
458 WINAPI
459 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle,
460 IN PLSA_UNICODE_STRING Name,
461 OUT PLUID Value)
462 {
463 LUID Luid;
464 NTSTATUS Status;
465
466 TRACE("(%p,%p,%p) stub\n", PolicyHandle, Name, Value);
467
468 RpcTryExcept
469 {
470 Status = LsarLookupPrivilegeValue(PolicyHandle,
471 (PRPC_UNICODE_STRING)Name,
472 &Luid);
473 if (Status == STATUS_SUCCESS)
474 *Value = Luid;
475 }
476 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
477 {
478 Status = I_RpcMapWin32Status(RpcExceptionCode());
479 }
480 RpcEndExcept;
481
482 return Status;
483 }
484
485 /*
486 * @unimplemented
487 */
488 NTSTATUS
489 WINAPI
490 LsaLookupSids(
491 LSA_HANDLE PolicyHandle,
492 ULONG Count,
493 PSID *Sids,
494 PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
495 PLSA_TRANSLATED_NAME *Names)
496 {
497 static const UNICODE_STRING UserName = RTL_CONSTANT_STRING(L"Administrator");
498 PLSA_REFERENCED_DOMAIN_LIST LocalDomains;
499 PLSA_TRANSLATED_NAME LocalNames;
500
501 TRACE("(%p,%u,%p,%p,%p) stub\n", PolicyHandle, Count, Sids,
502 ReferencedDomains, Names);
503
504 WARN("LsaLookupSids(): stub. Always returning 'Administrator'\n");
505 if (Count != 1)
506 return STATUS_NONE_MAPPED;
507 LocalDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_TRANSLATED_SID));
508 if (!LocalDomains)
509 return SCESTATUS_NOT_ENOUGH_RESOURCE;
510 LocalNames = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_TRANSLATED_NAME) + UserName.MaximumLength);
511 if (!LocalNames)
512 {
513 LsaFreeMemory(LocalDomains);
514 return SCESTATUS_NOT_ENOUGH_RESOURCE;
515 }
516 LocalDomains[0].Entries = 0;
517 LocalDomains[0].Domains = NULL;
518 LocalNames[0].Use = SidTypeWellKnownGroup;
519 LocalNames[0].Name.Buffer = (LPWSTR)((ULONG_PTR)(LocalNames) + sizeof(LSA_TRANSLATED_NAME));
520 LocalNames[0].Name.Length = UserName.Length;
521 LocalNames[0].Name.MaximumLength = UserName.MaximumLength;
522 RtlCopyMemory(LocalNames[0].Name.Buffer, UserName.Buffer, UserName.MaximumLength);
523
524 *ReferencedDomains = LocalDomains;
525 *Names = LocalNames;
526 return STATUS_SUCCESS;
527 }
528
529 /******************************************************************************
530 * LsaNtStatusToWinError
531 *
532 * PARAMS
533 * Status [I]
534 *
535 * @implemented
536 */
537 ULONG WINAPI
538 LsaNtStatusToWinError(NTSTATUS Status)
539 {
540 TRACE("(%lx)\n", Status);
541 return RtlNtStatusToDosError(Status);
542 }
543
544 /******************************************************************************
545 * LsaOpenPolicy
546 *
547 * PARAMS
548 * x1 []
549 * x2 []
550 * x3 []
551 * x4 []
552 *
553 * @unimplemented
554 */
555 NTSTATUS
556 WINAPI
557 LsaOpenPolicy(
558 IN PLSA_UNICODE_STRING SystemName,
559 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
560 IN ACCESS_MASK DesiredAccess,
561 IN OUT PLSA_HANDLE PolicyHandle)
562 {
563 NTSTATUS Status;
564
565 TRACE("LsaOpenPolicy (%s,%p,0x%08x,%p)\n",
566 SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
567 ObjectAttributes, DesiredAccess, PolicyHandle);
568
569 /* FIXME: RPC should take care of this */
570 if (!LsapIsLocalComputer(SystemName))
571 return RPC_NT_SERVER_UNAVAILABLE;
572
573 RpcTryExcept
574 {
575 *PolicyHandle = NULL;
576
577 Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
578 (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
579 DesiredAccess,
580 PolicyHandle);
581 }
582 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
583 {
584 Status = I_RpcMapWin32Status(RpcExceptionCode());
585 }
586 RpcEndExcept;
587
588 TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
589
590 return Status;
591 }
592
593
594 /*
595 * @unimplemented
596 */
597 NTSTATUS
598 WINAPI
599 LsaOpenTrustedDomainByName(
600 LSA_HANDLE PolicyHandle,
601 PLSA_UNICODE_STRING TrustedDomainName,
602 ACCESS_MASK DesiredAccess,
603 PLSA_HANDLE TrustedDomainHandle)
604 {
605 FIXME("(%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainName, DesiredAccess, TrustedDomainHandle);
606 return STATUS_OBJECT_NAME_NOT_FOUND;
607 }
608
609 /*
610 * @unimplemented
611 */
612 NTSTATUS
613 WINAPI
614 LsaQueryDomainInformationPolicy(
615 LSA_HANDLE PolicyHandle,
616 POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
617 PVOID *Buffer)
618 {
619 FIXME("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
620 return STATUS_NOT_IMPLEMENTED;
621 }
622
623 /*
624 * @unimplemented
625 */
626 NTSTATUS
627 WINAPI
628 LsaQueryForestTrustInformation(
629 LSA_HANDLE PolicyHandle,
630 PLSA_UNICODE_STRING TrustedDomainName,
631 PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
632 {
633 FIXME("(%p,%p,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo);
634 return STATUS_NOT_IMPLEMENTED;
635 }
636
637 /*
638 * @unimplemented
639 */
640 NTSTATUS WINAPI
641 LsaQueryInformationPolicy(LSA_HANDLE PolicyHandle,
642 POLICY_INFORMATION_CLASS InformationClass,
643 PVOID *Buffer)
644 {
645 TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
646
647 if(!Buffer) return STATUS_INVALID_PARAMETER;
648 switch (InformationClass)
649 {
650 case PolicyAuditEventsInformation: /* 2 */
651 {
652 PPOLICY_AUDIT_EVENTS_INFO p = RtlAllocateHeap(RtlGetProcessHeap(), HEAP_ZERO_MEMORY,
653 sizeof(POLICY_AUDIT_EVENTS_INFO));
654 p->AuditingMode = FALSE; /* no auditing */
655 *Buffer = p;
656 }
657 break;
658 case PolicyPrimaryDomainInformation: /* 3 */
659 {
660 /* Only the domain name is valid for the local computer.
661 * All other fields are zero.
662 */
663 PPOLICY_PRIMARY_DOMAIN_INFO pinfo;
664
665 pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_PRIMARY_DOMAIN_INFO, Name));
666
667 TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
668
669 *Buffer = pinfo;
670 }
671 case PolicyAccountDomainInformation: /* 5 */
672 {
673 struct di
674 {
675 POLICY_ACCOUNT_DOMAIN_INFO info;
676 SID sid;
677 DWORD padding[3];
678 WCHAR domain[MAX_COMPUTERNAME_LENGTH + 1];
679 };
680
681 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
682 struct di * xdi = HeapAlloc(GetProcessHeap(), HEAP_ZERO_MEMORY, sizeof(*xdi));
683
684 xdi->info.DomainName.MaximumLength = dwSize * sizeof(WCHAR);
685 xdi->info.DomainName.Buffer = xdi->domain;
686 if (GetComputerNameW(xdi->info.DomainName.Buffer, &dwSize))
687 xdi->info.DomainName.Length = dwSize * sizeof(WCHAR);
688
689 TRACE("setting name to %s\n", debugstr_w(xdi->info.DomainName.Buffer));
690
691 xdi->info.DomainSid = &xdi->sid;
692
693 /* read the computer SID from the registry */
694 if (!ADVAPI_GetComputerSid(&xdi->sid))
695 {
696 HeapFree(GetProcessHeap(), 0, xdi);
697
698 WARN("Computer SID not found\n");
699
700 return STATUS_UNSUCCESSFUL;
701 }
702
703 *Buffer = xdi;
704 }
705 break;
706 case PolicyDnsDomainInformation: /* 12 (0xc) */
707 {
708 /* Only the domain name is valid for the local computer.
709 * All other fields are zero.
710 */
711 PPOLICY_DNS_DOMAIN_INFO pinfo;
712
713 pinfo = ADVAPI_GetDomainName(sizeof(*pinfo), offsetof(POLICY_DNS_DOMAIN_INFO, Name));
714
715 TRACE("setting domain to %s\n", debugstr_w(pinfo->Name.Buffer));
716
717 *Buffer = pinfo;
718 }
719 break;
720 case PolicyAuditLogInformation:
721 case PolicyPdAccountInformation:
722 case PolicyLsaServerRoleInformation:
723 case PolicyReplicaSourceInformation:
724 case PolicyDefaultQuotaInformation:
725 case PolicyModificationInformation:
726 case PolicyAuditFullSetInformation:
727 case PolicyAuditFullQueryInformation:
728 case PolicyEfsInformation:
729 {
730 FIXME("category not implemented\n");
731 return STATUS_UNSUCCESSFUL;
732 }
733 }
734 return STATUS_SUCCESS;
735 }
736
737 /*
738 * @unimplemented
739 */
740 NTSTATUS
741 WINAPI
742 LsaQueryTrustedDomainInfoByName(
743 LSA_HANDLE PolicyHandle,
744 PLSA_UNICODE_STRING TrustedDomainName,
745 TRUSTED_INFORMATION_CLASS InformationClass,
746 PVOID *Buffer)
747 {
748 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
749 return STATUS_OBJECT_NAME_NOT_FOUND;
750 }
751
752 /*
753 * @unimplemented
754 */
755 NTSTATUS
756 WINAPI
757 LsaQueryTrustedDomainInfo(
758 LSA_HANDLE PolicyHandle,
759 PSID TrustedDomainSid,
760 TRUSTED_INFORMATION_CLASS InformationClass,
761 PVOID *Buffer)
762 {
763 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
764 return STATUS_OBJECT_NAME_NOT_FOUND;
765 }
766
767 /*
768 * @unimplemented
769 */
770 NTSTATUS
771 WINAPI
772 LsaRemoveAccountRights(
773 LSA_HANDLE PolicyHandle,
774 PSID AccountSid,
775 BOOLEAN AllRights,
776 PLSA_UNICODE_STRING UserRights,
777 ULONG CountOfRights)
778 {
779 FIXME("(%p,%p,%d,%p,0x%08x) stub\n", PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
780 return STATUS_SUCCESS;
781 }
782
783 /*
784 * @unimplemented
785 */
786 NTSTATUS
787 WINAPI
788 LsaRetrievePrivateData(
789 LSA_HANDLE PolicyHandle,
790 PLSA_UNICODE_STRING KeyName,
791 PLSA_UNICODE_STRING *PrivateData)
792 {
793 FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
794 return STATUS_OBJECT_NAME_NOT_FOUND;
795 }
796
797 /*
798 * @unimplemented
799 */
800 NTSTATUS
801 WINAPI
802 LsaSetDomainInformationPolicy(
803 LSA_HANDLE PolicyHandle,
804 POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
805 PVOID Buffer)
806 {
807 FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
808 return STATUS_UNSUCCESSFUL;
809 }
810
811 /*
812 * @unimplemented
813 */
814 NTSTATUS
815 WINAPI
816 LsaSetInformationPolicy(
817 LSA_HANDLE PolicyHandle,
818 POLICY_INFORMATION_CLASS InformationClass,
819 PVOID Buffer)
820 {
821 FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
822 return STATUS_UNSUCCESSFUL;
823 }
824
825 /*
826 * @unimplemented
827 */
828 NTSTATUS WINAPI LsaSetSecret(
829 IN LSA_HANDLE SecretHandle,
830 IN PLSA_UNICODE_STRING EncryptedCurrentValue,
831 IN PLSA_UNICODE_STRING EncryptedOldValue)
832 {
833 FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue,
834 EncryptedOldValue);
835 return STATUS_SUCCESS;
836 }
837
838 /*
839 * @unimplemented
840 */
841 NTSTATUS
842 WINAPI
843 LsaSetForestTrustInformation(
844 LSA_HANDLE PolicyHandle,
845 PLSA_UNICODE_STRING TrustedDomainName,
846 PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
847 BOOL CheckOnly,
848 PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
849 {
850 FIXME("(%p,%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
851 return STATUS_NOT_IMPLEMENTED;
852 }
853
854 /*
855 * @unimplemented
856 */
857 NTSTATUS
858 WINAPI
859 LsaSetTrustedDomainInfoByName(
860 LSA_HANDLE PolicyHandle,
861 PLSA_UNICODE_STRING TrustedDomainName,
862 TRUSTED_INFORMATION_CLASS InformationClass,
863 PVOID Buffer)
864 {
865 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
866 return STATUS_SUCCESS;
867 }
868
869 /*
870 * @unimplemented
871 */
872 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
873 POLICY_NOTIFICATION_INFORMATION_CLASS class,
874 HANDLE event)
875 {
876 FIXME("(%d,%p) stub\n", class, event);
877 return STATUS_UNSUCCESSFUL;
878 }
879
880 /*
881 * @unimplemented
882 */
883 NTSTATUS
884 WINAPI
885 LsaSetTrustedDomainInformation(
886 LSA_HANDLE PolicyHandle,
887 PSID TrustedDomainSid,
888 TRUSTED_INFORMATION_CLASS InformationClass,
889 PVOID Buffer)
890 {
891 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
892 return STATUS_SUCCESS;
893 }
894
895 /*
896 * @unimplemented
897 */
898 NTSTATUS
899 WINAPI
900 LsaStorePrivateData(
901 LSA_HANDLE PolicyHandle,
902 PLSA_UNICODE_STRING KeyName,
903 PLSA_UNICODE_STRING PrivateData)
904 {
905 FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
906 return STATUS_OBJECT_NAME_NOT_FOUND;
907 }
908
909 /*
910 * @unimplemented
911 */
912 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
913 POLICY_NOTIFICATION_INFORMATION_CLASS class,
914 HANDLE event)
915 {
916 FIXME("(%d,%p) stub\n", class, event);
917 return STATUS_SUCCESS;
918 }
919
920 /*
921 * @unimplemented
922 */
923 NTSTATUS
924 WINAPI
925 LsaGetUserName(
926 PUNICODE_STRING *UserName,
927 PUNICODE_STRING *DomainName)
928 {
929 FIXME("(%p,%p) stub\n", UserName, DomainName);
930 return STATUS_NOT_IMPLEMENTED;
931 }
932
933 /*
934 * @unimplemented
935 */
936 NTSTATUS
937 WINAPI
938 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
939 DWORD Unknonw1,
940 DWORD Unknonw2)
941 {
942 FIXME("(%d,%d,%d) stub\n", Unknonw0, Unknonw1, Unknonw2);
943 return STATUS_NOT_IMPLEMENTED;
944 }
945
946
947 /* EOF */
A free Windows-compatible Operating System