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
10 * 20030202 KJK compressed stubs
18 WINE_DEFAULT_DEBUG_CHANNEL(advapi
);
22 LsapIsLocalComputer(PLSA_UNICODE_STRING ServerName
)
24 DWORD dwSize
= MAX_COMPUTERNAME_LENGTH
+ 1;
28 if (ServerName
== NULL
|| ServerName
->Length
== 0 || ServerName
->Buffer
== NULL
)
31 buf
= HeapAlloc(GetProcessHeap(), 0, dwSize
* sizeof(WCHAR
));
32 Result
= GetComputerNameW(buf
, &dwSize
);
33 if (Result
&& (ServerName
->Buffer
[0] == '\\') && (ServerName
->Buffer
[1] == '\\'))
35 Result
= Result
&& !lstrcmpW(ServerName
->Buffer
, buf
);
36 HeapFree(GetProcessHeap(), 0, buf
);
44 PLSAPR_SERVER_NAME_bind(PLSAPR_SERVER_NAME pszSystemName
)
46 handle_t hBinding
= NULL
;
47 LPWSTR pszStringBinding
;
50 TRACE("PLSAPR_SERVER_NAME_bind() called\n");
52 status
= RpcStringBindingComposeW(NULL
,
60 TRACE("RpcStringBindingCompose returned 0x%x\n", status
);
64 /* Set the binding handle that will be used to bind to the server. */
65 status
= RpcBindingFromStringBindingW(pszStringBinding
,
69 TRACE("RpcBindingFromStringBinding returned 0x%x\n", status
);
72 status
= RpcStringFreeW(&pszStringBinding
);
75 TRACE("RpcStringFree returned 0x%x\n", status
);
84 PLSAPR_SERVER_NAME_unbind(PLSAPR_SERVER_NAME pszSystemName
,
89 TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
91 status
= RpcBindingFree(&hBinding
);
94 TRACE("RpcBindingFree returned 0x%x\n", status
);
104 LsaAddAccountRights(IN LSA_HANDLE PolicyHandle
,
106 IN PLSA_UNICODE_STRING UserRights
,
107 IN ULONG CountOfRights
)
109 LSAPR_USER_RIGHT_SET UserRightSet
;
112 TRACE("LsaAddAccountRights(%p %p %p 0x%08x)\n",
113 PolicyHandle
, AccountSid
, UserRights
, CountOfRights
);
115 UserRightSet
.Entries
= CountOfRights
;
116 UserRightSet
.UserRights
= (PRPC_UNICODE_STRING
)UserRights
;
120 Status
= LsarAddAccountRights((LSAPR_HANDLE
)PolicyHandle
,
121 (PRPC_SID
)AccountSid
,
125 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
127 Status
= I_RpcMapWin32Status(RpcExceptionCode());
140 LsaAddPrivilegesToAccount(IN LSA_HANDLE AccountHandle
,
141 IN PPRIVILEGE_SET PrivilegeSet
)
145 TRACE("LsaAddPrivilegesToAccount(%p %p)\n",
146 AccountHandle
, PrivilegeSet
);
150 Status
= LsarAddPrivilegesToAccount((LSAPR_HANDLE
)AccountHandle
,
151 (PLSAPR_PRIVILEGE_SET
)PrivilegeSet
);
153 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
155 Status
= I_RpcMapWin32Status(RpcExceptionCode());
168 LsaClearAuditLog(IN LSA_HANDLE PolicyHandle
)
172 TRACE("LsaClearAuditLog(%p)\n", PolicyHandle
);
176 Status
= LsarClearAuditLog((LSAPR_HANDLE
)PolicyHandle
);
178 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
180 Status
= I_RpcMapWin32Status(RpcExceptionCode());
193 LsaClose(IN LSA_HANDLE ObjectHandle
)
197 TRACE("LsaClose(%p) called\n", ObjectHandle
);
201 Status
= LsarClose((PLSAPR_HANDLE
)&ObjectHandle
);
203 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
205 Status
= I_RpcMapWin32Status(RpcExceptionCode());
218 LsaCreateAccount(IN LSA_HANDLE PolicyHandle
,
220 IN ACCESS_MASK DesiredAccess
,
221 OUT PLSA_HANDLE AccountHandle
)
225 TRACE("LsaCreateAccount(%p %p 0x%08lx %p)\n",
226 PolicyHandle
, AccountSid
, DesiredAccess
, AccountHandle
);
230 Status
= LsarCreateAccount((LSAPR_HANDLE
)PolicyHandle
,
235 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
237 Status
= I_RpcMapWin32Status(RpcExceptionCode());
250 LsaCreateSecret(IN LSA_HANDLE PolicyHandle
,
251 IN PLSA_UNICODE_STRING SecretName
,
252 IN ACCESS_MASK DesiredAccess
,
253 OUT PLSA_HANDLE SecretHandle
)
257 TRACE("LsaCreateSecret(%p %p 0x%08lx %p)\n",
258 PolicyHandle
, SecretName
, DesiredAccess
, SecretHandle
);
262 Status
= LsarCreateSecret((LSAPR_HANDLE
)PolicyHandle
,
263 (PRPC_UNICODE_STRING
)SecretName
,
267 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
269 Status
= I_RpcMapWin32Status(RpcExceptionCode());
282 LsaCreateTrustedDomain(IN LSA_HANDLE PolicyHandle
,
283 IN PLSA_TRUST_INFORMATION TrustedDomainInformation
,
284 IN ACCESS_MASK DesiredAccess
,
285 OUT PLSA_HANDLE TrustedDomainHandle
)
289 TRACE("LsaCreateTrustedDomain(%p %p 0x%08lx %p)\n",
290 PolicyHandle
, TrustedDomainInformation
, DesiredAccess
, TrustedDomainHandle
);
294 Status
= LsarCreateTrustedDomain((LSAPR_HANDLE
)PolicyHandle
,
295 (PLSAPR_TRUST_INFORMATION
)TrustedDomainInformation
,
297 (PLSAPR_HANDLE
)TrustedDomainHandle
);
299 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
301 Status
= I_RpcMapWin32Status(RpcExceptionCode());
314 LsaCreateTrustedDomainEx(IN LSA_HANDLE PolicyHandle
,
315 IN PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation
,
316 IN PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation
,
317 IN ACCESS_MASK DesiredAccess
,
318 OUT PLSA_HANDLE TrustedDomainHandle
)
320 PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL EncryptedAuthInfo
= NULL
;
323 TRACE("LsaCreateTrustedDomainEx(%p %p %p 0x%08lx %p) stub\n",
324 PolicyHandle
, TrustedDomainInformation
, AuthenticationInformation
,
325 DesiredAccess
, TrustedDomainHandle
);
329 /* FIXME: Encrypt AuthenticationInformation */
331 Status
= LsarCreateTrustedDomainEx2((LSAPR_HANDLE
)PolicyHandle
,
332 (PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX
)TrustedDomainInformation
,
335 (PLSAPR_HANDLE
)TrustedDomainHandle
);
337 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
339 Status
= I_RpcMapWin32Status(RpcExceptionCode());
352 LsaDelete(IN LSA_HANDLE ObjectHandle
)
356 TRACE("LsaDelete(%p)\n", ObjectHandle
);
360 Status
= LsarDelete((LSAPR_HANDLE
)ObjectHandle
);
362 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
364 Status
= I_RpcMapWin32Status(RpcExceptionCode());
377 LsaDeleteTrustedDomain(IN LSA_HANDLE PolicyHandle
,
378 IN PSID TrustedDomainSid
)
382 TRACE("LsaDeleteTrustedDomain(%p %p)\n",
383 PolicyHandle
, TrustedDomainSid
);
387 Status
= LsarDeleteTrustedDomain((LSAPR_HANDLE
)PolicyHandle
,
390 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
392 Status
= I_RpcMapWin32Status(RpcExceptionCode());
405 LsaEnumerateAccountRights(IN LSA_HANDLE PolicyHandle
,
407 OUT PLSA_UNICODE_STRING
*UserRights
,
408 OUT PULONG CountOfRights
)
410 LSAPR_USER_RIGHT_SET UserRightsSet
;
413 TRACE("LsaEnumerateAccountRights(%p %p %p %p)\n",
414 PolicyHandle
, AccountSid
, UserRights
, CountOfRights
);
416 UserRightsSet
.Entries
= 0;
417 UserRightsSet
.UserRights
= NULL
;
421 Status
= LsarEnumerateAccountRights((LSAPR_HANDLE
)PolicyHandle
,
425 *UserRights
= (PUNICODE_STRING
)UserRightsSet
.UserRights
;
426 *CountOfRights
= UserRightsSet
.Entries
;
428 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
430 Status
= I_RpcMapWin32Status(RpcExceptionCode());
432 if (UserRightsSet
.UserRights
!= NULL
)
433 MIDL_user_free(UserRightsSet
.UserRights
);
446 LsaEnumerateAccounts(IN LSA_HANDLE PolicyHandle
,
447 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext
,
449 IN ULONG PreferedMaximumLength
,
450 OUT PULONG CountReturned
)
452 LSAPR_ACCOUNT_ENUM_BUFFER AccountEnumBuffer
;
455 TRACE("LsaEnumerateAccounts(%p %p %p %lu %p)\n",
456 PolicyHandle
, EnumerationContext
, Buffer
,
457 PreferedMaximumLength
, CountReturned
);
459 AccountEnumBuffer
.EntriesRead
= 0;
460 AccountEnumBuffer
.Information
= NULL
;
464 Status
= LsarEnumerateAccounts((LSAPR_HANDLE
)PolicyHandle
,
467 PreferedMaximumLength
);
469 *Buffer
= AccountEnumBuffer
.Information
;
470 *CountReturned
= AccountEnumBuffer
.EntriesRead
;
472 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
474 if (AccountEnumBuffer
.Information
!= NULL
)
475 MIDL_user_free(AccountEnumBuffer
.Information
);
477 Status
= I_RpcMapWin32Status(RpcExceptionCode());
490 LsaEnumerateAccountsWithUserRight(IN LSA_HANDLE PolicyHandle
,
491 IN PLSA_UNICODE_STRING UserRight OPTIONAL
,
493 OUT PULONG CountReturned
)
495 LSAPR_ACCOUNT_ENUM_BUFFER AccountEnumBuffer
;
498 TRACE("LsaEnumerateAccountsWithUserRight(%p %p %p %p) stub\n",
499 PolicyHandle
, UserRight
, Buffer
, CountReturned
);
501 AccountEnumBuffer
.EntriesRead
= 0;
502 AccountEnumBuffer
.Information
= NULL
;
506 Status
= LsarEnumerateAccountsWithUserRight((LSAPR_HANDLE
)PolicyHandle
,
507 (PRPC_UNICODE_STRING
)UserRight
,
510 *Buffer
= AccountEnumBuffer
.Information
;
511 *CountReturned
= AccountEnumBuffer
.EntriesRead
;
513 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
515 if (AccountEnumBuffer
.Information
!= NULL
)
516 MIDL_user_free(AccountEnumBuffer
.Information
);
518 Status
= I_RpcMapWin32Status(RpcExceptionCode());
531 LsaEnumeratePrivileges(IN LSA_HANDLE PolicyHandle
,
532 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext
,
534 IN ULONG PreferedMaximumLength
,
535 OUT PULONG CountReturned
)
537 LSAPR_PRIVILEGE_ENUM_BUFFER PrivilegeEnumBuffer
;
540 TRACE("LsaEnumeratePrivileges(%p %p %p %lu %p)\n",
541 PolicyHandle
, EnumerationContext
, Buffer
,
542 PreferedMaximumLength
, CountReturned
);
544 PrivilegeEnumBuffer
.Entries
= 0;
545 PrivilegeEnumBuffer
.Privileges
= NULL
;
549 Status
= LsarEnumeratePrivileges((LSAPR_HANDLE
)PolicyHandle
,
551 &PrivilegeEnumBuffer
,
552 PreferedMaximumLength
);
554 *Buffer
= PrivilegeEnumBuffer
.Privileges
;
555 *CountReturned
= PrivilegeEnumBuffer
.Entries
;
558 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
560 if (PrivilegeEnumBuffer
.Privileges
!= NULL
)
561 MIDL_user_free(PrivilegeEnumBuffer
.Privileges
);
563 Status
= I_RpcMapWin32Status(RpcExceptionCode());
576 LsaEnumeratePrivilegesOfAccount(IN LSA_HANDLE AccountHandle
,
577 OUT PPRIVILEGE_SET
*Privileges
)
581 TRACE("LsaEnumeratePrivilegesOfAccount(%p %p)\n",
582 AccountHandle
, Privileges
);
586 Status
= LsarEnumeratePrivilegesAccount((LSAPR_HANDLE
)AccountHandle
,
587 (LSAPR_PRIVILEGE_SET
**)Privileges
);
589 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
591 Status
= I_RpcMapWin32Status(RpcExceptionCode());
604 LsaEnumerateTrustedDomains(IN LSA_HANDLE PolicyHandle
,
605 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext
,
607 IN ULONG PreferedMaximumLength
,
608 OUT PULONG CountReturned
)
610 FIXME("LsaEnumerateTrustedDomains(%p %p %p %lu %p) stub\n",
611 PolicyHandle
, EnumerationContext
, Buffer
,
612 PreferedMaximumLength
, CountReturned
);
617 return STATUS_SUCCESS
;
626 LsaEnumerateTrustedDomainsEx(IN LSA_HANDLE PolicyHandle
,
627 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext
,
629 IN ULONG PreferedMaximumLength
,
630 OUT PULONG CountReturned
)
632 FIXME("LsaEnumerateTrustedDomainsEx(%p %p %p %lu %p) stub\n",
633 PolicyHandle
, EnumerationContext
, Buffer
,
634 PreferedMaximumLength
, CountReturned
);
639 return STATUS_SUCCESS
;
648 LsaFreeMemory(IN PVOID Buffer
)
650 TRACE("LsaFreeMemory(%p)\n", Buffer
);
651 return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer
);
660 LsaGetQuotasForAccount(IN LSA_HANDLE AccountHandle
,
661 OUT PQUOTA_LIMITS QuotaLimits
)
665 TRACE("LsaGetQuotasForAccount(%p %p)\n",
666 AccountHandle
, QuotaLimits
);
670 Status
= LsarGetQuotasForAccount((LSAPR_HANDLE
)AccountHandle
,
673 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
675 Status
= I_RpcMapWin32Status(RpcExceptionCode());
688 LsaGetRemoteUserName(IN PLSA_UNICODE_STRING SystemName OPTIONAL
,
689 OUT PLSA_UNICODE_STRING
*UserName
,
690 OUT PLSA_UNICODE_STRING
*DomainName OPTIONAL
)
692 PRPC_UNICODE_STRING UserNameString
= NULL
;
693 PRPC_UNICODE_STRING DomainNameString
= NULL
;
696 TRACE("LsaGetRemoteUserName(%s %p %p)\n",
697 SystemName
? debugstr_w(SystemName
->Buffer
) : "(null)",
698 UserName
, DomainName
);
702 Status
= LsarGetUserName((PLSAPR_SERVER_NAME
)SystemName
,
704 (DomainName
!= NULL
) ? &DomainNameString
: NULL
);
706 *UserName
= (PLSA_UNICODE_STRING
)UserNameString
;
708 if (DomainName
!= NULL
)
709 *DomainName
= (PLSA_UNICODE_STRING
)DomainNameString
;
711 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
713 if (UserNameString
!= NULL
)
714 MIDL_user_free(UserNameString
);
716 if (DomainNameString
!= NULL
)
717 MIDL_user_free(DomainNameString
);
719 Status
= I_RpcMapWin32Status(RpcExceptionCode());
732 LsaGetSystemAccessAccount(IN LSA_HANDLE AccountHandle
,
733 OUT PULONG SystemAccess
)
737 TRACE("LsaGetSystemAccessAccount(%p %p)\n",
738 AccountHandle
, SystemAccess
);
742 Status
= LsarGetSystemAccessAccount((LSAPR_HANDLE
)AccountHandle
,
743 (ACCESS_MASK
*)SystemAccess
);
745 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
747 Status
= I_RpcMapWin32Status(RpcExceptionCode());
760 LsaGetUserName(OUT PUNICODE_STRING
*UserName
,
761 OUT PUNICODE_STRING
*DomainName OPTIONAL
)
763 PRPC_UNICODE_STRING UserNameString
= NULL
;
764 PRPC_UNICODE_STRING DomainNameString
= NULL
;
767 TRACE("LsaGetUserName(%p %p)\n",
768 UserName
, DomainName
);
772 Status
= LsarGetUserName(NULL
,
774 (DomainName
!= NULL
) ? &DomainNameString
: NULL
);
776 *UserName
= (PUNICODE_STRING
)UserNameString
;
778 if (DomainName
!= NULL
)
779 *DomainName
= (PUNICODE_STRING
)DomainNameString
;
781 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
783 if (UserNameString
!= NULL
)
784 MIDL_user_free(UserNameString
);
786 if (DomainNameString
!= NULL
)
787 MIDL_user_free(DomainNameString
);
789 Status
= I_RpcMapWin32Status(RpcExceptionCode());
802 LsaLookupNames(IN LSA_HANDLE PolicyHandle
,
804 IN PLSA_UNICODE_STRING Names
,
805 OUT PLSA_REFERENCED_DOMAIN_LIST
*ReferencedDomains
,
806 OUT PLSA_TRANSLATED_SID
*Sids
)
808 LSAPR_TRANSLATED_SIDS TranslatedSids
= {0, NULL
};
809 ULONG MappedCount
= 0;
812 TRACE("LsaLookupNames(%p %lu %p %p %p)\n",
813 PolicyHandle
, Count
, Names
, ReferencedDomains
, Sids
);
815 if (ReferencedDomains
== NULL
|| Sids
== NULL
)
816 return STATUS_INVALID_PARAMETER
;
820 *ReferencedDomains
= NULL
;
823 TranslatedSids
.Entries
= Count
;
825 Status
= LsarLookupNames((LSAPR_HANDLE
)PolicyHandle
,
827 (PRPC_UNICODE_STRING
)Names
,
828 (PLSAPR_REFERENCED_DOMAIN_LIST
*)ReferencedDomains
,
833 *Sids
= (PLSA_TRANSLATED_SID
)TranslatedSids
.Sids
;
835 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
837 if (TranslatedSids
.Sids
!= NULL
)
838 MIDL_user_free(TranslatedSids
.Sids
);
840 Status
= I_RpcMapWin32Status(RpcExceptionCode());
853 LsaLookupNames2(IN LSA_HANDLE PolicyHandle
,
856 IN PLSA_UNICODE_STRING Names
,
857 OUT PLSA_REFERENCED_DOMAIN_LIST
*ReferencedDomains
,
858 OUT PLSA_TRANSLATED_SID2
*Sids
)
860 LSAPR_TRANSLATED_SIDS_EX2 TranslatedSids
= {0, NULL
};
861 ULONG MappedCount
= 0;
864 TRACE("LsaLookupNames2(%p 0x%08x %lu %p %p %p)\n",
865 PolicyHandle
, Flags
, Count
, Names
, ReferencedDomains
, Sids
);
867 if (ReferencedDomains
== NULL
|| Sids
== NULL
)
868 return STATUS_INVALID_PARAMETER
;
872 *ReferencedDomains
= NULL
;
875 TranslatedSids
.Entries
= Count
;
877 Status
= LsarLookupNames3((LSAPR_HANDLE
)PolicyHandle
,
879 (PRPC_UNICODE_STRING
)Names
,
880 (PLSAPR_REFERENCED_DOMAIN_LIST
*)ReferencedDomains
,
887 *Sids
= (PLSA_TRANSLATED_SID2
)TranslatedSids
.Sids
;
889 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
891 if (TranslatedSids
.Sids
!= NULL
)
892 MIDL_user_free(TranslatedSids
.Sids
);
894 Status
= I_RpcMapWin32Status(RpcExceptionCode());
907 LsaLookupPrivilegeDisplayName(IN LSA_HANDLE PolicyHandle
,
908 IN PLSA_UNICODE_STRING Name
,
909 OUT PLSA_UNICODE_STRING
*DisplayName
,
910 OUT PUSHORT LanguageReturned
)
912 PRPC_UNICODE_STRING DisplayNameBuffer
= NULL
;
915 TRACE("LsaLookupPrivilegeDisplayName(%p %p %p %p)\n",
916 PolicyHandle
, Name
, DisplayName
, LanguageReturned
);
920 Status
= LsarLookupPrivilegeDisplayName(PolicyHandle
,
921 (PRPC_UNICODE_STRING
)Name
,
922 GetUserDefaultUILanguage(),
923 GetSystemDefaultUILanguage(),
927 *DisplayName
= (PUNICODE_STRING
)DisplayNameBuffer
;
929 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
931 if (DisplayNameBuffer
!= NULL
)
932 MIDL_user_free(DisplayNameBuffer
);
934 Status
= I_RpcMapWin32Status(RpcExceptionCode());
947 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle
,
949 OUT PUNICODE_STRING
*Name
)
951 PRPC_UNICODE_STRING NameBuffer
= NULL
;
954 TRACE("LsaLookupPrivilegeName(%p %p %p)\n",
955 PolicyHandle
, Value
, Name
);
959 Status
= LsarLookupPrivilegeName(PolicyHandle
,
963 *Name
= (PUNICODE_STRING
)NameBuffer
;
965 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
967 if (NameBuffer
!= NULL
)
968 MIDL_user_free(NameBuffer
);
970 Status
= I_RpcMapWin32Status(RpcExceptionCode());
983 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle
,
984 IN PLSA_UNICODE_STRING Name
,
990 TRACE("LsaLookupPrivilegeValue(%p %p %p)\n",
991 PolicyHandle
, Name
, Value
);
995 Status
= LsarLookupPrivilegeValue(PolicyHandle
,
996 (PRPC_UNICODE_STRING
)Name
,
998 if (Status
== STATUS_SUCCESS
)
1001 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1003 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1016 LsaLookupSids(IN LSA_HANDLE PolicyHandle
,
1019 OUT PLSA_REFERENCED_DOMAIN_LIST
*ReferencedDomains
,
1020 OUT PLSA_TRANSLATED_NAME
*Names
)
1022 LSAPR_SID_ENUM_BUFFER SidEnumBuffer
;
1023 LSAPR_TRANSLATED_NAMES TranslatedNames
;
1024 ULONG MappedCount
= 0;
1027 TRACE("LsaLookupSids(%p %lu %p %p %p)\n",
1028 PolicyHandle
, Count
, Sids
, ReferencedDomains
, Names
);
1031 return STATUS_INVALID_PARAMETER
;
1033 SidEnumBuffer
.Entries
= Count
;
1034 SidEnumBuffer
.SidInfo
= (PLSAPR_SID_INFORMATION
)Sids
;
1038 *ReferencedDomains
= NULL
;
1041 TranslatedNames
.Entries
= 0;
1042 TranslatedNames
.Names
= NULL
;
1044 Status
= LsarLookupSids((LSAPR_HANDLE
)PolicyHandle
,
1046 (PLSAPR_REFERENCED_DOMAIN_LIST
*)ReferencedDomains
,
1051 *Names
= (PLSA_TRANSLATED_NAME
)TranslatedNames
.Names
;
1053 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1055 if (TranslatedNames
.Names
!= NULL
)
1057 MIDL_user_free(TranslatedNames
.Names
);
1060 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1068 /******************************************************************************
1069 * LsaNtStatusToWinError
1078 LsaNtStatusToWinError(IN NTSTATUS Status
)
1080 TRACE("LsaNtStatusToWinError(0x%lx)\n", Status
);
1081 return RtlNtStatusToDosError(Status
);
1090 LsaOpenAccount(IN LSA_HANDLE PolicyHandle
,
1092 IN ACCESS_MASK DesiredAccess
,
1093 OUT PLSA_HANDLE AccountHandle
)
1097 TRACE("LsaOpenAccount(%p %p 0x%08lx %p)\n",
1098 PolicyHandle
, AccountSid
, DesiredAccess
, AccountHandle
);
1102 Status
= LsarOpenAccount((LSAPR_HANDLE
)PolicyHandle
,
1107 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1109 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1117 /******************************************************************************
1130 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName OPTIONAL
,
1131 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes
,
1132 IN ACCESS_MASK DesiredAccess
,
1133 OUT PLSA_HANDLE PolicyHandle
)
1137 TRACE("LsaOpenPolicy(%s %p 0x%08lx %p)\n",
1138 SystemName
? debugstr_w(SystemName
->Buffer
) : "(null)",
1139 ObjectAttributes
, DesiredAccess
, PolicyHandle
);
1141 /* FIXME: RPC should take care of this */
1142 if (!LsapIsLocalComputer(SystemName
))
1143 return RPC_NT_SERVER_UNAVAILABLE
;
1147 *PolicyHandle
= NULL
;
1149 Status
= LsarOpenPolicy(SystemName
? SystemName
->Buffer
: NULL
,
1150 (PLSAPR_OBJECT_ATTRIBUTES
)ObjectAttributes
,
1154 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1156 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1160 TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status
);
1171 LsaOpenPolicySce(IN PLSA_UNICODE_STRING SystemName OPTIONAL
,
1172 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes
,
1173 IN ACCESS_MASK DesiredAccess
,
1174 OUT PLSA_HANDLE PolicyHandle
)
1176 FIXME("LsaOpenPolicySce(%s %p 0x%08lx %p)\n",
1177 SystemName
? debugstr_w(SystemName
->Buffer
) : "(null)",
1178 ObjectAttributes
, DesiredAccess
, PolicyHandle
);
1179 return STATUS_NOT_IMPLEMENTED
;
1188 LsaOpenSecret(IN LSA_HANDLE PolicyHandle
,
1189 IN PLSA_UNICODE_STRING SecretName
,
1190 IN ACCESS_MASK DesiredAccess
,
1191 OUT PLSA_HANDLE SecretHandle
)
1195 TRACE("LsaOpenSecret(%p %p 0x%08lx %p)\n",
1196 PolicyHandle
, SecretName
, DesiredAccess
, SecretHandle
);
1200 *SecretHandle
= NULL
;
1202 Status
= LsarOpenSecret((LSAPR_HANDLE
)PolicyHandle
,
1203 (PRPC_UNICODE_STRING
)SecretName
,
1207 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1209 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1213 TRACE("LsaOpenSecret() done (Status: 0x%08lx)\n", Status
);
1224 LsaOpenTrustedDomain(IN LSA_HANDLE PolicyHandle
,
1225 IN PSID TrustedDomainSid
,
1226 IN ACCESS_MASK DesiredAccess
,
1227 OUT PLSA_HANDLE TrustedDomainHandle
)
1231 TRACE("LsaOpenTrustedDomain(%p %p 0x%08lx %p)\n",
1232 PolicyHandle
, TrustedDomainSid
, DesiredAccess
, TrustedDomainHandle
);
1236 Status
= LsarOpenTrustedDomain((LSAPR_HANDLE
)PolicyHandle
,
1237 (PRPC_SID
)TrustedDomainSid
,
1239 (PLSAPR_HANDLE
)TrustedDomainHandle
);
1241 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1243 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1256 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle
,
1257 IN PLSA_UNICODE_STRING TrustedDomainName
,
1258 IN ACCESS_MASK DesiredAccess
,
1259 OUT PLSA_HANDLE TrustedDomainHandle
)
1263 TRACE("LsaOpenTrustedDomainByName(%p %p 0x%08lx %p)\n",
1264 PolicyHandle
, TrustedDomainName
, DesiredAccess
, TrustedDomainHandle
);
1268 Status
= LsarOpenTrustedDomainByName((LSAPR_HANDLE
)PolicyHandle
,
1269 (PRPC_UNICODE_STRING
)TrustedDomainName
,
1271 TrustedDomainHandle
);
1273 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1275 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1288 LsaQueryDomainInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1289 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass
,
1292 PLSAPR_POLICY_DOMAIN_INFORMATION PolicyInformation
= NULL
;
1295 TRACE("LsaQueryDomainInformationPolicy(%p %lu %p)\n",
1296 PolicyHandle
, InformationClass
, Buffer
);
1300 Status
= LsarQueryDomainInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1302 &PolicyInformation
);
1304 *Buffer
= PolicyInformation
;
1306 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1308 if (PolicyInformation
!= NULL
)
1309 MIDL_user_free(PolicyInformation
);
1311 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1324 LsaQueryForestTrustInformation(IN LSA_HANDLE PolicyHandle
,
1325 IN PLSA_UNICODE_STRING TrustedDomainName
,
1326 OUT PLSA_FOREST_TRUST_INFORMATION
*ForestTrustInfo
)
1330 TRACE("LsaQueryForestTrustInformation(%p %p %p)\n",
1331 PolicyHandle
, TrustedDomainName
, ForestTrustInfo
);
1335 Status
= LsarQueryForestTrustInformation((LSAPR_HANDLE
)PolicyHandle
,
1337 ForestTrustDomainInfo
,
1340 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1342 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1355 LsaQueryInfoTrustedDomain(IN LSA_HANDLE TrustedDomainHandle
,
1356 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1359 FIXME("LsaQueryInfoTrustedDomain(%p %d %p) stub\n",
1360 TrustedDomainHandle
, InformationClass
, Buffer
);
1361 return STATUS_NOT_IMPLEMENTED
;
1370 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1371 IN POLICY_INFORMATION_CLASS InformationClass
,
1374 PLSAPR_POLICY_INFORMATION PolicyInformation
= NULL
;
1377 TRACE("LsaQueryInformationPolicy(%p %d %p)\n",
1378 PolicyHandle
, InformationClass
, Buffer
);
1382 Status
= LsarQueryInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1384 &PolicyInformation
);
1385 *Buffer
= PolicyInformation
;
1387 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1389 if (PolicyInformation
!= NULL
)
1390 MIDL_user_free(PolicyInformation
);
1392 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1396 TRACE("Done (Status: 0x%08x)\n", Status
);
1407 LsaQuerySecret(IN LSA_HANDLE SecretHandle
,
1408 OUT PLSA_UNICODE_STRING
*CurrentValue OPTIONAL
,
1409 OUT PLARGE_INTEGER CurrentValueSetTime OPTIONAL
,
1410 OUT PLSA_UNICODE_STRING
*OldValue OPTIONAL
,
1411 OUT PLARGE_INTEGER OldValueSetTime OPTIONAL
)
1413 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue
= NULL
;
1414 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue
= NULL
;
1415 PLSA_UNICODE_STRING DecryptedCurrentValue
= NULL
;
1416 PLSA_UNICODE_STRING DecryptedOldValue
= NULL
;
1420 TRACE("LsaQuerySecret(%p %p %p %p %p)\n",
1421 SecretHandle
, CurrentValue
, CurrentValueSetTime
,
1422 OldValue
, OldValueSetTime
);
1426 Status
= LsarQuerySecret((PLSAPR_HANDLE
)SecretHandle
,
1427 &EncryptedCurrentValue
,
1428 CurrentValueSetTime
,
1432 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1434 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1438 if (!NT_SUCCESS(Status
))
1441 /* Decrypt the current value */
1442 if (CurrentValue
!= NULL
)
1444 if (EncryptedCurrentValue
== NULL
)
1446 *CurrentValue
= NULL
;
1450 /* FIXME: Decrypt the current value */
1451 BufferSize
= sizeof(LSA_UNICODE_STRING
) + EncryptedCurrentValue
->MaximumLength
;
1452 DecryptedCurrentValue
= midl_user_allocate(BufferSize
);
1453 if (DecryptedCurrentValue
== NULL
)
1455 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1459 DecryptedCurrentValue
->Length
= (USHORT
)EncryptedCurrentValue
->Length
;
1460 DecryptedCurrentValue
->MaximumLength
= (USHORT
)EncryptedCurrentValue
->MaximumLength
;
1461 DecryptedCurrentValue
->Buffer
= (PWSTR
)(DecryptedCurrentValue
+ 1);
1462 RtlCopyMemory(DecryptedCurrentValue
->Buffer
,
1463 EncryptedCurrentValue
->Buffer
,
1464 EncryptedCurrentValue
->Length
);
1466 *CurrentValue
= DecryptedCurrentValue
;
1470 /* Decrypt the old value */
1471 if (OldValue
!= NULL
)
1473 if (EncryptedOldValue
== NULL
)
1479 /* FIXME: Decrypt the old value */
1480 BufferSize
= sizeof(LSA_UNICODE_STRING
) + EncryptedOldValue
->MaximumLength
;
1481 DecryptedOldValue
= midl_user_allocate(BufferSize
);
1482 if (DecryptedOldValue
== NULL
)
1484 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1488 DecryptedOldValue
->Length
= (USHORT
)EncryptedOldValue
->Length
;
1489 DecryptedOldValue
->MaximumLength
= (USHORT
)EncryptedOldValue
->MaximumLength
;
1490 DecryptedOldValue
->Buffer
= (PWSTR
)(DecryptedOldValue
+ 1);
1491 RtlCopyMemory(DecryptedOldValue
->Buffer
,
1492 EncryptedOldValue
->Buffer
,
1493 EncryptedOldValue
->Length
);
1495 *OldValue
= DecryptedOldValue
;
1500 if (!NT_SUCCESS(Status
))
1502 if (DecryptedCurrentValue
!= NULL
)
1503 midl_user_free(DecryptedCurrentValue
);
1505 if (DecryptedOldValue
!= NULL
)
1506 midl_user_free(DecryptedOldValue
);
1508 if (CurrentValue
!= NULL
)
1509 *CurrentValue
= NULL
;
1511 if (OldValue
!= NULL
)
1515 if (EncryptedCurrentValue
!= NULL
)
1516 midl_user_free(EncryptedCurrentValue
);
1518 if (EncryptedOldValue
!= NULL
)
1519 midl_user_free(EncryptedOldValue
);
1530 LsaQuerySecurityObject(IN LSA_HANDLE ObjectHandle
,
1531 IN SECURITY_INFORMATION SecurityInformation
,
1532 OUT PSECURITY_DESCRIPTOR
*SecurityDescriptor
)
1534 LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer
;
1535 PLSAPR_SR_SECURITY_DESCRIPTOR SdPointer
;
1538 TRACE("LsaQuerySecurityObject(%p %lx %p)\n",
1539 ObjectHandle
, SecurityInformation
, SecurityDescriptor
);
1541 SdBuffer
.Length
= 0;
1542 SdBuffer
.SecurityDescriptor
= NULL
;
1544 SdPointer
= &SdBuffer
;
1548 Status
= LsarQuerySecurityObject((LSAPR_HANDLE
)ObjectHandle
,
1549 SecurityInformation
,
1551 if (NT_SUCCESS(Status
))
1553 *SecurityDescriptor
= SdBuffer
.SecurityDescriptor
;
1557 *SecurityDescriptor
= NULL
;
1560 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1562 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1575 LsaQueryTrustedDomainInfo(IN LSA_HANDLE PolicyHandle
,
1576 IN PSID TrustedDomainSid
,
1577 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1580 FIXME("LsaQueryTrustedDomainInfo(%p %p %d %p) stub\n",
1581 PolicyHandle
, TrustedDomainSid
, InformationClass
, Buffer
);
1582 return STATUS_OBJECT_NAME_NOT_FOUND
;
1591 LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle
,
1592 IN PLSA_UNICODE_STRING TrustedDomainName
,
1593 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1598 TRACE("LsaQueryTrustedDomainInfoByName(%p %p %d %p)\n",
1599 PolicyHandle
, TrustedDomainName
, InformationClass
, Buffer
);
1601 if (InformationClass
== TrustedDomainAuthInformationInternal
||
1602 InformationClass
== TrustedDomainFullInformationInternal
)
1603 return STATUS_INVALID_INFO_CLASS
;
1607 Status
= LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE
)PolicyHandle
,
1608 (PRPC_UNICODE_STRING
)TrustedDomainName
,
1610 (PLSAPR_TRUSTED_DOMAIN_INFO
*)Buffer
);
1612 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1614 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1627 LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle
,
1629 IN BOOLEAN AllRights
,
1630 IN PLSA_UNICODE_STRING UserRights
,
1631 IN ULONG CountOfRights
)
1633 LSAPR_USER_RIGHT_SET UserRightSet
;
1635 TRACE("LsaRemoveAccountRights(%p %p %d %p %lu)\n",
1636 PolicyHandle
, AccountSid
, AllRights
, UserRights
, CountOfRights
);
1638 UserRightSet
.Entries
= CountOfRights
;
1639 UserRightSet
.UserRights
= (PRPC_UNICODE_STRING
)UserRights
;
1643 LsarRemoveAccountRights((LSAPR_HANDLE
)PolicyHandle
,
1644 (PRPC_SID
)AccountSid
,
1648 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1650 I_RpcMapWin32Status(RpcExceptionCode());
1654 return STATUS_SUCCESS
;
1663 LsaRemovePrivilegesFromAccount(IN LSA_HANDLE AccountHandle
,
1664 IN BOOLEAN AllPrivileges
,
1665 IN PPRIVILEGE_SET Privileges OPTIONAL
)
1671 Status
= LsarRemovePrivilegesFromAccount((LSAPR_HANDLE
)AccountHandle
,
1673 (PLSAPR_PRIVILEGE_SET
)Privileges
);
1675 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1677 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1690 LsaRetrievePrivateData(IN LSA_HANDLE PolicyHandle
,
1691 IN PLSA_UNICODE_STRING KeyName
,
1692 OUT PLSA_UNICODE_STRING
*PrivateData
)
1694 FIXME("LsaRetrievePrivateData(%p %p %p) stub\n",
1695 PolicyHandle
, KeyName
, PrivateData
);
1696 return STATUS_OBJECT_NAME_NOT_FOUND
;
1705 LsaSetDomainInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1706 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass
,
1707 IN PVOID Buffer OPTIONAL
)
1711 TRACE("LsaSetDomainInformationPolicy(%p %d %p)\n",
1712 PolicyHandle
, InformationClass
, Buffer
);
1716 Status
= LsarSetDomainInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1718 (PLSAPR_POLICY_DOMAIN_INFORMATION
)Buffer
);
1720 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1722 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1735 LsaSetForestTrustInformation(IN LSA_HANDLE PolicyHandle
,
1736 IN PLSA_UNICODE_STRING TrustedDomainName
,
1737 IN PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo
,
1739 OUT PLSA_FOREST_TRUST_COLLISION_INFORMATION
*CollisionInfo
)
1743 TRACE("LsaSetForestTrustInformation(%p %p %p %d %p)\n",
1744 PolicyHandle
, TrustedDomainName
, ForestTrustInfo
, CheckOnly
, CollisionInfo
);
1748 Status
= LsarSetForestTrustInformation((LSAPR_HANDLE
)PolicyHandle
,
1750 ForestTrustDomainInfo
,
1755 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1757 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1770 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1771 IN POLICY_INFORMATION_CLASS InformationClass
,
1776 TRACE("LsaSetInformationPolicy(%p %d %p)\n",
1777 PolicyHandle
, InformationClass
, Buffer
);
1781 Status
= LsarSetInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1783 (PLSAPR_POLICY_INFORMATION
)Buffer
);
1785 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1787 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1800 LsaSetInformationTrustedDomain(IN LSA_HANDLE TrustedDomainHandle
,
1801 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1804 FIXME("LsaSetInformationTrustedDomain(%p %d %p)\n",
1805 TrustedDomainHandle
, InformationClass
, Buffer
);
1806 return STATUS_NOT_IMPLEMENTED
;
1815 LsaSetQuotasForAccount(IN LSA_HANDLE AccountHandle
,
1816 IN PQUOTA_LIMITS QuotaLimits
)
1820 TRACE("LsaSetQuotasForAccount(%p %p)\n",
1821 AccountHandle
, QuotaLimits
);
1825 Status
= LsarSetQuotasForAccount((LSAPR_HANDLE
)AccountHandle
,
1828 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1830 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1843 LsaSetSecret(IN LSA_HANDLE SecretHandle
,
1844 IN PLSA_UNICODE_STRING CurrentValue OPTIONAL
,
1845 IN PLSA_UNICODE_STRING OldValue OPTIONAL
)
1847 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue
= NULL
;
1848 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue
= NULL
;
1852 TRACE("LsaSetSecret(%p %p %p)\n",
1853 SecretHandle
, EncryptedCurrentValue
, EncryptedOldValue
);
1855 if (CurrentValue
!= NULL
)
1857 BufferSize
= sizeof(LSAPR_CR_CIPHER_VALUE
) + CurrentValue
->MaximumLength
;
1858 EncryptedCurrentValue
= midl_user_allocate(BufferSize
);
1859 if (EncryptedCurrentValue
== NULL
)
1861 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1865 EncryptedCurrentValue
->Length
= CurrentValue
->Length
;
1866 EncryptedCurrentValue
->MaximumLength
= CurrentValue
->MaximumLength
;
1867 EncryptedCurrentValue
->Buffer
= (BYTE
*)(EncryptedCurrentValue
+ 1);
1868 if (EncryptedCurrentValue
->Buffer
!= NULL
)
1869 memcpy(EncryptedCurrentValue
->Buffer
, CurrentValue
->Buffer
, CurrentValue
->Length
);
1872 if (OldValue
!= NULL
)
1874 BufferSize
= sizeof(LSAPR_CR_CIPHER_VALUE
) + OldValue
->MaximumLength
;
1875 EncryptedOldValue
= midl_user_allocate(BufferSize
);
1876 if (EncryptedOldValue
== NULL
)
1878 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1882 EncryptedOldValue
->Length
= OldValue
->Length
;
1883 EncryptedOldValue
->MaximumLength
= OldValue
->MaximumLength
;
1884 EncryptedOldValue
->Buffer
= (BYTE
*)(EncryptedOldValue
+ 1);
1885 if (EncryptedOldValue
->Buffer
!= NULL
)
1886 memcpy(EncryptedOldValue
->Buffer
, OldValue
->Buffer
, OldValue
->Length
);
1891 Status
= LsarSetSecret((LSAPR_HANDLE
)SecretHandle
,
1892 EncryptedCurrentValue
,
1895 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1897 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1902 if (EncryptedCurrentValue
!= NULL
)
1903 midl_user_free(EncryptedCurrentValue
);
1905 if (EncryptedOldValue
!= NULL
)
1906 midl_user_free(EncryptedOldValue
);
1917 LsaSetSecurityObject(IN LSA_HANDLE ObjectHandle
,
1918 IN SECURITY_INFORMATION SecurityInformation
,
1919 IN PSECURITY_DESCRIPTOR SecurityDescriptor
)
1921 LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer
= {0, NULL
};
1925 TRACE("LsaSetSecurityObject(%p %lx %p)\n",
1926 ObjectHandle
, SecurityInformation
, SecurityDescriptor
);
1928 Status
= RtlMakeSelfRelativeSD(SecurityDescriptor
,
1931 if (Status
!= STATUS_BUFFER_TOO_SMALL
)
1932 return STATUS_INVALID_PARAMETER
;
1934 SdBuffer
.SecurityDescriptor
= MIDL_user_allocate(SdLength
);
1935 if (SdBuffer
.SecurityDescriptor
== NULL
)
1936 return STATUS_INSUFFICIENT_RESOURCES
;
1938 Status
= RtlMakeSelfRelativeSD(SecurityDescriptor
,
1939 (PSECURITY_DESCRIPTOR
)SdBuffer
.SecurityDescriptor
,
1941 if (!NT_SUCCESS(Status
))
1944 SdBuffer
.Length
= SdLength
;
1948 Status
= LsarSetSecurityObject((LSAPR_HANDLE
)ObjectHandle
,
1949 SecurityInformation
,
1952 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1954 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1959 if (SdBuffer
.SecurityDescriptor
!= NULL
)
1960 MIDL_user_free(SdBuffer
.SecurityDescriptor
);
1971 LsaSetSystemAccessAccount(IN LSA_HANDLE AccountHandle
,
1972 IN ULONG SystemAccess
)
1976 TRACE("LsaSetSystemAccessAccount(%p 0x%lx)\n",
1977 AccountHandle
, SystemAccess
);
1981 Status
= LsarSetSystemAccessAccount((LSAPR_HANDLE
)AccountHandle
,
1984 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1986 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1999 LsaSetTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle
,
2000 IN PLSA_UNICODE_STRING TrustedDomainName
,
2001 IN TRUSTED_INFORMATION_CLASS InformationClass
,
2004 FIXME("LsaSetTrustedDomainInfoByName(%p %p %d %p) stub\n",
2005 PolicyHandle
, TrustedDomainName
, InformationClass
, Buffer
);
2006 return STATUS_SUCCESS
;
2015 LsaSetTrustedDomainInformation(IN LSA_HANDLE PolicyHandle
,
2016 IN PSID TrustedDomainSid
,
2017 IN TRUSTED_INFORMATION_CLASS InformationClass
,
2020 FIXME("LsaSetTrustedDomainInformation(%p %p %d %p) stub\n",
2021 PolicyHandle
, TrustedDomainSid
, InformationClass
, Buffer
);
2022 return STATUS_SUCCESS
;
2031 LsaStorePrivateData(IN LSA_HANDLE PolicyHandle
,
2032 IN PLSA_UNICODE_STRING KeyName
,
2033 IN PLSA_UNICODE_STRING PrivateData OPTIONAL
)
2035 FIXME("LsaStorePrivateData(%p %p %p) stub\n",
2036 PolicyHandle
, KeyName
, PrivateData
);
2037 return STATUS_OBJECT_NAME_NOT_FOUND
;