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
17 WINE_DEFAULT_DEBUG_CHANNEL(advapi
);
21 LsapIsLocalComputer(PLSA_UNICODE_STRING ServerName
)
23 DWORD dwSize
= MAX_COMPUTERNAME_LENGTH
+ 1;
27 if (ServerName
== NULL
|| ServerName
->Length
== 0 || ServerName
->Buffer
== NULL
)
30 buf
= HeapAlloc(GetProcessHeap(), 0, dwSize
* sizeof(WCHAR
));
31 Result
= GetComputerNameW(buf
, &dwSize
);
32 if (Result
&& (ServerName
->Buffer
[0] == '\\') && (ServerName
->Buffer
[1] == '\\'))
34 Result
= Result
&& !lstrcmpW(ServerName
->Buffer
, buf
);
35 HeapFree(GetProcessHeap(), 0, buf
);
43 PLSAPR_SERVER_NAME_bind(PLSAPR_SERVER_NAME pszSystemName
)
45 handle_t hBinding
= NULL
;
46 LPWSTR pszStringBinding
;
49 TRACE("PLSAPR_SERVER_NAME_bind() called\n");
51 status
= RpcStringBindingComposeW(NULL
,
59 TRACE("RpcStringBindingCompose returned 0x%x\n", status
);
63 /* Set the binding handle that will be used to bind to the server. */
64 status
= RpcBindingFromStringBindingW(pszStringBinding
,
68 TRACE("RpcBindingFromStringBinding returned 0x%x\n", status
);
71 status
= RpcStringFreeW(&pszStringBinding
);
74 TRACE("RpcStringFree returned 0x%x\n", status
);
83 PLSAPR_SERVER_NAME_unbind(PLSAPR_SERVER_NAME pszSystemName
,
88 TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
90 status
= RpcBindingFree(&hBinding
);
93 TRACE("RpcBindingFree returned 0x%x\n", status
);
103 LsaAddAccountRights(IN LSA_HANDLE PolicyHandle
,
105 IN PLSA_UNICODE_STRING UserRights
,
106 IN ULONG CountOfRights
)
108 LSAPR_USER_RIGHT_SET UserRightSet
;
111 TRACE("LsaAddAccountRights(%p %p %p 0x%08x)\n",
112 PolicyHandle
, AccountSid
, UserRights
, CountOfRights
);
114 UserRightSet
.Entries
= CountOfRights
;
115 UserRightSet
.UserRights
= (PRPC_UNICODE_STRING
)UserRights
;
119 Status
= LsarAddAccountRights((LSAPR_HANDLE
)PolicyHandle
,
120 (PRPC_SID
)AccountSid
,
124 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
126 Status
= I_RpcMapWin32Status(RpcExceptionCode());
139 LsaAddPrivilegesToAccount(IN LSA_HANDLE AccountHandle
,
140 IN PPRIVILEGE_SET PrivilegeSet
)
144 TRACE("LsaAddPrivilegesToAccount(%p %p)\n",
145 AccountHandle
, PrivilegeSet
);
149 Status
= LsarAddPrivilegesToAccount((LSAPR_HANDLE
)AccountHandle
,
150 (PLSAPR_PRIVILEGE_SET
)PrivilegeSet
);
152 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
154 Status
= I_RpcMapWin32Status(RpcExceptionCode());
167 LsaClearAuditLog(IN LSA_HANDLE PolicyHandle
)
171 TRACE("LsaClearAuditLog(%p)\n", PolicyHandle
);
175 Status
= LsarClearAuditLog((LSAPR_HANDLE
)PolicyHandle
);
177 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
179 Status
= I_RpcMapWin32Status(RpcExceptionCode());
192 LsaClose(IN LSA_HANDLE ObjectHandle
)
196 TRACE("LsaClose(%p) called\n", ObjectHandle
);
200 Status
= LsarClose((PLSAPR_HANDLE
)&ObjectHandle
);
202 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
204 Status
= I_RpcMapWin32Status(RpcExceptionCode());
217 LsaCreateAccount(IN LSA_HANDLE PolicyHandle
,
219 IN ACCESS_MASK DesiredAccess
,
220 OUT PLSA_HANDLE AccountHandle
)
224 TRACE("LsaCreateAccount(%p %p 0x%08lx %p)\n",
225 PolicyHandle
, AccountSid
, DesiredAccess
, AccountHandle
);
229 Status
= LsarCreateAccount((LSAPR_HANDLE
)PolicyHandle
,
234 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
236 Status
= I_RpcMapWin32Status(RpcExceptionCode());
249 LsaCreateSecret(IN LSA_HANDLE PolicyHandle
,
250 IN PLSA_UNICODE_STRING SecretName
,
251 IN ACCESS_MASK DesiredAccess
,
252 OUT PLSA_HANDLE SecretHandle
)
256 TRACE("LsaCreateSecret(%p %p 0x%08lx %p)\n",
257 PolicyHandle
, SecretName
, DesiredAccess
, SecretHandle
);
261 Status
= LsarCreateSecret((LSAPR_HANDLE
)PolicyHandle
,
262 (PRPC_UNICODE_STRING
)SecretName
,
266 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
268 Status
= I_RpcMapWin32Status(RpcExceptionCode());
281 LsaCreateTrustedDomain(IN LSA_HANDLE PolicyHandle
,
282 IN PLSA_TRUST_INFORMATION TrustedDomainInformation
,
283 IN ACCESS_MASK DesiredAccess
,
284 OUT PLSA_HANDLE TrustedDomainHandle
)
288 TRACE("LsaCreateTrustedDomain(%p %p 0x%08lx %p)\n",
289 PolicyHandle
, TrustedDomainInformation
, DesiredAccess
, TrustedDomainHandle
);
293 Status
= LsarCreateTrustedDomain((LSAPR_HANDLE
)PolicyHandle
,
294 (PLSAPR_TRUST_INFORMATION
)TrustedDomainInformation
,
296 (PLSAPR_HANDLE
)TrustedDomainHandle
);
298 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
300 Status
= I_RpcMapWin32Status(RpcExceptionCode());
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
)
319 PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL EncryptedAuthInfo
= NULL
;
322 TRACE("LsaCreateTrustedDomainEx(%p %p %p 0x%08lx %p) stub\n",
323 PolicyHandle
, TrustedDomainInformation
, AuthenticationInformation
,
324 DesiredAccess
, TrustedDomainHandle
);
328 /* FIXME: Encrypt AuthenticationInformation */
330 Status
= LsarCreateTrustedDomainEx2((LSAPR_HANDLE
)PolicyHandle
,
331 (PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX
)TrustedDomainInformation
,
334 (PLSAPR_HANDLE
)TrustedDomainHandle
);
336 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
338 Status
= I_RpcMapWin32Status(RpcExceptionCode());
351 LsaDelete(IN LSA_HANDLE ObjectHandle
)
355 TRACE("LsaDelete(%p)\n", ObjectHandle
);
359 Status
= LsarDelete((LSAPR_HANDLE
)ObjectHandle
);
361 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
363 Status
= I_RpcMapWin32Status(RpcExceptionCode());
376 LsaDeleteTrustedDomain(IN LSA_HANDLE PolicyHandle
,
377 IN PSID TrustedDomainSid
)
381 TRACE("LsaDeleteTrustedDomain(%p %p)\n",
382 PolicyHandle
, TrustedDomainSid
);
386 Status
= LsarDeleteTrustedDomain((LSAPR_HANDLE
)PolicyHandle
,
389 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
391 Status
= I_RpcMapWin32Status(RpcExceptionCode());
404 LsaEnumerateAccountRights(IN LSA_HANDLE PolicyHandle
,
406 OUT PLSA_UNICODE_STRING
*UserRights
,
407 OUT PULONG CountOfRights
)
409 LSAPR_USER_RIGHT_SET UserRightsSet
;
412 TRACE("LsaEnumerateAccountRights(%p %p %p %p)\n",
413 PolicyHandle
, AccountSid
, UserRights
, CountOfRights
);
415 UserRightsSet
.Entries
= 0;
416 UserRightsSet
.UserRights
= NULL
;
420 Status
= LsarEnumerateAccountRights((LSAPR_HANDLE
)PolicyHandle
,
424 *UserRights
= (PUNICODE_STRING
)UserRightsSet
.UserRights
;
425 *CountOfRights
= UserRightsSet
.Entries
;
427 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
429 Status
= I_RpcMapWin32Status(RpcExceptionCode());
431 if (UserRightsSet
.UserRights
!= NULL
)
432 MIDL_user_free(UserRightsSet
.UserRights
);
445 LsaEnumerateAccounts(IN LSA_HANDLE PolicyHandle
,
446 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext
,
448 IN ULONG PreferedMaximumLength
,
449 OUT PULONG CountReturned
)
451 LSAPR_ACCOUNT_ENUM_BUFFER AccountEnumBuffer
;
454 TRACE("LsaEnumerateAccounts(%p %p %p %lu %p)\n",
455 PolicyHandle
, EnumerationContext
, Buffer
,
456 PreferedMaximumLength
, CountReturned
);
458 AccountEnumBuffer
.EntriesRead
= 0;
459 AccountEnumBuffer
.Information
= NULL
;
463 Status
= LsarEnumerateAccounts((LSAPR_HANDLE
)PolicyHandle
,
466 PreferedMaximumLength
);
468 *Buffer
= AccountEnumBuffer
.Information
;
469 *CountReturned
= AccountEnumBuffer
.EntriesRead
;
471 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
473 if (AccountEnumBuffer
.Information
!= NULL
)
474 MIDL_user_free(AccountEnumBuffer
.Information
);
476 Status
= I_RpcMapWin32Status(RpcExceptionCode());
489 LsaEnumerateAccountsWithUserRight(IN LSA_HANDLE PolicyHandle
,
490 IN PLSA_UNICODE_STRING UserRight OPTIONAL
,
492 OUT PULONG CountReturned
)
494 LSAPR_ACCOUNT_ENUM_BUFFER AccountEnumBuffer
;
497 TRACE("LsaEnumerateAccountsWithUserRight(%p %p %p %p) stub\n",
498 PolicyHandle
, UserRight
, Buffer
, CountReturned
);
500 AccountEnumBuffer
.EntriesRead
= 0;
501 AccountEnumBuffer
.Information
= NULL
;
505 Status
= LsarEnumerateAccountsWithUserRight((LSAPR_HANDLE
)PolicyHandle
,
506 (PRPC_UNICODE_STRING
)UserRight
,
509 *Buffer
= AccountEnumBuffer
.Information
;
510 *CountReturned
= AccountEnumBuffer
.EntriesRead
;
512 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
514 if (AccountEnumBuffer
.Information
!= NULL
)
515 MIDL_user_free(AccountEnumBuffer
.Information
);
517 Status
= I_RpcMapWin32Status(RpcExceptionCode());
530 LsaEnumeratePrivileges(IN LSA_HANDLE PolicyHandle
,
531 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext
,
533 IN ULONG PreferedMaximumLength
,
534 OUT PULONG CountReturned
)
536 LSAPR_PRIVILEGE_ENUM_BUFFER PrivilegeEnumBuffer
;
539 TRACE("LsaEnumeratePrivileges(%p %p %p %lu %p)\n",
540 PolicyHandle
, EnumerationContext
, Buffer
,
541 PreferedMaximumLength
, CountReturned
);
543 PrivilegeEnumBuffer
.Entries
= 0;
544 PrivilegeEnumBuffer
.Privileges
= NULL
;
548 Status
= LsarEnumeratePrivileges((LSAPR_HANDLE
)PolicyHandle
,
550 &PrivilegeEnumBuffer
,
551 PreferedMaximumLength
);
553 *Buffer
= PrivilegeEnumBuffer
.Privileges
;
554 *CountReturned
= PrivilegeEnumBuffer
.Entries
;
557 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
559 if (PrivilegeEnumBuffer
.Privileges
!= NULL
)
560 MIDL_user_free(PrivilegeEnumBuffer
.Privileges
);
562 Status
= I_RpcMapWin32Status(RpcExceptionCode());
575 LsaEnumeratePrivilegesOfAccount(IN LSA_HANDLE AccountHandle
,
576 OUT PPRIVILEGE_SET
*Privileges
)
580 TRACE("LsaEnumeratePrivilegesOfAccount(%p %p)\n",
581 AccountHandle
, Privileges
);
585 Status
= LsarEnumeratePrivilegesAccount((LSAPR_HANDLE
)AccountHandle
,
586 (LSAPR_PRIVILEGE_SET
**)Privileges
);
588 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
590 Status
= I_RpcMapWin32Status(RpcExceptionCode());
603 LsaEnumerateTrustedDomains(IN LSA_HANDLE PolicyHandle
,
604 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext
,
606 IN ULONG PreferedMaximumLength
,
607 OUT PULONG CountReturned
)
609 FIXME("LsaEnumerateTrustedDomains(%p %p %p %lu %p) stub\n",
610 PolicyHandle
, EnumerationContext
, Buffer
,
611 PreferedMaximumLength
, CountReturned
);
616 return STATUS_SUCCESS
;
625 LsaEnumerateTrustedDomainsEx(IN LSA_HANDLE PolicyHandle
,
626 IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext
,
628 IN ULONG PreferedMaximumLength
,
629 OUT PULONG CountReturned
)
631 FIXME("LsaEnumerateTrustedDomainsEx(%p %p %p %lu %p) stub\n",
632 PolicyHandle
, EnumerationContext
, Buffer
,
633 PreferedMaximumLength
, CountReturned
);
638 return STATUS_SUCCESS
;
647 LsaFreeMemory(IN PVOID Buffer
)
649 TRACE("LsaFreeMemory(%p)\n", Buffer
);
650 return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer
);
659 LsaGetQuotasForAccount(IN LSA_HANDLE AccountHandle
,
660 OUT PQUOTA_LIMITS QuotaLimits
)
664 TRACE("LsaGetQuotasForAccount(%p %p)\n",
665 AccountHandle
, QuotaLimits
);
669 Status
= LsarGetQuotasForAccount((LSAPR_HANDLE
)AccountHandle
,
672 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
674 Status
= I_RpcMapWin32Status(RpcExceptionCode());
687 LsaGetRemoteUserName(IN PLSA_UNICODE_STRING SystemName OPTIONAL
,
688 OUT PLSA_UNICODE_STRING
*UserName
,
689 OUT PLSA_UNICODE_STRING
*DomainName OPTIONAL
)
691 PRPC_UNICODE_STRING UserNameString
= NULL
;
692 PRPC_UNICODE_STRING DomainNameString
= NULL
;
695 TRACE("LsaGetRemoteUserName(%s %p %p)\n",
696 SystemName
? debugstr_w(SystemName
->Buffer
) : "(null)",
697 UserName
, DomainName
);
701 Status
= LsarGetUserName((PLSAPR_SERVER_NAME
)SystemName
,
703 (DomainName
!= NULL
) ? &DomainNameString
: NULL
);
705 *UserName
= (PLSA_UNICODE_STRING
)UserNameString
;
707 if (DomainName
!= NULL
)
708 *DomainName
= (PLSA_UNICODE_STRING
)DomainNameString
;
710 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
712 if (UserNameString
!= NULL
)
713 MIDL_user_free(UserNameString
);
715 if (DomainNameString
!= NULL
)
716 MIDL_user_free(DomainNameString
);
718 Status
= I_RpcMapWin32Status(RpcExceptionCode());
731 LsaGetSystemAccessAccount(IN LSA_HANDLE AccountHandle
,
732 OUT PULONG SystemAccess
)
736 TRACE("LsaGetSystemAccessAccount(%p %p)\n",
737 AccountHandle
, SystemAccess
);
741 Status
= LsarGetSystemAccessAccount((LSAPR_HANDLE
)AccountHandle
,
742 (ACCESS_MASK
*)SystemAccess
);
744 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
746 Status
= I_RpcMapWin32Status(RpcExceptionCode());
759 LsaGetUserName(OUT PUNICODE_STRING
*UserName
,
760 OUT PUNICODE_STRING
*DomainName OPTIONAL
)
762 PRPC_UNICODE_STRING UserNameString
= NULL
;
763 PRPC_UNICODE_STRING DomainNameString
= NULL
;
766 TRACE("LsaGetUserName(%p %p)\n",
767 UserName
, DomainName
);
771 Status
= LsarGetUserName(NULL
,
773 (DomainName
!= NULL
) ? &DomainNameString
: NULL
);
775 *UserName
= (PUNICODE_STRING
)UserNameString
;
777 if (DomainName
!= NULL
)
778 *DomainName
= (PUNICODE_STRING
)DomainNameString
;
780 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
782 if (UserNameString
!= NULL
)
783 MIDL_user_free(UserNameString
);
785 if (DomainNameString
!= NULL
)
786 MIDL_user_free(DomainNameString
);
788 Status
= I_RpcMapWin32Status(RpcExceptionCode());
801 LsaLookupNames(IN LSA_HANDLE PolicyHandle
,
803 IN PLSA_UNICODE_STRING Names
,
804 OUT PLSA_REFERENCED_DOMAIN_LIST
*ReferencedDomains
,
805 OUT PLSA_TRANSLATED_SID
*Sids
)
807 LSAPR_TRANSLATED_SIDS TranslatedSids
= {0, NULL
};
808 ULONG MappedCount
= 0;
811 TRACE("LsaLookupNames(%p %lu %p %p %p)\n",
812 PolicyHandle
, Count
, Names
, ReferencedDomains
, Sids
);
814 if (ReferencedDomains
== NULL
|| Sids
== NULL
)
815 return STATUS_INVALID_PARAMETER
;
819 *ReferencedDomains
= NULL
;
822 TranslatedSids
.Entries
= Count
;
824 Status
= LsarLookupNames((LSAPR_HANDLE
)PolicyHandle
,
826 (PRPC_UNICODE_STRING
)Names
,
827 (PLSAPR_REFERENCED_DOMAIN_LIST
*)ReferencedDomains
,
832 *Sids
= (PLSA_TRANSLATED_SID
)TranslatedSids
.Sids
;
834 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
836 if (TranslatedSids
.Sids
!= NULL
)
837 MIDL_user_free(TranslatedSids
.Sids
);
839 Status
= I_RpcMapWin32Status(RpcExceptionCode());
852 LsaLookupNames2(IN LSA_HANDLE PolicyHandle
,
855 IN PLSA_UNICODE_STRING Names
,
856 OUT PLSA_REFERENCED_DOMAIN_LIST
*ReferencedDomains
,
857 OUT PLSA_TRANSLATED_SID2
*Sids
)
859 LSAPR_TRANSLATED_SIDS_EX2 TranslatedSids
= {0, NULL
};
860 ULONG MappedCount
= 0;
863 TRACE("LsaLookupNames2(%p 0x%08x %lu %p %p %p)\n",
864 PolicyHandle
, Flags
, Count
, Names
, ReferencedDomains
, Sids
);
866 if (ReferencedDomains
== NULL
|| Sids
== NULL
)
867 return STATUS_INVALID_PARAMETER
;
871 *ReferencedDomains
= NULL
;
874 TranslatedSids
.Entries
= Count
;
876 Status
= LsarLookupNames3((LSAPR_HANDLE
)PolicyHandle
,
878 (PRPC_UNICODE_STRING
)Names
,
879 (PLSAPR_REFERENCED_DOMAIN_LIST
*)ReferencedDomains
,
886 *Sids
= (PLSA_TRANSLATED_SID2
)TranslatedSids
.Sids
;
888 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
890 if (TranslatedSids
.Sids
!= NULL
)
891 MIDL_user_free(TranslatedSids
.Sids
);
893 Status
= I_RpcMapWin32Status(RpcExceptionCode());
906 LsaLookupPrivilegeDisplayName(IN LSA_HANDLE PolicyHandle
,
907 IN PLSA_UNICODE_STRING Name
,
908 OUT PLSA_UNICODE_STRING
*DisplayName
,
909 OUT PUSHORT LanguageReturned
)
911 PRPC_UNICODE_STRING DisplayNameBuffer
= NULL
;
914 TRACE("LsaLookupPrivilegeDisplayName(%p %p %p %p)\n",
915 PolicyHandle
, Name
, DisplayName
, LanguageReturned
);
919 Status
= LsarLookupPrivilegeDisplayName(PolicyHandle
,
920 (PRPC_UNICODE_STRING
)Name
,
921 GetUserDefaultUILanguage(),
922 GetSystemDefaultUILanguage(),
926 *DisplayName
= (PUNICODE_STRING
)DisplayNameBuffer
;
928 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
930 if (DisplayNameBuffer
!= NULL
)
931 MIDL_user_free(DisplayNameBuffer
);
933 Status
= I_RpcMapWin32Status(RpcExceptionCode());
946 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle
,
948 OUT PUNICODE_STRING
*Name
)
950 PRPC_UNICODE_STRING NameBuffer
= NULL
;
953 TRACE("LsaLookupPrivilegeName(%p %p %p)\n",
954 PolicyHandle
, Value
, Name
);
958 Status
= LsarLookupPrivilegeName(PolicyHandle
,
962 *Name
= (PUNICODE_STRING
)NameBuffer
;
964 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
966 if (NameBuffer
!= NULL
)
967 MIDL_user_free(NameBuffer
);
969 Status
= I_RpcMapWin32Status(RpcExceptionCode());
982 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle
,
983 IN PLSA_UNICODE_STRING Name
,
989 TRACE("LsaLookupPrivilegeValue(%p %p %p)\n",
990 PolicyHandle
, Name
, Value
);
994 Status
= LsarLookupPrivilegeValue(PolicyHandle
,
995 (PRPC_UNICODE_STRING
)Name
,
997 if (Status
== STATUS_SUCCESS
)
1000 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1002 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1015 LsaLookupSids(IN LSA_HANDLE PolicyHandle
,
1018 OUT PLSA_REFERENCED_DOMAIN_LIST
*ReferencedDomains
,
1019 OUT PLSA_TRANSLATED_NAME
*Names
)
1021 LSAPR_SID_ENUM_BUFFER SidEnumBuffer
;
1022 LSAPR_TRANSLATED_NAMES TranslatedNames
;
1023 ULONG MappedCount
= 0;
1026 TRACE("LsaLookupSids(%p %lu %p %p %p)\n",
1027 PolicyHandle
, Count
, Sids
, ReferencedDomains
, Names
);
1030 return STATUS_INVALID_PARAMETER
;
1032 SidEnumBuffer
.Entries
= Count
;
1033 SidEnumBuffer
.SidInfo
= (PLSAPR_SID_INFORMATION
)Sids
;
1037 *ReferencedDomains
= NULL
;
1040 TranslatedNames
.Entries
= 0;
1041 TranslatedNames
.Names
= NULL
;
1043 Status
= LsarLookupSids((LSAPR_HANDLE
)PolicyHandle
,
1045 (PLSAPR_REFERENCED_DOMAIN_LIST
*)ReferencedDomains
,
1050 *Names
= (PLSA_TRANSLATED_NAME
)TranslatedNames
.Names
;
1052 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1054 if (TranslatedNames
.Names
!= NULL
)
1056 MIDL_user_free(TranslatedNames
.Names
);
1059 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1067 /******************************************************************************
1068 * LsaNtStatusToWinError
1077 LsaNtStatusToWinError(IN NTSTATUS Status
)
1079 TRACE("LsaNtStatusToWinError(0x%lx)\n", Status
);
1080 return RtlNtStatusToDosError(Status
);
1089 LsaOpenAccount(IN LSA_HANDLE PolicyHandle
,
1091 IN ACCESS_MASK DesiredAccess
,
1092 OUT PLSA_HANDLE AccountHandle
)
1096 TRACE("LsaOpenAccount(%p %p 0x%08lx %p)\n",
1097 PolicyHandle
, AccountSid
, DesiredAccess
, AccountHandle
);
1101 Status
= LsarOpenAccount((LSAPR_HANDLE
)PolicyHandle
,
1106 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1108 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1116 /******************************************************************************
1129 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName OPTIONAL
,
1130 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes
,
1131 IN ACCESS_MASK DesiredAccess
,
1132 OUT PLSA_HANDLE PolicyHandle
)
1136 TRACE("LsaOpenPolicy(%s %p 0x%08lx %p)\n",
1137 SystemName
? debugstr_w(SystemName
->Buffer
) : "(null)",
1138 ObjectAttributes
, DesiredAccess
, PolicyHandle
);
1140 /* FIXME: RPC should take care of this */
1141 if (!LsapIsLocalComputer(SystemName
))
1142 return RPC_NT_SERVER_UNAVAILABLE
;
1146 *PolicyHandle
= NULL
;
1148 Status
= LsarOpenPolicy(SystemName
? SystemName
->Buffer
: NULL
,
1149 (PLSAPR_OBJECT_ATTRIBUTES
)ObjectAttributes
,
1153 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1155 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1159 TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status
);
1170 LsaOpenPolicySce(IN PLSA_UNICODE_STRING SystemName OPTIONAL
,
1171 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes
,
1172 IN ACCESS_MASK DesiredAccess
,
1173 OUT PLSA_HANDLE PolicyHandle
)
1177 TRACE("LsaOpenPolicySce(%s %p 0x%08lx %p)\n",
1178 SystemName
? debugstr_w(SystemName
->Buffer
) : "(null)",
1179 ObjectAttributes
, DesiredAccess
, PolicyHandle
);
1181 /* FIXME: RPC should take care of this */
1182 if (!LsapIsLocalComputer(SystemName
))
1183 return RPC_NT_SERVER_UNAVAILABLE
;
1187 *PolicyHandle
= NULL
;
1189 Status
= LsarOpenPolicySce(SystemName
? SystemName
->Buffer
: NULL
,
1190 (PLSAPR_OBJECT_ATTRIBUTES
)ObjectAttributes
,
1194 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1196 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1200 TRACE("LsaOpenPolicySce() done (Status: 0x%08lx)\n", Status
);
1211 LsaOpenSecret(IN LSA_HANDLE PolicyHandle
,
1212 IN PLSA_UNICODE_STRING SecretName
,
1213 IN ACCESS_MASK DesiredAccess
,
1214 OUT PLSA_HANDLE SecretHandle
)
1218 TRACE("LsaOpenSecret(%p %p 0x%08lx %p)\n",
1219 PolicyHandle
, SecretName
, DesiredAccess
, SecretHandle
);
1223 *SecretHandle
= NULL
;
1225 Status
= LsarOpenSecret((LSAPR_HANDLE
)PolicyHandle
,
1226 (PRPC_UNICODE_STRING
)SecretName
,
1230 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1232 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1236 TRACE("LsaOpenSecret() done (Status: 0x%08lx)\n", Status
);
1247 LsaOpenTrustedDomain(IN LSA_HANDLE PolicyHandle
,
1248 IN PSID TrustedDomainSid
,
1249 IN ACCESS_MASK DesiredAccess
,
1250 OUT PLSA_HANDLE TrustedDomainHandle
)
1254 TRACE("LsaOpenTrustedDomain(%p %p 0x%08lx %p)\n",
1255 PolicyHandle
, TrustedDomainSid
, DesiredAccess
, TrustedDomainHandle
);
1259 Status
= LsarOpenTrustedDomain((LSAPR_HANDLE
)PolicyHandle
,
1260 (PRPC_SID
)TrustedDomainSid
,
1262 (PLSAPR_HANDLE
)TrustedDomainHandle
);
1264 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1266 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1279 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle
,
1280 IN PLSA_UNICODE_STRING TrustedDomainName
,
1281 IN ACCESS_MASK DesiredAccess
,
1282 OUT PLSA_HANDLE TrustedDomainHandle
)
1286 TRACE("LsaOpenTrustedDomainByName(%p %p 0x%08lx %p)\n",
1287 PolicyHandle
, TrustedDomainName
, DesiredAccess
, TrustedDomainHandle
);
1291 Status
= LsarOpenTrustedDomainByName((LSAPR_HANDLE
)PolicyHandle
,
1292 (PRPC_UNICODE_STRING
)TrustedDomainName
,
1294 TrustedDomainHandle
);
1296 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1298 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1311 LsaQueryDomainInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1312 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass
,
1315 PLSAPR_POLICY_DOMAIN_INFORMATION PolicyInformation
= NULL
;
1318 TRACE("LsaQueryDomainInformationPolicy(%p %lu %p)\n",
1319 PolicyHandle
, InformationClass
, Buffer
);
1323 Status
= LsarQueryDomainInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1325 &PolicyInformation
);
1327 *Buffer
= PolicyInformation
;
1329 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1331 if (PolicyInformation
!= NULL
)
1332 MIDL_user_free(PolicyInformation
);
1334 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1347 LsaQueryForestTrustInformation(IN LSA_HANDLE PolicyHandle
,
1348 IN PLSA_UNICODE_STRING TrustedDomainName
,
1349 OUT PLSA_FOREST_TRUST_INFORMATION
*ForestTrustInfo
)
1353 TRACE("LsaQueryForestTrustInformation(%p %p %p)\n",
1354 PolicyHandle
, TrustedDomainName
, ForestTrustInfo
);
1358 Status
= LsarQueryForestTrustInformation((LSAPR_HANDLE
)PolicyHandle
,
1360 ForestTrustDomainInfo
,
1363 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1365 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1378 LsaQueryInfoTrustedDomain(IN LSA_HANDLE TrustedDomainHandle
,
1379 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1382 FIXME("LsaQueryInfoTrustedDomain(%p %d %p) stub\n",
1383 TrustedDomainHandle
, InformationClass
, Buffer
);
1384 return STATUS_NOT_IMPLEMENTED
;
1393 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1394 IN POLICY_INFORMATION_CLASS InformationClass
,
1397 PLSAPR_POLICY_INFORMATION PolicyInformation
= NULL
;
1400 TRACE("LsaQueryInformationPolicy(%p %d %p)\n",
1401 PolicyHandle
, InformationClass
, Buffer
);
1405 Status
= LsarQueryInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1407 &PolicyInformation
);
1408 *Buffer
= PolicyInformation
;
1410 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1412 if (PolicyInformation
!= NULL
)
1413 MIDL_user_free(PolicyInformation
);
1415 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1419 TRACE("Done (Status: 0x%08x)\n", Status
);
1430 LsaQuerySecret(IN LSA_HANDLE SecretHandle
,
1431 OUT PLSA_UNICODE_STRING
*CurrentValue OPTIONAL
,
1432 OUT PLARGE_INTEGER CurrentValueSetTime OPTIONAL
,
1433 OUT PLSA_UNICODE_STRING
*OldValue OPTIONAL
,
1434 OUT PLARGE_INTEGER OldValueSetTime OPTIONAL
)
1436 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue
= NULL
;
1437 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue
= NULL
;
1438 PLSA_UNICODE_STRING DecryptedCurrentValue
= NULL
;
1439 PLSA_UNICODE_STRING DecryptedOldValue
= NULL
;
1443 TRACE("LsaQuerySecret(%p %p %p %p %p)\n",
1444 SecretHandle
, CurrentValue
, CurrentValueSetTime
,
1445 OldValue
, OldValueSetTime
);
1449 Status
= LsarQuerySecret((PLSAPR_HANDLE
)SecretHandle
,
1450 &EncryptedCurrentValue
,
1451 CurrentValueSetTime
,
1455 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1457 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1461 if (!NT_SUCCESS(Status
))
1464 /* Decrypt the current value */
1465 if (CurrentValue
!= NULL
)
1467 if (EncryptedCurrentValue
== NULL
)
1469 *CurrentValue
= NULL
;
1473 /* FIXME: Decrypt the current value */
1474 BufferSize
= sizeof(LSA_UNICODE_STRING
) + EncryptedCurrentValue
->MaximumLength
;
1475 DecryptedCurrentValue
= midl_user_allocate(BufferSize
);
1476 if (DecryptedCurrentValue
== NULL
)
1478 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1482 DecryptedCurrentValue
->Length
= (USHORT
)EncryptedCurrentValue
->Length
;
1483 DecryptedCurrentValue
->MaximumLength
= (USHORT
)EncryptedCurrentValue
->MaximumLength
;
1484 DecryptedCurrentValue
->Buffer
= (PWSTR
)(DecryptedCurrentValue
+ 1);
1485 RtlCopyMemory(DecryptedCurrentValue
->Buffer
,
1486 EncryptedCurrentValue
->Buffer
,
1487 EncryptedCurrentValue
->Length
);
1489 *CurrentValue
= DecryptedCurrentValue
;
1493 /* Decrypt the old value */
1494 if (OldValue
!= NULL
)
1496 if (EncryptedOldValue
== NULL
)
1502 /* FIXME: Decrypt the old value */
1503 BufferSize
= sizeof(LSA_UNICODE_STRING
) + EncryptedOldValue
->MaximumLength
;
1504 DecryptedOldValue
= midl_user_allocate(BufferSize
);
1505 if (DecryptedOldValue
== NULL
)
1507 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1511 DecryptedOldValue
->Length
= (USHORT
)EncryptedOldValue
->Length
;
1512 DecryptedOldValue
->MaximumLength
= (USHORT
)EncryptedOldValue
->MaximumLength
;
1513 DecryptedOldValue
->Buffer
= (PWSTR
)(DecryptedOldValue
+ 1);
1514 RtlCopyMemory(DecryptedOldValue
->Buffer
,
1515 EncryptedOldValue
->Buffer
,
1516 EncryptedOldValue
->Length
);
1518 *OldValue
= DecryptedOldValue
;
1523 if (!NT_SUCCESS(Status
))
1525 if (DecryptedCurrentValue
!= NULL
)
1526 midl_user_free(DecryptedCurrentValue
);
1528 if (DecryptedOldValue
!= NULL
)
1529 midl_user_free(DecryptedOldValue
);
1531 if (CurrentValue
!= NULL
)
1532 *CurrentValue
= NULL
;
1534 if (OldValue
!= NULL
)
1538 if (EncryptedCurrentValue
!= NULL
)
1539 midl_user_free(EncryptedCurrentValue
);
1541 if (EncryptedOldValue
!= NULL
)
1542 midl_user_free(EncryptedOldValue
);
1553 LsaQuerySecurityObject(IN LSA_HANDLE ObjectHandle
,
1554 IN SECURITY_INFORMATION SecurityInformation
,
1555 OUT PSECURITY_DESCRIPTOR
*SecurityDescriptor
)
1557 LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer
;
1558 PLSAPR_SR_SECURITY_DESCRIPTOR SdPointer
;
1561 TRACE("LsaQuerySecurityObject(%p %lx %p)\n",
1562 ObjectHandle
, SecurityInformation
, SecurityDescriptor
);
1564 SdBuffer
.Length
= 0;
1565 SdBuffer
.SecurityDescriptor
= NULL
;
1567 SdPointer
= &SdBuffer
;
1571 Status
= LsarQuerySecurityObject((LSAPR_HANDLE
)ObjectHandle
,
1572 SecurityInformation
,
1574 if (NT_SUCCESS(Status
))
1576 *SecurityDescriptor
= SdBuffer
.SecurityDescriptor
;
1580 *SecurityDescriptor
= NULL
;
1583 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1585 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1598 LsaQueryTrustedDomainInfo(IN LSA_HANDLE PolicyHandle
,
1599 IN PSID TrustedDomainSid
,
1600 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1603 FIXME("LsaQueryTrustedDomainInfo(%p %p %d %p) stub\n",
1604 PolicyHandle
, TrustedDomainSid
, InformationClass
, Buffer
);
1605 return STATUS_OBJECT_NAME_NOT_FOUND
;
1614 LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle
,
1615 IN PLSA_UNICODE_STRING TrustedDomainName
,
1616 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1621 TRACE("LsaQueryTrustedDomainInfoByName(%p %p %d %p)\n",
1622 PolicyHandle
, TrustedDomainName
, InformationClass
, Buffer
);
1624 if (InformationClass
== TrustedDomainAuthInformationInternal
||
1625 InformationClass
== TrustedDomainFullInformationInternal
)
1626 return STATUS_INVALID_INFO_CLASS
;
1630 Status
= LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE
)PolicyHandle
,
1631 (PRPC_UNICODE_STRING
)TrustedDomainName
,
1633 (PLSAPR_TRUSTED_DOMAIN_INFO
*)Buffer
);
1635 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1637 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1650 LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle
,
1652 IN BOOLEAN AllRights
,
1653 IN PLSA_UNICODE_STRING UserRights
,
1654 IN ULONG CountOfRights
)
1657 LSAPR_USER_RIGHT_SET UserRightSet
;
1659 TRACE("LsaRemoveAccountRights(%p %p %d %p %lu)\n",
1660 PolicyHandle
, AccountSid
, AllRights
, UserRights
, CountOfRights
);
1662 UserRightSet
.Entries
= CountOfRights
;
1663 UserRightSet
.UserRights
= (PRPC_UNICODE_STRING
)UserRights
;
1667 Status
= LsarRemoveAccountRights((LSAPR_HANDLE
)PolicyHandle
,
1668 (PRPC_SID
)AccountSid
,
1672 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1674 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1687 LsaRemovePrivilegesFromAccount(IN LSA_HANDLE AccountHandle
,
1688 IN BOOLEAN AllPrivileges
,
1689 IN PPRIVILEGE_SET Privileges OPTIONAL
)
1695 Status
= LsarRemovePrivilegesFromAccount((LSAPR_HANDLE
)AccountHandle
,
1697 (PLSAPR_PRIVILEGE_SET
)Privileges
);
1699 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1701 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1714 LsaRetrievePrivateData(IN LSA_HANDLE PolicyHandle
,
1715 IN PLSA_UNICODE_STRING KeyName
,
1716 OUT PLSA_UNICODE_STRING
*PrivateData
)
1718 PLSAPR_CR_CIPHER_VALUE EncryptedData
= NULL
;
1719 PLSA_UNICODE_STRING DecryptedData
= NULL
;
1723 TRACE("LsaRetrievePrivateData(%p %p %p)\n",
1724 PolicyHandle
, KeyName
, PrivateData
);
1728 Status
= LsarRetrievePrivateData((LSAPR_HANDLE
)PolicyHandle
,
1729 (PRPC_UNICODE_STRING
)KeyName
,
1732 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1734 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1738 if (EncryptedData
== NULL
)
1740 *PrivateData
= NULL
;
1744 BufferSize
= sizeof(LSA_UNICODE_STRING
) + EncryptedData
->MaximumLength
;
1745 DecryptedData
= midl_user_allocate(BufferSize
);
1746 if (DecryptedData
== NULL
)
1748 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1752 DecryptedData
->Length
= (USHORT
)EncryptedData
->Length
;
1753 DecryptedData
->MaximumLength
= (USHORT
)EncryptedData
->MaximumLength
;
1754 DecryptedData
->Buffer
= (PWSTR
)(DecryptedData
+ 1);
1755 RtlCopyMemory(DecryptedData
->Buffer
,
1756 EncryptedData
->Buffer
,
1757 EncryptedData
->Length
);
1759 *PrivateData
= DecryptedData
;
1763 if (!NT_SUCCESS(Status
))
1765 if (DecryptedData
!= NULL
)
1766 midl_user_free(DecryptedData
);
1768 *PrivateData
= NULL
;
1771 if (EncryptedData
!= NULL
)
1772 midl_user_free(EncryptedData
);
1783 LsaSetDomainInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1784 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass
,
1785 IN PVOID Buffer OPTIONAL
)
1789 TRACE("LsaSetDomainInformationPolicy(%p %d %p)\n",
1790 PolicyHandle
, InformationClass
, Buffer
);
1794 Status
= LsarSetDomainInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1796 (PLSAPR_POLICY_DOMAIN_INFORMATION
)Buffer
);
1798 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1800 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1813 LsaSetForestTrustInformation(IN LSA_HANDLE PolicyHandle
,
1814 IN PLSA_UNICODE_STRING TrustedDomainName
,
1815 IN PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo
,
1816 IN BOOLEAN CheckOnly
,
1817 OUT PLSA_FOREST_TRUST_COLLISION_INFORMATION
*CollisionInfo
)
1821 TRACE("LsaSetForestTrustInformation(%p %p %p %d %p)\n",
1822 PolicyHandle
, TrustedDomainName
, ForestTrustInfo
, CheckOnly
, CollisionInfo
);
1826 Status
= LsarSetForestTrustInformation((LSAPR_HANDLE
)PolicyHandle
,
1828 ForestTrustDomainInfo
,
1833 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1835 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1848 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1849 IN POLICY_INFORMATION_CLASS InformationClass
,
1854 TRACE("LsaSetInformationPolicy(%p %d %p)\n",
1855 PolicyHandle
, InformationClass
, Buffer
);
1859 Status
= LsarSetInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1861 (PLSAPR_POLICY_INFORMATION
)Buffer
);
1863 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1865 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1878 LsaSetInformationTrustedDomain(IN LSA_HANDLE TrustedDomainHandle
,
1879 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1882 FIXME("LsaSetInformationTrustedDomain(%p %d %p)\n",
1883 TrustedDomainHandle
, InformationClass
, Buffer
);
1884 return STATUS_NOT_IMPLEMENTED
;
1893 LsaSetQuotasForAccount(IN LSA_HANDLE AccountHandle
,
1894 IN PQUOTA_LIMITS QuotaLimits
)
1898 TRACE("LsaSetQuotasForAccount(%p %p)\n",
1899 AccountHandle
, QuotaLimits
);
1903 Status
= LsarSetQuotasForAccount((LSAPR_HANDLE
)AccountHandle
,
1906 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1908 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1921 LsaSetSecret(IN LSA_HANDLE SecretHandle
,
1922 IN PLSA_UNICODE_STRING CurrentValue OPTIONAL
,
1923 IN PLSA_UNICODE_STRING OldValue OPTIONAL
)
1925 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue
= NULL
;
1926 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue
= NULL
;
1930 TRACE("LsaSetSecret(%p %p %p)\n",
1931 SecretHandle
, EncryptedCurrentValue
, EncryptedOldValue
);
1933 if (CurrentValue
!= NULL
)
1935 BufferSize
= sizeof(LSAPR_CR_CIPHER_VALUE
) + CurrentValue
->MaximumLength
;
1936 EncryptedCurrentValue
= midl_user_allocate(BufferSize
);
1937 if (EncryptedCurrentValue
== NULL
)
1939 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1943 EncryptedCurrentValue
->Length
= CurrentValue
->Length
;
1944 EncryptedCurrentValue
->MaximumLength
= CurrentValue
->MaximumLength
;
1945 EncryptedCurrentValue
->Buffer
= (BYTE
*)(EncryptedCurrentValue
+ 1);
1946 if (EncryptedCurrentValue
->Buffer
!= NULL
)
1947 memcpy(EncryptedCurrentValue
->Buffer
, CurrentValue
->Buffer
, CurrentValue
->Length
);
1950 if (OldValue
!= NULL
)
1952 BufferSize
= sizeof(LSAPR_CR_CIPHER_VALUE
) + OldValue
->MaximumLength
;
1953 EncryptedOldValue
= midl_user_allocate(BufferSize
);
1954 if (EncryptedOldValue
== NULL
)
1956 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1960 EncryptedOldValue
->Length
= OldValue
->Length
;
1961 EncryptedOldValue
->MaximumLength
= OldValue
->MaximumLength
;
1962 EncryptedOldValue
->Buffer
= (BYTE
*)(EncryptedOldValue
+ 1);
1963 if (EncryptedOldValue
->Buffer
!= NULL
)
1964 memcpy(EncryptedOldValue
->Buffer
, OldValue
->Buffer
, OldValue
->Length
);
1969 Status
= LsarSetSecret((LSAPR_HANDLE
)SecretHandle
,
1970 EncryptedCurrentValue
,
1973 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1975 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1980 if (EncryptedCurrentValue
!= NULL
)
1981 midl_user_free(EncryptedCurrentValue
);
1983 if (EncryptedOldValue
!= NULL
)
1984 midl_user_free(EncryptedOldValue
);
1995 LsaSetSecurityObject(IN LSA_HANDLE ObjectHandle
,
1996 IN SECURITY_INFORMATION SecurityInformation
,
1997 IN PSECURITY_DESCRIPTOR SecurityDescriptor
)
1999 LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer
= {0, NULL
};
2003 TRACE("LsaSetSecurityObject(%p %lx %p)\n",
2004 ObjectHandle
, SecurityInformation
, SecurityDescriptor
);
2006 Status
= RtlMakeSelfRelativeSD(SecurityDescriptor
,
2009 if (Status
!= STATUS_BUFFER_TOO_SMALL
)
2010 return STATUS_INVALID_PARAMETER
;
2012 SdBuffer
.SecurityDescriptor
= MIDL_user_allocate(SdLength
);
2013 if (SdBuffer
.SecurityDescriptor
== NULL
)
2014 return STATUS_INSUFFICIENT_RESOURCES
;
2016 Status
= RtlMakeSelfRelativeSD(SecurityDescriptor
,
2017 (PSECURITY_DESCRIPTOR
)SdBuffer
.SecurityDescriptor
,
2019 if (!NT_SUCCESS(Status
))
2022 SdBuffer
.Length
= SdLength
;
2026 Status
= LsarSetSecurityObject((LSAPR_HANDLE
)ObjectHandle
,
2027 SecurityInformation
,
2030 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
2032 Status
= I_RpcMapWin32Status(RpcExceptionCode());
2037 if (SdBuffer
.SecurityDescriptor
!= NULL
)
2038 MIDL_user_free(SdBuffer
.SecurityDescriptor
);
2049 LsaSetSystemAccessAccount(IN LSA_HANDLE AccountHandle
,
2050 IN ULONG SystemAccess
)
2054 TRACE("LsaSetSystemAccessAccount(%p 0x%lx)\n",
2055 AccountHandle
, SystemAccess
);
2059 Status
= LsarSetSystemAccessAccount((LSAPR_HANDLE
)AccountHandle
,
2062 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
2064 Status
= I_RpcMapWin32Status(RpcExceptionCode());
2077 LsaSetTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle
,
2078 IN PLSA_UNICODE_STRING TrustedDomainName
,
2079 IN TRUSTED_INFORMATION_CLASS InformationClass
,
2082 FIXME("LsaSetTrustedDomainInfoByName(%p %p %d %p) stub\n",
2083 PolicyHandle
, TrustedDomainName
, InformationClass
, Buffer
);
2084 return STATUS_SUCCESS
;
2093 LsaSetTrustedDomainInformation(IN LSA_HANDLE PolicyHandle
,
2094 IN PSID TrustedDomainSid
,
2095 IN TRUSTED_INFORMATION_CLASS InformationClass
,
2098 FIXME("LsaSetTrustedDomainInformation(%p %p %d %p) stub\n",
2099 PolicyHandle
, TrustedDomainSid
, InformationClass
, Buffer
);
2100 return STATUS_SUCCESS
;
2109 LsaStorePrivateData(IN LSA_HANDLE PolicyHandle
,
2110 IN PLSA_UNICODE_STRING KeyName
,
2111 IN PLSA_UNICODE_STRING PrivateData OPTIONAL
)
2113 PLSAPR_CR_CIPHER_VALUE EncryptedData
= NULL
;
2117 TRACE("LsaStorePrivateData(%p %p %p)\n",
2118 PolicyHandle
, KeyName
, PrivateData
);
2120 if (PrivateData
!= NULL
)
2122 BufferSize
= sizeof(LSAPR_CR_CIPHER_VALUE
) + PrivateData
->MaximumLength
;
2123 EncryptedData
= midl_user_allocate(BufferSize
);
2124 if (EncryptedData
== NULL
)
2126 Status
= STATUS_INSUFFICIENT_RESOURCES
;
2130 EncryptedData
->Length
= PrivateData
->Length
;
2131 EncryptedData
->MaximumLength
= PrivateData
->MaximumLength
;
2132 EncryptedData
->Buffer
= (BYTE
*)(EncryptedData
+ 1);
2133 if (EncryptedData
->Buffer
!= NULL
)
2134 RtlCopyMemory(EncryptedData
->Buffer
,
2135 PrivateData
->Buffer
,
2136 PrivateData
->Length
);
2141 Status
= LsarStorePrivateData((LSAPR_HANDLE
)PolicyHandle
,
2142 (PRPC_UNICODE_STRING
)KeyName
,
2145 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
2147 Status
= I_RpcMapWin32Status(RpcExceptionCode());
2152 if (EncryptedData
!= NULL
)
2153 midl_user_free(EncryptedData
);