[CMAKE]
[reactos.git] / 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
20 static BOOL LsapIsLocalComputer(PLSA_UNICODE_STRING ServerName)
21 {
22 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
23 BOOL Result;
24 LPWSTR buf;
25
26 if (ServerName == NULL || ServerName->Length == 0 || ServerName->Buffer == NULL)
27 return TRUE;
28
29 buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
30 Result = GetComputerNameW(buf, &dwSize);
31 if (Result && (ServerName->Buffer[0] == '\\') && (ServerName->Buffer[1] == '\\'))
32 ServerName += 2;
33 Result = Result && !lstrcmpW(ServerName->Buffer, buf);
34 HeapFree(GetProcessHeap(), 0, buf);
35
36 return Result;
37 }
38
39
40 handle_t __RPC_USER
41 PLSAPR_SERVER_NAME_bind(PLSAPR_SERVER_NAME pszSystemName)
42 {
43 handle_t hBinding = NULL;
44 LPWSTR pszStringBinding;
45 RPC_STATUS status;
46
47 TRACE("PLSAPR_SERVER_NAME_bind() called\n");
48
49 status = RpcStringBindingComposeW(NULL,
50 L"ncacn_np",
51 pszSystemName,
52 L"\\pipe\\lsarpc",
53 NULL,
54 &pszStringBinding);
55 if (status)
56 {
57 TRACE("RpcStringBindingCompose returned 0x%x\n", status);
58 return NULL;
59 }
60
61 /* Set the binding handle that will be used to bind to the server. */
62 status = RpcBindingFromStringBindingW(pszStringBinding,
63 &hBinding);
64 if (status)
65 {
66 TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
67 }
68
69 status = RpcStringFreeW(&pszStringBinding);
70 if (status)
71 {
72 TRACE("RpcStringFree returned 0x%x\n", status);
73 }
74
75 return hBinding;
76 }
77
78
79 void __RPC_USER
80 PLSAPR_SERVER_NAME_unbind(PLSAPR_SERVER_NAME pszSystemName,
81 handle_t hBinding)
82 {
83 RPC_STATUS status;
84
85 TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
86
87 status = RpcBindingFree(&hBinding);
88 if (status)
89 {
90 TRACE("RpcBindingFree returned 0x%x\n", status);
91 }
92 }
93
94
95 /*
96 * @implemented
97 */
98 NTSTATUS
99 WINAPI
100 LsaClose(IN LSA_HANDLE ObjectHandle)
101 {
102 NTSTATUS Status;
103
104 TRACE("LsaClose(0x%p) called\n", ObjectHandle);
105
106 RpcTryExcept
107 {
108 Status = LsarClose((PLSAPR_HANDLE)&ObjectHandle);
109 }
110 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
111 {
112 Status = I_RpcMapWin32Status(RpcExceptionCode());
113 }
114 RpcEndExcept;
115
116 return Status;
117 }
118
119
120 /*
121 * @implemented
122 */
123 NTSTATUS
124 WINAPI
125 LsaDelete(IN LSA_HANDLE ObjectHandle)
126 {
127 NTSTATUS Status;
128
129 TRACE("LsaDelete(0x%p) called\n", ObjectHandle);
130
131 RpcTryExcept
132 {
133 Status = LsarDelete((LSAPR_HANDLE)ObjectHandle);
134 }
135 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
136 {
137 Status = I_RpcMapWin32Status(RpcExceptionCode());
138 }
139 RpcEndExcept;
140
141 return Status;
142 }
143
144
145 /*
146 * @implemented
147 */
148 NTSTATUS
149 WINAPI
150 LsaAddAccountRights(IN LSA_HANDLE PolicyHandle,
151 IN PSID AccountSid,
152 IN PLSA_UNICODE_STRING UserRights,
153 IN ULONG CountOfRights)
154 {
155 LSAPR_USER_RIGHT_SET UserRightSet;
156 NTSTATUS Status;
157
158 TRACE("(%p,%p,%p,0x%08x) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
159
160 UserRightSet.Entries = CountOfRights;
161 UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
162
163 RpcTryExcept
164 {
165 Status = LsarAddAccountRights((LSAPR_HANDLE)PolicyHandle,
166 (PRPC_SID)AccountSid,
167 &UserRightSet);
168
169 }
170 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
171 {
172 Status = I_RpcMapWin32Status(RpcExceptionCode());
173 }
174 RpcEndExcept;
175
176 return Status;
177 }
178
179
180 /*
181 * @implemented
182 */
183 NTSTATUS
184 WINAPI
185 LsaAddPrivilegesToAccount(IN LSA_HANDLE AccountHandle,
186 IN PPRIVILEGE_SET PrivilegeSet)
187 {
188 NTSTATUS Status;
189
190 TRACE("(%p,%p) stub\n", AccountHandle, PrivilegeSet);
191
192 RpcTryExcept
193 {
194 Status = LsarAddPrivilegesToAccount((LSAPR_HANDLE)AccountHandle,
195 (PLSAPR_PRIVILEGE_SET)PrivilegeSet);
196 }
197 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
198 {
199 Status = I_RpcMapWin32Status(RpcExceptionCode());
200 }
201 RpcEndExcept;
202
203 return Status;
204 }
205
206
207 /*
208 * @implemented
209 */
210 NTSTATUS
211 WINAPI
212 LsaCreateAccount(IN LSA_HANDLE PolicyHandle,
213 IN PSID AccountSid,
214 IN ULONG Flags,
215 OUT PLSA_HANDLE AccountHandle)
216 {
217 NTSTATUS Status;
218
219 TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, AccountSid, Flags, AccountHandle);
220
221 RpcTryExcept
222 {
223 Status = LsarCreateAccount((LSAPR_HANDLE)PolicyHandle,
224 AccountSid,
225 Flags,
226 AccountHandle);
227 }
228 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
229 {
230 Status = I_RpcMapWin32Status(RpcExceptionCode());
231 }
232 RpcEndExcept;
233
234 return Status;
235 }
236
237
238 /*
239 * @implemented
240 */
241 NTSTATUS
242 WINAPI
243 LsaCreateTrustedDomain(IN LSA_HANDLE PolicyHandle,
244 IN PLSA_TRUST_INFORMATION TrustedDomainInformation,
245 IN ACCESS_MASK DesiredAccess,
246 OUT PLSA_HANDLE TrustedDomainHandle)
247 {
248 NTSTATUS Status;
249
250 TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, TrustedDomainInformation,
251 DesiredAccess, TrustedDomainHandle);
252
253 RpcTryExcept
254 {
255 Status = LsarCreateTrustedDomain((LSAPR_HANDLE)PolicyHandle,
256 (PLSAPR_TRUST_INFORMATION)TrustedDomainInformation,
257 DesiredAccess,
258 (PLSAPR_HANDLE)TrustedDomainHandle);
259 }
260 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
261 {
262 Status = I_RpcMapWin32Status(RpcExceptionCode());
263 }
264 RpcEndExcept;
265
266 return Status;
267 }
268
269
270 /*
271 * @unimplemented
272 */
273 NTSTATUS
274 WINAPI
275 LsaCreateTrustedDomainEx(
276 LSA_HANDLE PolicyHandle,
277 PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
278 PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
279 ACCESS_MASK DesiredAccess,
280 PLSA_HANDLE TrustedDomainHandle)
281 {
282 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
283 DesiredAccess, TrustedDomainHandle);
284 return STATUS_SUCCESS;
285 }
286
287
288 /*
289 * @implemented
290 */
291 NTSTATUS
292 WINAPI
293 LsaDeleteTrustedDomain(IN LSA_HANDLE PolicyHandle,
294 IN PSID TrustedDomainSid)
295 {
296 NTSTATUS Status;
297
298 TRACE("(%p,%p)\n", PolicyHandle, TrustedDomainSid);
299
300 RpcTryExcept
301 {
302 Status = LsarDeleteTrustedDomain((LSAPR_HANDLE)PolicyHandle,
303 TrustedDomainSid);
304 }
305 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
306 {
307 Status = I_RpcMapWin32Status(RpcExceptionCode());
308 }
309 RpcEndExcept;
310
311 return Status;
312 }
313
314
315 /*
316 * @implemented
317 */
318 NTSTATUS
319 WINAPI
320 LsaEnumerateAccountRights(IN LSA_HANDLE PolicyHandle,
321 IN PSID AccountSid,
322 OUT PLSA_UNICODE_STRING *UserRights,
323 OUT PULONG CountOfRights)
324 {
325 LSAPR_USER_RIGHT_SET UserRightsSet;
326 NTSTATUS Status;
327
328 TRACE("(%p,%p,%p,%p) stub\n", PolicyHandle, AccountSid, UserRights, CountOfRights);
329
330 UserRightsSet.Entries = 0;
331 UserRightsSet.UserRights = NULL;
332
333 RpcTryExcept
334 {
335 Status = LsarEnmuerateAccountRights((LSAPR_HANDLE)PolicyHandle,
336 AccountSid,
337 &UserRightsSet);
338
339 *CountOfRights = UserRightsSet.Entries;
340 *UserRights = (PUNICODE_STRING)UserRightsSet.UserRights;
341 }
342 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
343 {
344 Status = I_RpcMapWin32Status(RpcExceptionCode());
345
346 if (UserRightsSet.UserRights != NULL)
347 {
348 MIDL_user_free(UserRightsSet.UserRights);
349 }
350 }
351 RpcEndExcept;
352
353 return Status;
354 }
355
356
357 /*
358 * @unimplemented
359 */
360 NTSTATUS
361 WINAPI
362 LsaEnumerateAccountsWithUserRight(
363 LSA_HANDLE PolicyHandle,
364 OPTIONAL PLSA_UNICODE_STRING UserRights,
365 PVOID *EnumerationBuffer,
366 PULONG CountReturned)
367 {
368 FIXME("(%p,%p,%p,%p) stub\n", PolicyHandle, UserRights, EnumerationBuffer, CountReturned);
369 return STATUS_NO_MORE_ENTRIES;
370 }
371
372 /*
373 * @unimplemented
374 */
375 NTSTATUS
376 WINAPI
377 LsaEnumerateTrustedDomains(
378 LSA_HANDLE PolicyHandle,
379 PLSA_ENUMERATION_HANDLE EnumerationContext,
380 PVOID *Buffer,
381 ULONG PreferedMaximumLength,
382 PULONG CountReturned)
383 {
384 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext,
385 Buffer, PreferedMaximumLength, CountReturned);
386
387 if (CountReturned) *CountReturned = 0;
388 return STATUS_SUCCESS;
389 }
390
391 /*
392 * @unimplemented
393 */
394 NTSTATUS
395 WINAPI
396 LsaEnumerateTrustedDomainsEx(
397 LSA_HANDLE PolicyHandle,
398 PLSA_ENUMERATION_HANDLE EnumerationContext,
399 PVOID *Buffer,
400 ULONG PreferedMaximumLength,
401 PULONG CountReturned)
402 {
403 FIXME("(%p,%p,%p,0x%08x,%p) stub\n", PolicyHandle, EnumerationContext, Buffer,
404 PreferedMaximumLength, CountReturned);
405 if (CountReturned) *CountReturned = 0;
406 return STATUS_SUCCESS;
407 }
408
409
410 /*
411 * @implemented
412 */
413 NTSTATUS
414 WINAPI
415 LsaFreeMemory(IN PVOID Buffer)
416 {
417 TRACE("(%p)\n", Buffer);
418 return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
419 }
420
421
422 /*
423 * @implemented
424 */
425 NTSTATUS
426 WINAPI
427 LsaLookupNames(IN LSA_HANDLE PolicyHandle,
428 IN ULONG Count,
429 IN PLSA_UNICODE_STRING Names,
430 OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
431 OUT PLSA_TRANSLATED_SID *Sids)
432 {
433 LSAPR_TRANSLATED_SIDS TranslatedSids;
434 ULONG MappedCount = 0;
435 NTSTATUS Status;
436
437 TRACE("(%p,0x%08x,%p,%p,%p)\n", PolicyHandle, Count, Names,
438 ReferencedDomains, Sids);
439
440 RpcTryExcept
441 {
442 *ReferencedDomains = NULL;
443 *Sids = NULL;
444
445 TranslatedSids.Entries = Count;
446 TranslatedSids.Sids = *Sids;
447
448 Status = LsarLookupNames((LSAPR_HANDLE)PolicyHandle,
449 Count,
450 (PRPC_UNICODE_STRING)Names,
451 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
452 &TranslatedSids,
453 LsapLookupWksta,
454 &MappedCount);
455
456 *Sids = (PLSA_TRANSLATED_SID)TranslatedSids.Sids;
457 }
458 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
459 {
460 if (TranslatedSids.Sids != NULL)
461 {
462 MIDL_user_free(TranslatedSids.Sids);
463 }
464
465 Status = I_RpcMapWin32Status(RpcExceptionCode());
466 }
467 RpcEndExcept;
468
469 return Status;
470 }
471
472
473 /*
474 * @unimplemented
475 */
476 NTSTATUS
477 WINAPI
478 LsaLookupNames2(
479 LSA_HANDLE PolicyHandle,
480 ULONG Flags,
481 ULONG Count,
482 PLSA_UNICODE_STRING Names,
483 PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
484 PLSA_TRANSLATED_SID2 *Sids)
485 {
486 FIXME("(%p,0x%08x,0x%08x,%p,%p,%p) stub\n", PolicyHandle, Flags,
487 Count, Names, ReferencedDomains, Sids);
488 if (Names != NULL && Count > 0)
489 {
490 *ReferencedDomains = RtlAllocateHeap(RtlGetProcessHeap(), 0, sizeof(LSA_REFERENCED_DOMAIN_LIST));
491 *Sids = RtlAllocateHeap(RtlGetProcessHeap(), 0, Count * sizeof(LSA_TRANSLATED_SID2));
492 return STATUS_SOME_NOT_MAPPED;
493 }
494 return STATUS_NONE_MAPPED;
495 }
496
497
498 /*
499 * @implemented
500 */
501 NTSTATUS
502 WINAPI
503 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle,
504 IN PLUID Value,
505 OUT PUNICODE_STRING *Name)
506 {
507 PRPC_UNICODE_STRING NameBuffer = NULL;
508 NTSTATUS Status;
509
510 TRACE("(%p,%p,%p)\n", PolicyHandle, Value, Name);
511
512 RpcTryExcept
513 {
514 Status = LsarLookupPrivilegeName(PolicyHandle,
515 Value,
516 &NameBuffer);
517
518 *Name = (PUNICODE_STRING)NameBuffer;
519 }
520 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
521 {
522 if (NameBuffer != NULL)
523 MIDL_user_free(NameBuffer);
524
525 Status = I_RpcMapWin32Status(RpcExceptionCode());
526 }
527 RpcEndExcept;
528
529 return Status;
530 }
531
532
533 /*
534 * @implemented
535 */
536 NTSTATUS
537 WINAPI
538 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle,
539 IN PLSA_UNICODE_STRING Name,
540 OUT PLUID Value)
541 {
542 LUID Luid;
543 NTSTATUS Status;
544
545 TRACE("(%p,%p,%p)\n", PolicyHandle, Name, Value);
546
547 RpcTryExcept
548 {
549 Status = LsarLookupPrivilegeValue(PolicyHandle,
550 (PRPC_UNICODE_STRING)Name,
551 &Luid);
552 if (Status == STATUS_SUCCESS)
553 *Value = Luid;
554 }
555 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
556 {
557 Status = I_RpcMapWin32Status(RpcExceptionCode());
558 }
559 RpcEndExcept;
560
561 return Status;
562 }
563
564
565 /*
566 * @implemented
567 */
568 NTSTATUS
569 WINAPI
570 LsaLookupSids(IN LSA_HANDLE PolicyHandle,
571 IN ULONG Count,
572 IN PSID *Sids,
573 OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
574 OUT PLSA_TRANSLATED_NAME *Names)
575 {
576 LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
577 LSAPR_TRANSLATED_NAMES TranslatedNames;
578 ULONG MappedCount = 0;
579 NTSTATUS Status;
580
581 TRACE("(%p,%u,%p,%p,%p)\n", PolicyHandle, Count, Sids,
582 ReferencedDomains, Names);
583
584 if (Count == 0)
585 return STATUS_INVALID_PARAMETER;
586
587 SidEnumBuffer.Entries = Count;
588 SidEnumBuffer.SidInfo = (PLSAPR_SID_INFORMATION)Sids;
589
590 RpcTryExcept
591 {
592 *ReferencedDomains = NULL;
593 *Names = NULL;
594
595 TranslatedNames.Entries = 0;
596 TranslatedNames.Names = NULL;
597
598 Status = LsarLookupSids((LSAPR_HANDLE)PolicyHandle,
599 &SidEnumBuffer,
600 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
601 &TranslatedNames,
602 LsapLookupWksta,
603 &MappedCount);
604
605 *Names = (PLSA_TRANSLATED_NAME)TranslatedNames.Names;
606 }
607 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
608 {
609 if (TranslatedNames.Names != NULL)
610 {
611 MIDL_user_free(TranslatedNames.Names);
612 }
613
614 Status = I_RpcMapWin32Status(RpcExceptionCode());
615 }
616 RpcEndExcept;
617
618 return Status;
619 }
620
621
622 /******************************************************************************
623 * LsaNtStatusToWinError
624 *
625 * PARAMS
626 * Status [I]
627 *
628 * @implemented
629 */
630 ULONG
631 WINAPI
632 LsaNtStatusToWinError(IN NTSTATUS Status)
633 {
634 TRACE("(%lx)\n", Status);
635 return RtlNtStatusToDosError(Status);
636 }
637
638
639 /*
640 * @implemented
641 */
642 NTSTATUS
643 WINAPI
644 LsaOpenAccount(IN LSA_HANDLE PolicyHandle,
645 IN PSID AccountSid,
646 IN ULONG Flags,
647 OUT PLSA_HANDLE AccountHandle)
648 {
649 NTSTATUS Status;
650
651 TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, AccountSid, Flags, AccountHandle);
652
653 RpcTryExcept
654 {
655 Status = LsarOpenAccount((LSAPR_HANDLE)PolicyHandle,
656 AccountSid,
657 Flags,
658 AccountHandle);
659 }
660 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
661 {
662 Status = I_RpcMapWin32Status(RpcExceptionCode());
663 }
664 RpcEndExcept;
665
666 return Status;
667 }
668
669
670 /******************************************************************************
671 * LsaOpenPolicy
672 *
673 * PARAMS
674 * x1 []
675 * x2 []
676 * x3 []
677 * x4 []
678 *
679 * @implemented
680 */
681 NTSTATUS
682 WINAPI
683 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName,
684 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
685 IN ACCESS_MASK DesiredAccess,
686 OUT PLSA_HANDLE PolicyHandle)
687 {
688 NTSTATUS Status;
689
690 TRACE("LsaOpenPolicy (%s,%p,0x%08x,%p)\n",
691 SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
692 ObjectAttributes, DesiredAccess, PolicyHandle);
693
694 /* FIXME: RPC should take care of this */
695 if (!LsapIsLocalComputer(SystemName))
696 return RPC_NT_SERVER_UNAVAILABLE;
697
698 RpcTryExcept
699 {
700 *PolicyHandle = NULL;
701
702 Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
703 (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
704 DesiredAccess,
705 PolicyHandle);
706 }
707 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
708 {
709 Status = I_RpcMapWin32Status(RpcExceptionCode());
710 }
711 RpcEndExcept;
712
713 TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
714
715 return Status;
716 }
717
718
719 /*
720 * @implemented
721 */
722 NTSTATUS
723 WINAPI
724 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle,
725 IN PLSA_UNICODE_STRING TrustedDomainName,
726 IN ACCESS_MASK DesiredAccess,
727 OUT PLSA_HANDLE TrustedDomainHandle)
728 {
729 NTSTATUS Status;
730
731 TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, TrustedDomainName,
732 DesiredAccess, TrustedDomainHandle);
733
734 RpcTryExcept
735 {
736 Status = LsarOpenTrustedDomainByName((LSAPR_HANDLE)PolicyHandle,
737 (PRPC_UNICODE_STRING)TrustedDomainName,
738 DesiredAccess,
739 TrustedDomainHandle);
740 }
741 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
742 {
743 Status = I_RpcMapWin32Status(RpcExceptionCode());
744 }
745 RpcEndExcept;
746
747 return Status;
748 }
749
750
751 /*
752 * @unimplemented
753 */
754 NTSTATUS
755 WINAPI
756 LsaQueryDomainInformationPolicy(
757 LSA_HANDLE PolicyHandle,
758 POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
759 PVOID *Buffer)
760 {
761 FIXME("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
762 return STATUS_NOT_IMPLEMENTED;
763 }
764
765 /*
766 * @unimplemented
767 */
768 NTSTATUS
769 WINAPI
770 LsaQueryForestTrustInformation(
771 LSA_HANDLE PolicyHandle,
772 PLSA_UNICODE_STRING TrustedDomainName,
773 PLSA_FOREST_TRUST_INFORMATION * ForestTrustInfo)
774 {
775 FIXME("(%p,%p,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo);
776 return STATUS_NOT_IMPLEMENTED;
777 }
778
779
780 /*
781 * @implemented
782 */
783 NTSTATUS
784 WINAPI
785 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle,
786 IN POLICY_INFORMATION_CLASS InformationClass,
787 OUT PVOID *Buffer)
788 {
789 PLSAPR_POLICY_INFORMATION PolicyInformation = NULL;
790 NTSTATUS Status;
791
792 TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
793
794 RpcTryExcept
795 {
796 Status = LsarQueryInformationPolicy((LSAPR_HANDLE)PolicyHandle,
797 InformationClass,
798 &PolicyInformation);
799 *Buffer = PolicyInformation;
800 }
801 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
802 {
803 if (PolicyInformation != NULL)
804 MIDL_user_free(PolicyInformation);
805
806 Status = I_RpcMapWin32Status(RpcExceptionCode());
807 }
808 RpcEndExcept;
809
810 TRACE("Done (Status: 0x%08x)\n", Status);
811
812 return Status;
813 }
814
815
816 /*
817 * @unimplemented
818 */
819 NTSTATUS
820 WINAPI
821 LsaQueryTrustedDomainInfo(
822 LSA_HANDLE PolicyHandle,
823 PSID TrustedDomainSid,
824 TRUSTED_INFORMATION_CLASS InformationClass,
825 PVOID *Buffer)
826 {
827 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
828 return STATUS_OBJECT_NAME_NOT_FOUND;
829 }
830
831
832 /*
833 * @implemented
834 */
835 NTSTATUS
836 WINAPI
837 LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle,
838 IN PLSA_UNICODE_STRING TrustedDomainName,
839 IN TRUSTED_INFORMATION_CLASS InformationClass,
840 OUT PVOID *Buffer)
841 {
842 NTSTATUS Status;
843
844 TRACE("(%p,%p,%d,%p)\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
845
846 if (InformationClass == TrustedDomainAuthInformationInternal ||
847 InformationClass == TrustedDomainFullInformationInternal)
848 return STATUS_INVALID_INFO_CLASS;
849
850 RpcTryExcept
851 {
852 Status = LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE)PolicyHandle,
853 (PRPC_UNICODE_STRING)TrustedDomainName,
854 InformationClass,
855 (unsigned long *)Buffer); // Shuld be: (PLSAPR_POLICY_INFORMATION *)Buffer
856 }
857 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
858 {
859 Status = I_RpcMapWin32Status(RpcExceptionCode());
860 }
861 RpcEndExcept;
862
863 return Status;
864 }
865
866
867 /*
868 * @implemented
869 */
870 NTSTATUS
871 WINAPI
872 LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle,
873 IN PSID AccountSid,
874 IN BOOLEAN AllRights,
875 IN PLSA_UNICODE_STRING UserRights,
876 IN ULONG CountOfRights)
877 {
878 LSAPR_USER_RIGHT_SET UserRightSet;
879 NTSTATUS Status;
880
881 TRACE("(%p,%p,%d,%p,0x%08x) stub\n", PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
882
883 UserRightSet.Entries = CountOfRights;
884 UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
885
886 RpcTryExcept
887 {
888 Status = LsarRemoveAccountRights((LSAPR_HANDLE)PolicyHandle,
889 (PRPC_SID)AccountSid,
890 AllRights,
891 &UserRightSet);
892 }
893 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
894 {
895 Status = I_RpcMapWin32Status(RpcExceptionCode());
896 }
897 RpcEndExcept;
898
899 return STATUS_SUCCESS;
900 }
901
902
903 /*
904 * @unimplemented
905 */
906 NTSTATUS
907 WINAPI
908 LsaRetrievePrivateData(
909 LSA_HANDLE PolicyHandle,
910 PLSA_UNICODE_STRING KeyName,
911 PLSA_UNICODE_STRING *PrivateData)
912 {
913 FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
914 return STATUS_OBJECT_NAME_NOT_FOUND;
915 }
916
917 /*
918 * @unimplemented
919 */
920 NTSTATUS
921 WINAPI
922 LsaSetDomainInformationPolicy(
923 LSA_HANDLE PolicyHandle,
924 POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
925 PVOID Buffer)
926 {
927 FIXME("(%p,0x%08x,%p) stub\n", PolicyHandle, InformationClass, Buffer);
928 return STATUS_UNSUCCESSFUL;
929 }
930
931
932 /*
933 * @implemented
934 */
935 NTSTATUS
936 WINAPI
937 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle,
938 IN POLICY_INFORMATION_CLASS InformationClass,
939 IN PVOID Buffer)
940 {
941 NTSTATUS Status;
942
943 TRACE("(%p,0x%08x,%p)\n", PolicyHandle, InformationClass, Buffer);
944
945 RpcTryExcept
946 {
947 Status = LsarSetInformationPolicy((LSAPR_HANDLE)PolicyHandle,
948 InformationClass,
949 (PLSAPR_POLICY_INFORMATION)Buffer);
950 }
951 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
952 {
953 Status = I_RpcMapWin32Status(RpcExceptionCode());
954 }
955 RpcEndExcept;
956
957 return Status;
958 }
959
960
961 /*
962 * @unimplemented
963 */
964 NTSTATUS WINAPI LsaSetSecret(
965 IN LSA_HANDLE SecretHandle,
966 IN PLSA_UNICODE_STRING EncryptedCurrentValue,
967 IN PLSA_UNICODE_STRING EncryptedOldValue)
968 {
969 FIXME("(%p,%p,%p) stub\n", SecretHandle, EncryptedCurrentValue,
970 EncryptedOldValue);
971 return STATUS_SUCCESS;
972 }
973
974 /*
975 * @unimplemented
976 */
977 NTSTATUS
978 WINAPI
979 LsaSetForestTrustInformation(
980 LSA_HANDLE PolicyHandle,
981 PLSA_UNICODE_STRING TrustedDomainName,
982 PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
983 BOOL CheckOnly,
984 PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
985 {
986 FIXME("(%p,%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
987 return STATUS_NOT_IMPLEMENTED;
988 }
989
990 /*
991 * @unimplemented
992 */
993 NTSTATUS
994 WINAPI
995 LsaSetTrustedDomainInfoByName(
996 LSA_HANDLE PolicyHandle,
997 PLSA_UNICODE_STRING TrustedDomainName,
998 TRUSTED_INFORMATION_CLASS InformationClass,
999 PVOID Buffer)
1000 {
1001 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainName, InformationClass, Buffer);
1002 return STATUS_SUCCESS;
1003 }
1004
1005 /*
1006 * @unimplemented
1007 */
1008 NTSTATUS WINAPI LsaRegisterPolicyChangeNotification(
1009 POLICY_NOTIFICATION_INFORMATION_CLASS class,
1010 HANDLE event)
1011 {
1012 FIXME("(%d,%p) stub\n", class, event);
1013 return STATUS_UNSUCCESSFUL;
1014 }
1015
1016 /*
1017 * @unimplemented
1018 */
1019 NTSTATUS
1020 WINAPI
1021 LsaSetTrustedDomainInformation(
1022 LSA_HANDLE PolicyHandle,
1023 PSID TrustedDomainSid,
1024 TRUSTED_INFORMATION_CLASS InformationClass,
1025 PVOID Buffer)
1026 {
1027 FIXME("(%p,%p,%d,%p) stub\n", PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
1028 return STATUS_SUCCESS;
1029 }
1030
1031 /*
1032 * @unimplemented
1033 */
1034 NTSTATUS
1035 WINAPI
1036 LsaStorePrivateData(
1037 LSA_HANDLE PolicyHandle,
1038 PLSA_UNICODE_STRING KeyName,
1039 PLSA_UNICODE_STRING PrivateData)
1040 {
1041 FIXME("(%p,%p,%p) stub\n", PolicyHandle, KeyName, PrivateData);
1042 return STATUS_OBJECT_NAME_NOT_FOUND;
1043 }
1044
1045 /*
1046 * @unimplemented
1047 */
1048 NTSTATUS WINAPI LsaUnregisterPolicyChangeNotification(
1049 POLICY_NOTIFICATION_INFORMATION_CLASS class,
1050 HANDLE event)
1051 {
1052 FIXME("(%d,%p) stub\n", class, event);
1053 return STATUS_SUCCESS;
1054 }
1055
1056 /*
1057 * @unimplemented
1058 */
1059 NTSTATUS
1060 WINAPI
1061 LsaGetUserName(
1062 PUNICODE_STRING *UserName,
1063 PUNICODE_STRING *DomainName)
1064 {
1065 FIXME("(%p,%p) stub\n", UserName, DomainName);
1066 return STATUS_NOT_IMPLEMENTED;
1067 }
1068
1069 /*
1070 * @unimplemented
1071 */
1072 NTSTATUS
1073 WINAPI
1074 LsaQueryInfoTrustedDomain (DWORD Unknonw0,
1075 DWORD Unknonw1,
1076 DWORD Unknonw2)
1077 {
1078 FIXME("(%d,%d,%d) stub\n", Unknonw0, Unknonw1, Unknonw2);
1079 return STATUS_NOT_IMPLEMENTED;
1080 }
1081
1082
1083 /* EOF */