projects / reactos.git / blob
? search:


218d6485d92d2a0d9e653f2b1ac4f7e6c53d9ef1
[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
14 #include <advapi32.h>
15
16 WINE_DEFAULT_DEBUG_CHANNEL(advapi);
17
18
19 static
20 BOOL
21 LsapIsLocalComputer(PLSA_UNICODE_STRING ServerName)
22 {
23 DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
24 BOOL Result;
25 LPWSTR buf;
26
27 if (ServerName == NULL || ServerName->Length == 0 || ServerName->Buffer == NULL)
28 return TRUE;
29
30 buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
31 Result = GetComputerNameW(buf, &dwSize);
32 if (Result && (ServerName->Buffer[0] == '\\') && (ServerName->Buffer[1] == '\\'))
33 ServerName += 2;
34 Result = Result && !lstrcmpW(ServerName->Buffer, buf);
35 HeapFree(GetProcessHeap(), 0, buf);
36
37 return Result;
38 }
39
40
41 handle_t
42 __RPC_USER
43 PLSAPR_SERVER_NAME_bind(PLSAPR_SERVER_NAME pszSystemName)
44 {
45 handle_t hBinding = NULL;
46 LPWSTR pszStringBinding;
47 RPC_STATUS status;
48
49 TRACE("PLSAPR_SERVER_NAME_bind() called\n");
50
51 status = RpcStringBindingComposeW(NULL,
52 L"ncacn_np",
53 pszSystemName,
54 L"\\pipe\\lsarpc",
55 NULL,
56 &pszStringBinding);
57 if (status)
58 {
59 TRACE("RpcStringBindingCompose returned 0x%x\n", status);
60 return NULL;
61 }
62
63 /* Set the binding handle that will be used to bind to the server. */
64 status = RpcBindingFromStringBindingW(pszStringBinding,
65 &hBinding);
66 if (status)
67 {
68 TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
69 }
70
71 status = RpcStringFreeW(&pszStringBinding);
72 if (status)
73 {
74 TRACE("RpcStringFree returned 0x%x\n", status);
75 }
76
77 return hBinding;
78 }
79
80
81 void
82 __RPC_USER
83 PLSAPR_SERVER_NAME_unbind(PLSAPR_SERVER_NAME pszSystemName,
84 handle_t hBinding)
85 {
86 RPC_STATUS status;
87
88 TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
89
90 status = RpcBindingFree(&hBinding);
91 if (status)
92 {
93 TRACE("RpcBindingFree returned 0x%x\n", status);
94 }
95 }
96
97
98 /*
99 * @implemented
100 */
101 NTSTATUS
102 WINAPI
103 LsaAddAccountRights(IN LSA_HANDLE PolicyHandle,
104 IN PSID AccountSid,
105 IN PLSA_UNICODE_STRING UserRights,
106 IN ULONG CountOfRights)
107 {
108 LSAPR_USER_RIGHT_SET UserRightSet;
109 NTSTATUS Status;
110
111 TRACE("LsaAddAccountRights(%p %p %p 0x%08x)\n",
112 PolicyHandle, AccountSid, UserRights, CountOfRights);
113
114 UserRightSet.Entries = CountOfRights;
115 UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
116
117 RpcTryExcept
118 {
119 Status = LsarAddAccountRights((LSAPR_HANDLE)PolicyHandle,
120 (PRPC_SID)AccountSid,
121 &UserRightSet);
122
123 }
124 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
125 {
126 Status = I_RpcMapWin32Status(RpcExceptionCode());
127 }
128 RpcEndExcept;
129
130 return Status;
131 }
132
133
134 /*
135 * @implemented
136 */
137 NTSTATUS
138 WINAPI
139 LsaAddPrivilegesToAccount(IN LSA_HANDLE AccountHandle,
140 IN PPRIVILEGE_SET PrivilegeSet)
141 {
142 NTSTATUS Status;
143
144 TRACE("LsaAddPrivilegesToAccount(%p %p)\n",
145 AccountHandle, PrivilegeSet);
146
147 RpcTryExcept
148 {
149 Status = LsarAddPrivilegesToAccount((LSAPR_HANDLE)AccountHandle,
150 (PLSAPR_PRIVILEGE_SET)PrivilegeSet);
151 }
152 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
153 {
154 Status = I_RpcMapWin32Status(RpcExceptionCode());
155 }
156 RpcEndExcept;
157
158 return Status;
159 }
160
161
162 /*
163 * @implemented
164 */
165 NTSTATUS
166 NTAPI
167 LsaClearAuditLog(IN LSA_HANDLE PolicyHandle)
168 {
169 NTSTATUS Status;
170
171 TRACE("LsaClearAuditLog(%p)\n", PolicyHandle);
172
173 RpcTryExcept
174 {
175 Status = LsarClearAuditLog((LSAPR_HANDLE)PolicyHandle);
176 }
177 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
178 {
179 Status = I_RpcMapWin32Status(RpcExceptionCode());
180 }
181 RpcEndExcept;
182
183 return Status;
184 }
185
186
187 /*
188 * @implemented
189 */
190 NTSTATUS
191 WINAPI
192 LsaClose(IN LSA_HANDLE ObjectHandle)
193 {
194 NTSTATUS Status;
195
196 TRACE("LsaClose(%p) called\n", ObjectHandle);
197
198 RpcTryExcept
199 {
200 Status = LsarClose((PLSAPR_HANDLE)&ObjectHandle);
201 }
202 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
203 {
204 Status = I_RpcMapWin32Status(RpcExceptionCode());
205 }
206 RpcEndExcept;
207
208 return Status;
209 }
210
211
212 /*
213 * @implemented
214 */
215 NTSTATUS
216 WINAPI
217 LsaCreateAccount(IN LSA_HANDLE PolicyHandle,
218 IN PSID AccountSid,
219 IN ACCESS_MASK DesiredAccess,
220 OUT PLSA_HANDLE AccountHandle)
221 {
222 NTSTATUS Status;
223
224 TRACE("LsaCreateAccount(%p %p 0x%08lx %p)\n",
225 PolicyHandle, AccountSid, DesiredAccess, AccountHandle);
226
227 RpcTryExcept
228 {
229 Status = LsarCreateAccount((LSAPR_HANDLE)PolicyHandle,
230 AccountSid,
231 DesiredAccess,
232 AccountHandle);
233 }
234 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
235 {
236 Status = I_RpcMapWin32Status(RpcExceptionCode());
237 }
238 RpcEndExcept;
239
240 return Status;
241 }
242
243
244 /*
245 * @implemented
246 */
247 NTSTATUS
248 WINAPI
249 LsaCreateSecret(IN LSA_HANDLE PolicyHandle,
250 IN PLSA_UNICODE_STRING SecretName,
251 IN ACCESS_MASK DesiredAccess,
252 OUT PLSA_HANDLE SecretHandle)
253 {
254 NTSTATUS Status;
255
256 TRACE("LsaCreateSecret(%p %p 0x%08lx %p)\n",
257 PolicyHandle, SecretName, DesiredAccess, SecretHandle);
258
259 RpcTryExcept
260 {
261 Status = LsarCreateSecret((LSAPR_HANDLE)PolicyHandle,
262 (PRPC_UNICODE_STRING)SecretName,
263 DesiredAccess,
264 SecretHandle);
265 }
266 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
267 {
268 Status = I_RpcMapWin32Status(RpcExceptionCode());
269 }
270 RpcEndExcept;
271
272 return Status;
273 }
274
275
276 /*
277 * @implemented
278 */
279 NTSTATUS
280 WINAPI
281 LsaCreateTrustedDomain(IN LSA_HANDLE PolicyHandle,
282 IN PLSA_TRUST_INFORMATION TrustedDomainInformation,
283 IN ACCESS_MASK DesiredAccess,
284 OUT PLSA_HANDLE TrustedDomainHandle)
285 {
286 NTSTATUS Status;
287
288 TRACE("LsaCreateTrustedDomain(%p %p 0x%08lx %p)\n",
289 PolicyHandle, TrustedDomainInformation, DesiredAccess, TrustedDomainHandle);
290
291 RpcTryExcept
292 {
293 Status = LsarCreateTrustedDomain((LSAPR_HANDLE)PolicyHandle,
294 (PLSAPR_TRUST_INFORMATION)TrustedDomainInformation,
295 DesiredAccess,
296 (PLSAPR_HANDLE)TrustedDomainHandle);
297 }
298 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
299 {
300 Status = I_RpcMapWin32Status(RpcExceptionCode());
301 }
302 RpcEndExcept;
303
304 return Status;
305 }
306
307
308 /*
309 * @unimplemented
310 */
311 NTSTATUS
312 WINAPI
313 LsaCreateTrustedDomainEx(IN LSA_HANDLE PolicyHandle,
314 IN PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation,
315 IN PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation,
316 IN ACCESS_MASK DesiredAccess,
317 OUT PLSA_HANDLE TrustedDomainHandle)
318 {
319 FIXME("LsaCreateTrustedDomainEx(%p %p %p 0x%08lx %p) stub\n",
320 PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
321 DesiredAccess, TrustedDomainHandle);
322 return STATUS_SUCCESS;
323 }
324
325
326 /*
327 * @implemented
328 */
329 NTSTATUS
330 WINAPI
331 LsaDelete(IN LSA_HANDLE ObjectHandle)
332 {
333 NTSTATUS Status;
334
335 TRACE("LsaDelete(%p)\n", ObjectHandle);
336
337 RpcTryExcept
338 {
339 Status = LsarDelete((LSAPR_HANDLE)ObjectHandle);
340 }
341 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
342 {
343 Status = I_RpcMapWin32Status(RpcExceptionCode());
344 }
345 RpcEndExcept;
346
347 return Status;
348 }
349
350
351 /*
352 * @implemented
353 */
354 NTSTATUS
355 WINAPI
356 LsaDeleteTrustedDomain(IN LSA_HANDLE PolicyHandle,
357 IN PSID TrustedDomainSid)
358 {
359 NTSTATUS Status;
360
361 TRACE("LsaDeleteTrustedDomain(%p %p)\n",
362 PolicyHandle, TrustedDomainSid);
363
364 RpcTryExcept
365 {
366 Status = LsarDeleteTrustedDomain((LSAPR_HANDLE)PolicyHandle,
367 TrustedDomainSid);
368 }
369 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
370 {
371 Status = I_RpcMapWin32Status(RpcExceptionCode());
372 }
373 RpcEndExcept;
374
375 return Status;
376 }
377
378
379 /*
380 * @implemented
381 */
382 NTSTATUS
383 WINAPI
384 LsaEnumerateAccountRights(IN LSA_HANDLE PolicyHandle,
385 IN PSID AccountSid,
386 OUT PLSA_UNICODE_STRING *UserRights,
387 OUT PULONG CountOfRights)
388 {
389 LSAPR_USER_RIGHT_SET UserRightsSet;
390 NTSTATUS Status;
391
392 TRACE("LsaEnumerateAccountRights(%p %p %p %p)\n",
393 PolicyHandle, AccountSid, UserRights, CountOfRights);
394
395 UserRightsSet.Entries = 0;
396 UserRightsSet.UserRights = NULL;
397
398 RpcTryExcept
399 {
400 Status = LsarEnmuerateAccountRights((LSAPR_HANDLE)PolicyHandle,
401 AccountSid,
402 &UserRightsSet);
403
404 *CountOfRights = UserRightsSet.Entries;
405 *UserRights = (PUNICODE_STRING)UserRightsSet.UserRights;
406 }
407 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
408 {
409 Status = I_RpcMapWin32Status(RpcExceptionCode());
410
411 if (UserRightsSet.UserRights != NULL)
412 {
413 MIDL_user_free(UserRightsSet.UserRights);
414 }
415 }
416 RpcEndExcept;
417
418 return Status;
419 }
420
421
422 /*
423 * @unimplemented
424 */
425 NTSTATUS
426 WINAPI
427 LsaEnumerateAccountsWithUserRight(IN LSA_HANDLE PolicyHandle,
428 IN PLSA_UNICODE_STRING UserRight OPTIONAL,
429 OUT PVOID *Buffer,
430 OUT PULONG CountReturned)
431 {
432 FIXME("LsaEnumerateAccountsWithUserRight(%p %p %p %p) stub\n",
433 PolicyHandle, UserRight, Buffer, CountReturned);
434 return STATUS_NO_MORE_ENTRIES;
435 }
436
437
438 /*
439 * @implemented
440 */
441 NTSTATUS
442 WINAPI
443 LsaEnumeratePrivilegesOfAccount(IN LSA_HANDLE AccountHandle,
444 OUT PPRIVILEGE_SET *Privileges)
445 {
446 NTSTATUS Status;
447
448 TRACE("LsaEnumeratePrivilegesOfAccount(%p %p)\n",
449 AccountHandle, Privileges);
450
451 RpcTryExcept
452 {
453 Status = LsarEnumeratePrivilegesAccount((LSAPR_HANDLE)AccountHandle,
454 (LSAPR_PRIVILEGE_SET **)Privileges);
455 }
456 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
457 {
458 Status = I_RpcMapWin32Status(RpcExceptionCode());
459 }
460 RpcEndExcept;
461
462 return Status;
463 }
464
465
466 /*
467 * @unimplemented
468 */
469 NTSTATUS
470 WINAPI
471 LsaEnumerateTrustedDomains(IN LSA_HANDLE PolicyHandle,
472 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext,
473 OUT PVOID *Buffer,
474 IN ULONG PreferedMaximumLength,
475 OUT PULONG CountReturned)
476 {
477 FIXME("LsaEnumerateTrustedDomains(%p %p %p %lu %p) stub\n",
478 PolicyHandle, EnumerationContext, Buffer,
479 PreferedMaximumLength, CountReturned);
480
481 if (CountReturned) *CountReturned = 0;
482 return STATUS_SUCCESS;
483 }
484
485 /*
486 * @unimplemented
487 */
488 NTSTATUS
489 WINAPI
490 LsaEnumerateTrustedDomainsEx(IN LSA_HANDLE PolicyHandle,
491 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext,
492 OUT PVOID *Buffer,
493 IN ULONG PreferedMaximumLength,
494 OUT PULONG CountReturned)
495 {
496 FIXME("LsaEnumerateTrustedDomainsEx(%p %p %p %lu %p) stub\n",
497 PolicyHandle, EnumerationContext, Buffer,
498 PreferedMaximumLength, CountReturned);
499
500 if (CountReturned) *CountReturned = 0;
501 return STATUS_SUCCESS;
502 }
503
504
505 /*
506 * @implemented
507 */
508 NTSTATUS
509 WINAPI
510 LsaFreeMemory(IN PVOID Buffer)
511 {
512 TRACE("LsaFreeMemory(%p)\n", Buffer);
513 return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
514 }
515
516
517 /*
518 * @implemented
519 */
520 NTSTATUS
521 WINAPI
522 LsaGetSystemAccessAccount(IN LSA_HANDLE AccountHandle,
523 OUT PULONG SystemAccess)
524 {
525 NTSTATUS Status;
526
527 TRACE("LsaGetSystemAccessAccount(%p %p)\n",
528 AccountHandle, SystemAccess);
529
530 RpcTryExcept
531 {
532 Status = LsarGetSystemAccessAccount((LSAPR_HANDLE)AccountHandle,
533 (ACCESS_MASK *)SystemAccess);
534 }
535 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
536 {
537 Status = I_RpcMapWin32Status(RpcExceptionCode());
538 }
539 RpcEndExcept;
540
541 return Status;
542 }
543
544
545 /*
546 * @unimplemented
547 */
548 NTSTATUS
549 WINAPI
550 LsaGetUserName(PUNICODE_STRING *UserName,
551 PUNICODE_STRING *DomainName)
552 {
553 FIXME("LsaGetUserName(%p %p) stub\n",
554 UserName, DomainName);
555 return STATUS_NOT_IMPLEMENTED;
556 }
557
558
559 /*
560 * @implemented
561 */
562 NTSTATUS
563 WINAPI
564 LsaLookupNames(IN LSA_HANDLE PolicyHandle,
565 IN ULONG Count,
566 IN PLSA_UNICODE_STRING Names,
567 OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
568 OUT PLSA_TRANSLATED_SID *Sids)
569 {
570 LSAPR_TRANSLATED_SIDS TranslatedSids = {0, NULL};
571 ULONG MappedCount = 0;
572 NTSTATUS Status;
573
574 TRACE("LsaLookupNames(%p %lu %p %p %p)\n",
575 PolicyHandle, Count, Names, ReferencedDomains, Sids);
576
577 if (ReferencedDomains == NULL || Sids == NULL)
578 return STATUS_INVALID_PARAMETER;
579
580 RpcTryExcept
581 {
582 *ReferencedDomains = NULL;
583 *Sids = NULL;
584
585 TranslatedSids.Entries = Count;
586
587 Status = LsarLookupNames((LSAPR_HANDLE)PolicyHandle,
588 Count,
589 (PRPC_UNICODE_STRING)Names,
590 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
591 &TranslatedSids,
592 LsapLookupWksta,
593 &MappedCount);
594
595 *Sids = (PLSA_TRANSLATED_SID)TranslatedSids.Sids;
596 }
597 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
598 {
599 if (TranslatedSids.Sids != NULL)
600 MIDL_user_free(TranslatedSids.Sids);
601
602 Status = I_RpcMapWin32Status(RpcExceptionCode());
603 }
604 RpcEndExcept;
605
606 return Status;
607 }
608
609
610 /*
611 * @implemented
612 */
613 NTSTATUS
614 WINAPI
615 LsaLookupNames2(IN LSA_HANDLE PolicyHandle,
616 IN ULONG Flags,
617 IN ULONG Count,
618 IN PLSA_UNICODE_STRING Names,
619 OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
620 OUT PLSA_TRANSLATED_SID2 *Sids)
621 {
622 LSAPR_TRANSLATED_SIDS_EX2 TranslatedSids = {0, NULL};
623 ULONG MappedCount = 0;
624 NTSTATUS Status;
625
626 TRACE("LsaLookupNames2(%p 0x%08x %lu %p %p %p)\n",
627 PolicyHandle, Flags, Count, Names, ReferencedDomains, Sids);
628
629 if (ReferencedDomains == NULL || Sids == NULL)
630 return STATUS_INVALID_PARAMETER;
631
632 RpcTryExcept
633 {
634 *ReferencedDomains = NULL;
635 *Sids = NULL;
636
637 TranslatedSids.Entries = Count;
638
639 Status = LsarLookupNames3((LSAPR_HANDLE)PolicyHandle,
640 Count,
641 (PRPC_UNICODE_STRING)Names,
642 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
643 &TranslatedSids,
644 LsapLookupWksta,
645 &MappedCount,
646 Flags,
647 2);
648
649 *Sids = (PLSA_TRANSLATED_SID2)TranslatedSids.Sids;
650 }
651 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
652 {
653 if (TranslatedSids.Sids != NULL)
654 MIDL_user_free(TranslatedSids.Sids);
655
656 Status = I_RpcMapWin32Status(RpcExceptionCode());
657 }
658 RpcEndExcept;
659
660 return Status;
661 }
662
663
664 /*
665 * @implemented
666 */
667 NTSTATUS
668 WINAPI
669 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle,
670 IN PLUID Value,
671 OUT PUNICODE_STRING *Name)
672 {
673 PRPC_UNICODE_STRING NameBuffer = NULL;
674 NTSTATUS Status;
675
676 TRACE("LsaLookupPrivilegeName(%p %p %p)\n",
677 PolicyHandle, Value, Name);
678
679 RpcTryExcept
680 {
681 Status = LsarLookupPrivilegeName(PolicyHandle,
682 Value,
683 &NameBuffer);
684
685 *Name = (PUNICODE_STRING)NameBuffer;
686 }
687 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
688 {
689 if (NameBuffer != NULL)
690 MIDL_user_free(NameBuffer);
691
692 Status = I_RpcMapWin32Status(RpcExceptionCode());
693 }
694 RpcEndExcept;
695
696 return Status;
697 }
698
699
700 /*
701 * @implemented
702 */
703 NTSTATUS
704 WINAPI
705 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle,
706 IN PLSA_UNICODE_STRING Name,
707 OUT PLUID Value)
708 {
709 LUID Luid;
710 NTSTATUS Status;
711
712 TRACE("LsaLookupPrivilegeValue(%p %p %p)\n",
713 PolicyHandle, Name, Value);
714
715 RpcTryExcept
716 {
717 Status = LsarLookupPrivilegeValue(PolicyHandle,
718 (PRPC_UNICODE_STRING)Name,
719 &Luid);
720 if (Status == STATUS_SUCCESS)
721 *Value = Luid;
722 }
723 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
724 {
725 Status = I_RpcMapWin32Status(RpcExceptionCode());
726 }
727 RpcEndExcept;
728
729 return Status;
730 }
731
732
733 /*
734 * @implemented
735 */
736 NTSTATUS
737 WINAPI
738 LsaLookupSids(IN LSA_HANDLE PolicyHandle,
739 IN ULONG Count,
740 IN PSID *Sids,
741 OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
742 OUT PLSA_TRANSLATED_NAME *Names)
743 {
744 LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
745 LSAPR_TRANSLATED_NAMES TranslatedNames;
746 ULONG MappedCount = 0;
747 NTSTATUS Status;
748
749 TRACE("LsaLookupSids(%p %lu %p %p %p)\n",
750 PolicyHandle, Count, Sids, ReferencedDomains, Names);
751
752 if (Count == 0)
753 return STATUS_INVALID_PARAMETER;
754
755 SidEnumBuffer.Entries = Count;
756 SidEnumBuffer.SidInfo = (PLSAPR_SID_INFORMATION)Sids;
757
758 RpcTryExcept
759 {
760 *ReferencedDomains = NULL;
761 *Names = NULL;
762
763 TranslatedNames.Entries = 0;
764 TranslatedNames.Names = NULL;
765
766 Status = LsarLookupSids((LSAPR_HANDLE)PolicyHandle,
767 &SidEnumBuffer,
768 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
769 &TranslatedNames,
770 LsapLookupWksta,
771 &MappedCount);
772
773 *Names = (PLSA_TRANSLATED_NAME)TranslatedNames.Names;
774 }
775 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
776 {
777 if (TranslatedNames.Names != NULL)
778 {
779 MIDL_user_free(TranslatedNames.Names);
780 }
781
782 Status = I_RpcMapWin32Status(RpcExceptionCode());
783 }
784 RpcEndExcept;
785
786 return Status;
787 }
788
789
790 /******************************************************************************
791 * LsaNtStatusToWinError
792 *
793 * PARAMS
794 * Status [I]
795 *
796 * @implemented
797 */
798 ULONG
799 WINAPI
800 LsaNtStatusToWinError(IN NTSTATUS Status)
801 {
802 TRACE("LsaNtStatusToWinError(0x%lx)\n", Status);
803 return RtlNtStatusToDosError(Status);
804 }
805
806
807 /*
808 * @implemented
809 */
810 NTSTATUS
811 WINAPI
812 LsaOpenAccount(IN LSA_HANDLE PolicyHandle,
813 IN PSID AccountSid,
814 IN ACCESS_MASK DesiredAccess,
815 OUT PLSA_HANDLE AccountHandle)
816 {
817 NTSTATUS Status;
818
819 TRACE("LsaOpenAccount(%p %p 0x%08lx %p)\n",
820 PolicyHandle, AccountSid, DesiredAccess, AccountHandle);
821
822 RpcTryExcept
823 {
824 Status = LsarOpenAccount((LSAPR_HANDLE)PolicyHandle,
825 AccountSid,
826 DesiredAccess,
827 AccountHandle);
828 }
829 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
830 {
831 Status = I_RpcMapWin32Status(RpcExceptionCode());
832 }
833 RpcEndExcept;
834
835 return Status;
836 }
837
838
839 /******************************************************************************
840 * LsaOpenPolicy
841 *
842 * PARAMS
843 * x1 []
844 * x2 []
845 * x3 []
846 * x4 []
847 *
848 * @implemented
849 */
850 NTSTATUS
851 WINAPI
852 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName OPTIONAL,
853 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes,
854 IN ACCESS_MASK DesiredAccess,
855 OUT PLSA_HANDLE PolicyHandle)
856 {
857 NTSTATUS Status;
858
859 TRACE("LsaOpenPolicy(%s %p 0x%08lx %p)\n",
860 SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
861 ObjectAttributes, DesiredAccess, PolicyHandle);
862
863 /* FIXME: RPC should take care of this */
864 if (!LsapIsLocalComputer(SystemName))
865 return RPC_NT_SERVER_UNAVAILABLE;
866
867 RpcTryExcept
868 {
869 *PolicyHandle = NULL;
870
871 Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
872 (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
873 DesiredAccess,
874 PolicyHandle);
875 }
876 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
877 {
878 Status = I_RpcMapWin32Status(RpcExceptionCode());
879 }
880 RpcEndExcept;
881
882 TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
883
884 return Status;
885 }
886
887
888 NTSTATUS
889 WINAPI
890 LsaOpenSecret(IN LSA_HANDLE PolicyHandle,
891 IN PLSA_UNICODE_STRING SecretName,
892 IN ACCESS_MASK DesiredAccess,
893 OUT PLSA_HANDLE SecretHandle)
894 {
895 NTSTATUS Status;
896
897 TRACE("LsaOpenSecret(%p %p 0x%08lx %p)\n",
898 PolicyHandle, SecretName, DesiredAccess, SecretHandle);
899
900 RpcTryExcept
901 {
902 *SecretHandle = NULL;
903
904 Status = LsarOpenSecret((LSAPR_HANDLE)PolicyHandle,
905 (PRPC_UNICODE_STRING)SecretName,
906 DesiredAccess,
907 SecretHandle);
908 }
909 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
910 {
911 Status = I_RpcMapWin32Status(RpcExceptionCode());
912 }
913 RpcEndExcept;
914
915 TRACE("LsaOpenSecret() done (Status: 0x%08lx)\n", Status);
916
917 return Status;
918 }
919
920
921 /*
922 * @implemented
923 */
924 NTSTATUS
925 WINAPI
926 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle,
927 IN PLSA_UNICODE_STRING TrustedDomainName,
928 IN ACCESS_MASK DesiredAccess,
929 OUT PLSA_HANDLE TrustedDomainHandle)
930 {
931 NTSTATUS Status;
932
933 TRACE("LsaOpenTrustedDomainByName(%p %p 0x%08lx %p)\n",
934 PolicyHandle, TrustedDomainName, DesiredAccess, TrustedDomainHandle);
935
936 RpcTryExcept
937 {
938 Status = LsarOpenTrustedDomainByName((LSAPR_HANDLE)PolicyHandle,
939 (PRPC_UNICODE_STRING)TrustedDomainName,
940 DesiredAccess,
941 TrustedDomainHandle);
942 }
943 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
944 {
945 Status = I_RpcMapWin32Status(RpcExceptionCode());
946 }
947 RpcEndExcept;
948
949 return Status;
950 }
951
952
953 /*
954 * @unimplemented
955 */
956 NTSTATUS
957 WINAPI
958 LsaQueryDomainInformationPolicy(IN LSA_HANDLE PolicyHandle,
959 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
960 OUT PVOID *Buffer)
961 {
962 FIXME("LsaQueryDomainInformationPolicy(%p %lu %p) stub\n",
963 PolicyHandle, InformationClass, Buffer);
964 return STATUS_NOT_IMPLEMENTED;
965 }
966
967
968 /*
969 * @unimplemented
970 */
971 NTSTATUS
972 WINAPI
973 LsaQueryForestTrustInformation(IN LSA_HANDLE PolicyHandle,
974 IN PLSA_UNICODE_STRING TrustedDomainName,
975 OUT PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
976 {
977 FIXME("LsaQueryForestTrustInformation(%p %p %p) stub\n",
978 PolicyHandle, TrustedDomainName, ForestTrustInfo);
979 return STATUS_NOT_IMPLEMENTED;
980 }
981
982
983 /*
984 * @unimplemented
985 */
986 NTSTATUS
987 WINAPI
988 LsaQueryInfoTrustedDomain(IN LSA_HANDLE TrustedDomainHandle,
989 IN TRUSTED_INFORMATION_CLASS InformationClass,
990 OUT PVOID *Buffer)
991 {
992 FIXME("LsaQueryInfoTrustedDomain(%p %d %p) stub\n",
993 TrustedDomainHandle, InformationClass, Buffer);
994 return STATUS_NOT_IMPLEMENTED;
995 }
996
997
998 /*
999 * @implemented
1000 */
1001 NTSTATUS
1002 WINAPI
1003 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle,
1004 IN POLICY_INFORMATION_CLASS InformationClass,
1005 OUT PVOID *Buffer)
1006 {
1007 PLSAPR_POLICY_INFORMATION PolicyInformation = NULL;
1008 NTSTATUS Status;
1009
1010 TRACE("LsaQueryInformationPolicy(%p %d %p)\n",
1011 PolicyHandle, InformationClass, Buffer);
1012
1013 RpcTryExcept
1014 {
1015 Status = LsarQueryInformationPolicy((LSAPR_HANDLE)PolicyHandle,
1016 InformationClass,
1017 &PolicyInformation);
1018 *Buffer = PolicyInformation;
1019 }
1020 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1021 {
1022 if (PolicyInformation != NULL)
1023 MIDL_user_free(PolicyInformation);
1024
1025 Status = I_RpcMapWin32Status(RpcExceptionCode());
1026 }
1027 RpcEndExcept;
1028
1029 TRACE("Done (Status: 0x%08x)\n", Status);
1030
1031 return Status;
1032 }
1033
1034
1035 /*
1036 * @unimplemented
1037 */
1038 NTSTATUS
1039 WINAPI
1040 LsaQuerySecret(IN LSA_HANDLE SecretHandle,
1041 OUT PLSA_UNICODE_STRING *CurrentValue OPTIONAL,
1042 OUT PLARGE_INTEGER CurrentValueSetTime OPTIONAL,
1043 OUT PLSA_UNICODE_STRING *OldValue OPTIONAL,
1044 OUT PLARGE_INTEGER OldValueSetTime OPTIONAL)
1045 {
1046 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue = NULL;
1047 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue = NULL;
1048 PLSA_UNICODE_STRING DecryptedCurrentValue = NULL;
1049 PLSA_UNICODE_STRING DecryptedOldValue = NULL;
1050 SIZE_T BufferSize;
1051 NTSTATUS Status;
1052
1053 TRACE("LsaQuerySecret(%p %p %p %p %p)\n",
1054 SecretHandle, CurrentValue, CurrentValueSetTime,
1055 OldValue, OldValueSetTime);
1056
1057 RpcTryExcept
1058 {
1059 Status = LsarQuerySecret((PLSAPR_HANDLE)SecretHandle,
1060 &EncryptedCurrentValue,
1061 CurrentValueSetTime,
1062 &EncryptedOldValue,
1063 OldValueSetTime);
1064 }
1065 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1066 {
1067 Status = I_RpcMapWin32Status(RpcExceptionCode());
1068 }
1069 RpcEndExcept;
1070
1071 if (!NT_SUCCESS(Status))
1072 goto done;
1073
1074 /* Decrypt the current value */
1075 if (CurrentValue != NULL)
1076 {
1077 if (EncryptedCurrentValue == NULL)
1078 {
1079 *CurrentValue = NULL;
1080 }
1081 else
1082 {
1083 /* FIXME: Decrypt the current value */
1084 BufferSize = sizeof(LSA_UNICODE_STRING) + EncryptedCurrentValue->MaximumLength;
1085 DecryptedCurrentValue = midl_user_allocate(BufferSize);
1086 if (DecryptedCurrentValue == NULL)
1087 {
1088 Status = STATUS_INSUFFICIENT_RESOURCES;
1089 goto done;
1090 }
1091
1092 DecryptedCurrentValue->Length = (USHORT)EncryptedCurrentValue->Length;
1093 DecryptedCurrentValue->MaximumLength = (USHORT)EncryptedCurrentValue->MaximumLength;
1094 DecryptedCurrentValue->Buffer = (PWSTR)(DecryptedCurrentValue + 1);
1095 RtlCopyMemory(DecryptedCurrentValue->Buffer,
1096 EncryptedCurrentValue->Buffer,
1097 EncryptedCurrentValue->Length);
1098
1099 *CurrentValue = DecryptedCurrentValue;
1100 }
1101 }
1102
1103 /* Decrypt the old value */
1104 if (OldValue != NULL)
1105 {
1106 if (EncryptedOldValue == NULL)
1107 {
1108 *OldValue = NULL;
1109 }
1110 else
1111 {
1112 /* FIXME: Decrypt the old value */
1113 BufferSize = sizeof(LSA_UNICODE_STRING) + EncryptedOldValue->MaximumLength;
1114 DecryptedOldValue = midl_user_allocate(BufferSize);
1115 if (DecryptedOldValue == NULL)
1116 {
1117 Status = STATUS_INSUFFICIENT_RESOURCES;
1118 goto done;
1119 }
1120
1121 DecryptedOldValue->Length = (USHORT)EncryptedOldValue->Length;
1122 DecryptedOldValue->MaximumLength = (USHORT)EncryptedOldValue->MaximumLength;
1123 DecryptedOldValue->Buffer = (PWSTR)(DecryptedOldValue + 1);
1124 RtlCopyMemory(DecryptedOldValue->Buffer,
1125 EncryptedOldValue->Buffer,
1126 EncryptedOldValue->Length);
1127
1128 *OldValue = DecryptedOldValue;
1129 }
1130 }
1131
1132 done:
1133 if (!NT_SUCCESS(Status))
1134 {
1135 if (DecryptedCurrentValue != NULL)
1136 midl_user_free(DecryptedCurrentValue);
1137
1138 if (DecryptedOldValue != NULL)
1139 midl_user_free(DecryptedOldValue);
1140
1141 if (CurrentValue != NULL)
1142 *CurrentValue = NULL;
1143
1144 if (OldValue != NULL)
1145 *OldValue = NULL;
1146 }
1147
1148 if (EncryptedCurrentValue != NULL)
1149 midl_user_free(EncryptedCurrentValue);
1150
1151 if (EncryptedOldValue != NULL)
1152 midl_user_free(EncryptedOldValue);
1153
1154 return Status;
1155 }
1156
1157
1158 /*
1159 * @unimplemented
1160 */
1161 NTSTATUS
1162 WINAPI
1163 LsaQueryTrustedDomainInfo(IN LSA_HANDLE PolicyHandle,
1164 IN PSID TrustedDomainSid,
1165 IN TRUSTED_INFORMATION_CLASS InformationClass,
1166 OUT PVOID *Buffer)
1167 {
1168 FIXME("LsaQueryTrustedDomainInfo(%p %p %d %p) stub\n",
1169 PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
1170 return STATUS_OBJECT_NAME_NOT_FOUND;
1171 }
1172
1173
1174 /*
1175 * @implemented
1176 */
1177 NTSTATUS
1178 WINAPI
1179 LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle,
1180 IN PLSA_UNICODE_STRING TrustedDomainName,
1181 IN TRUSTED_INFORMATION_CLASS InformationClass,
1182 OUT PVOID *Buffer)
1183 {
1184 NTSTATUS Status;
1185
1186 TRACE("LsaQueryTrustedDomainInfoByName(%p %p %d %p)\n",
1187 PolicyHandle, TrustedDomainName, InformationClass, Buffer);
1188
1189 if (InformationClass == TrustedDomainAuthInformationInternal ||
1190 InformationClass == TrustedDomainFullInformationInternal)
1191 return STATUS_INVALID_INFO_CLASS;
1192
1193 RpcTryExcept
1194 {
1195 Status = LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE)PolicyHandle,
1196 (PRPC_UNICODE_STRING)TrustedDomainName,
1197 InformationClass,
1198 (unsigned long *)Buffer); // Shuld be: (PLSAPR_POLICY_INFORMATION *)Buffer
1199 }
1200 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1201 {
1202 Status = I_RpcMapWin32Status(RpcExceptionCode());
1203 }
1204 RpcEndExcept;
1205
1206 return Status;
1207 }
1208
1209
1210 /*
1211 * @unimplemented
1212 */
1213 NTSTATUS
1214 WINAPI
1215 LsaRegisterPolicyChangeNotification(IN POLICY_NOTIFICATION_INFORMATION_CLASS InformationClass,
1216 IN HANDLE NotificationEventHandle)
1217 {
1218 FIXME("LsaRegisterPolicyChangeNotification(%d %p) stub\n",
1219 InformationClass, NotificationEventHandle);
1220 return STATUS_UNSUCCESSFUL;
1221 }
1222
1223
1224 /*
1225 * @implemented
1226 */
1227 NTSTATUS
1228 WINAPI
1229 LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle,
1230 IN PSID AccountSid,
1231 IN BOOLEAN AllRights,
1232 IN PLSA_UNICODE_STRING UserRights,
1233 IN ULONG CountOfRights)
1234 {
1235 LSAPR_USER_RIGHT_SET UserRightSet;
1236
1237 TRACE("LsaRemoveAccountRights(%p %p %d %p %lu)\n",
1238 PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
1239
1240 UserRightSet.Entries = CountOfRights;
1241 UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
1242
1243 RpcTryExcept
1244 {
1245 LsarRemoveAccountRights((LSAPR_HANDLE)PolicyHandle,
1246 (PRPC_SID)AccountSid,
1247 AllRights,
1248 &UserRightSet);
1249 }
1250 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1251 {
1252 I_RpcMapWin32Status(RpcExceptionCode());
1253 }
1254 RpcEndExcept;
1255
1256 return STATUS_SUCCESS;
1257 }
1258
1259
1260 /*
1261 * @unimplemented
1262 */
1263 NTSTATUS
1264 WINAPI
1265 LsaRetrievePrivateData(IN LSA_HANDLE PolicyHandle,
1266 IN PLSA_UNICODE_STRING KeyName,
1267 OUT PLSA_UNICODE_STRING *PrivateData)
1268 {
1269 FIXME("LsaRetrievePrivateData(%p %p %p) stub\n",
1270 PolicyHandle, KeyName, PrivateData);
1271 return STATUS_OBJECT_NAME_NOT_FOUND;
1272 }
1273
1274
1275 /*
1276 * @unimplemented
1277 */
1278 NTSTATUS
1279 WINAPI
1280 LsaSetDomainInformationPolicy(IN LSA_HANDLE PolicyHandle,
1281 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass,
1282 IN PVOID Buffer OPTIONAL)
1283 {
1284 FIXME("LsaSetDomainInformationPolicy(%p %d %p) stub\n",
1285 PolicyHandle, InformationClass, Buffer);
1286 return STATUS_UNSUCCESSFUL;
1287 }
1288
1289
1290 /*
1291 * @unimplemented
1292 */
1293 NTSTATUS
1294 WINAPI
1295 LsaSetForestTrustInformation(IN LSA_HANDLE PolicyHandle,
1296 IN PLSA_UNICODE_STRING TrustedDomainName,
1297 IN PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo,
1298 IN BOOL CheckOnly,
1299 OUT PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
1300 {
1301 FIXME("LsaSetForestTrustInformation(%p %p %p %d %p) stub\n",
1302 PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
1303 return STATUS_NOT_IMPLEMENTED;
1304 }
1305
1306
1307 /*
1308 * @implemented
1309 */
1310 NTSTATUS
1311 WINAPI
1312 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle,
1313 IN POLICY_INFORMATION_CLASS InformationClass,
1314 IN PVOID Buffer)
1315 {
1316 NTSTATUS Status;
1317
1318 TRACE("LsaSetInformationPolicy(%p %d %p)\n",
1319 PolicyHandle, InformationClass, Buffer);
1320
1321 RpcTryExcept
1322 {
1323 Status = LsarSetInformationPolicy((LSAPR_HANDLE)PolicyHandle,
1324 InformationClass,
1325 (PLSAPR_POLICY_INFORMATION)Buffer);
1326 }
1327 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1328 {
1329 Status = I_RpcMapWin32Status(RpcExceptionCode());
1330 }
1331 RpcEndExcept;
1332
1333 return Status;
1334 }
1335
1336
1337 /*
1338 * @implemented
1339 */
1340 NTSTATUS
1341 WINAPI
1342 LsaSetSecret(IN LSA_HANDLE SecretHandle,
1343 IN PLSA_UNICODE_STRING CurrentValue OPTIONAL,
1344 IN PLSA_UNICODE_STRING OldValue OPTIONAL)
1345 {
1346 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue = NULL;
1347 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue = NULL;
1348 SIZE_T BufferSize;
1349 NTSTATUS Status;
1350
1351 TRACE("LsaSetSecret(%p %p %p)\n",
1352 SecretHandle, EncryptedCurrentValue, EncryptedOldValue);
1353
1354 if (CurrentValue != NULL)
1355 {
1356 BufferSize = sizeof(LSAPR_CR_CIPHER_VALUE) + CurrentValue->MaximumLength;
1357 EncryptedCurrentValue = midl_user_allocate(BufferSize);
1358 if (EncryptedCurrentValue == NULL)
1359 {
1360 Status = STATUS_INSUFFICIENT_RESOURCES;
1361 goto done;
1362 }
1363
1364 EncryptedCurrentValue->Length = CurrentValue->Length;
1365 EncryptedCurrentValue->MaximumLength = CurrentValue->MaximumLength;
1366 EncryptedCurrentValue->Buffer = (BYTE *)(EncryptedCurrentValue + 1);
1367 if (EncryptedCurrentValue->Buffer != NULL)
1368 memcpy(EncryptedCurrentValue->Buffer, CurrentValue->Buffer, CurrentValue->Length);
1369 }
1370
1371 if (OldValue != NULL)
1372 {
1373 BufferSize = sizeof(LSAPR_CR_CIPHER_VALUE) + OldValue->MaximumLength;
1374 EncryptedOldValue = midl_user_allocate(BufferSize);
1375 if (EncryptedOldValue == NULL)
1376 {
1377 Status = STATUS_INSUFFICIENT_RESOURCES;
1378 goto done;
1379 }
1380
1381 EncryptedOldValue->Length = OldValue->Length;
1382 EncryptedOldValue->MaximumLength = OldValue->MaximumLength;
1383 EncryptedOldValue->Buffer = (BYTE*)(EncryptedOldValue + 1);
1384 if (EncryptedOldValue->Buffer != NULL)
1385 memcpy(EncryptedOldValue->Buffer, OldValue->Buffer, OldValue->Length);
1386 }
1387
1388 RpcTryExcept
1389 {
1390 Status = LsarSetSecret((LSAPR_HANDLE)SecretHandle,
1391 EncryptedCurrentValue,
1392 EncryptedOldValue);
1393 }
1394 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1395 {
1396 Status = I_RpcMapWin32Status(RpcExceptionCode());
1397 }
1398 RpcEndExcept;
1399
1400 done:
1401 if (EncryptedCurrentValue != NULL)
1402 midl_user_free(EncryptedCurrentValue);
1403
1404 if (EncryptedOldValue != NULL)
1405 midl_user_free(EncryptedOldValue);
1406
1407 return Status;
1408 }
1409
1410
1411 /*
1412 * @implemented
1413 */
1414 NTSTATUS
1415 WINAPI
1416 LsaSetSystemAccessAccount(IN LSA_HANDLE AccountHandle,
1417 IN ULONG SystemAccess)
1418 {
1419 NTSTATUS Status;
1420
1421 TRACE("LsaSetSystemAccessAccount(%p 0x%lx)\n",
1422 AccountHandle, SystemAccess);
1423
1424 RpcTryExcept
1425 {
1426 Status = LsarSetSystemAccessAccount((LSAPR_HANDLE)AccountHandle,
1427 SystemAccess);
1428 }
1429 RpcExcept(EXCEPTION_EXECUTE_HANDLER)
1430 {
1431 Status = I_RpcMapWin32Status(RpcExceptionCode());
1432 }
1433 RpcEndExcept;
1434
1435 return Status;
1436 }
1437
1438
1439 /*
1440 * @unimplemented
1441 */
1442 NTSTATUS
1443 WINAPI
1444 LsaSetTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle,
1445 IN PLSA_UNICODE_STRING TrustedDomainName,
1446 IN TRUSTED_INFORMATION_CLASS InformationClass,
1447 IN PVOID Buffer)
1448 {
1449 FIXME("LsaSetTrustedDomainInfoByName(%p %p %d %p) stub\n",
1450 PolicyHandle, TrustedDomainName, InformationClass, Buffer);
1451 return STATUS_SUCCESS;
1452 }
1453
1454
1455 /*
1456 * @unimplemented
1457 */
1458 NTSTATUS
1459 WINAPI
1460 LsaSetTrustedDomainInformation(IN LSA_HANDLE PolicyHandle,
1461 IN PSID TrustedDomainSid,
1462 IN TRUSTED_INFORMATION_CLASS InformationClass,
1463 IN PVOID Buffer)
1464 {
1465 FIXME("LsaSetTrustedDomainInformation(%p %p %d %p) stub\n",
1466 PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
1467 return STATUS_SUCCESS;
1468 }
1469
1470
1471 /*
1472 * @unimplemented
1473 */
1474 NTSTATUS
1475 WINAPI
1476 LsaStorePrivateData(IN LSA_HANDLE PolicyHandle,
1477 IN PLSA_UNICODE_STRING KeyName,
1478 IN PLSA_UNICODE_STRING PrivateData OPTIONAL)
1479 {
1480 FIXME("LsaStorePrivateData(%p %p %p) stub\n",
1481 PolicyHandle, KeyName, PrivateData);
1482 return STATUS_OBJECT_NAME_NOT_FOUND;
1483 }
1484
1485
1486 /*
1487 * @unimplemented
1488 */
1489 NTSTATUS
1490 WINAPI
1491 LsaUnregisterPolicyChangeNotification(IN POLICY_NOTIFICATION_INFORMATION_CLASS InformationClass,
1492 IN HANDLE NotificationEventHandle)
1493 {
1494 FIXME("(%d %p) stub\n",
1495 InformationClass, NotificationEventHandle);
1496 return STATUS_SUCCESS;
1497 }
1498
1499 /* EOF */
A free Windows-compatible Operating System