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
16 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 PSHORT LanguageReturned
)
911 FIXME("LsaLookupPrivilegeDisplayName(%p %p %p %p)\n",
912 PolicyHandle
, Name
, DisplayName
, LanguageReturned
);
913 return STATUS_NOT_IMPLEMENTED
;
922 LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle
,
924 OUT PUNICODE_STRING
*Name
)
926 PRPC_UNICODE_STRING NameBuffer
= NULL
;
929 TRACE("LsaLookupPrivilegeName(%p %p %p)\n",
930 PolicyHandle
, Value
, Name
);
934 Status
= LsarLookupPrivilegeName(PolicyHandle
,
938 *Name
= (PUNICODE_STRING
)NameBuffer
;
940 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
942 if (NameBuffer
!= NULL
)
943 MIDL_user_free(NameBuffer
);
945 Status
= I_RpcMapWin32Status(RpcExceptionCode());
958 LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle
,
959 IN PLSA_UNICODE_STRING Name
,
965 TRACE("LsaLookupPrivilegeValue(%p %p %p)\n",
966 PolicyHandle
, Name
, Value
);
970 Status
= LsarLookupPrivilegeValue(PolicyHandle
,
971 (PRPC_UNICODE_STRING
)Name
,
973 if (Status
== STATUS_SUCCESS
)
976 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
978 Status
= I_RpcMapWin32Status(RpcExceptionCode());
991 LsaLookupSids(IN LSA_HANDLE PolicyHandle
,
994 OUT PLSA_REFERENCED_DOMAIN_LIST
*ReferencedDomains
,
995 OUT PLSA_TRANSLATED_NAME
*Names
)
997 LSAPR_SID_ENUM_BUFFER SidEnumBuffer
;
998 LSAPR_TRANSLATED_NAMES TranslatedNames
;
999 ULONG MappedCount
= 0;
1002 TRACE("LsaLookupSids(%p %lu %p %p %p)\n",
1003 PolicyHandle
, Count
, Sids
, ReferencedDomains
, Names
);
1006 return STATUS_INVALID_PARAMETER
;
1008 SidEnumBuffer
.Entries
= Count
;
1009 SidEnumBuffer
.SidInfo
= (PLSAPR_SID_INFORMATION
)Sids
;
1013 *ReferencedDomains
= NULL
;
1016 TranslatedNames
.Entries
= 0;
1017 TranslatedNames
.Names
= NULL
;
1019 Status
= LsarLookupSids((LSAPR_HANDLE
)PolicyHandle
,
1021 (PLSAPR_REFERENCED_DOMAIN_LIST
*)ReferencedDomains
,
1026 *Names
= (PLSA_TRANSLATED_NAME
)TranslatedNames
.Names
;
1028 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1030 if (TranslatedNames
.Names
!= NULL
)
1032 MIDL_user_free(TranslatedNames
.Names
);
1035 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1043 /******************************************************************************
1044 * LsaNtStatusToWinError
1053 LsaNtStatusToWinError(IN NTSTATUS Status
)
1055 TRACE("LsaNtStatusToWinError(0x%lx)\n", Status
);
1056 return RtlNtStatusToDosError(Status
);
1065 LsaOpenAccount(IN LSA_HANDLE PolicyHandle
,
1067 IN ACCESS_MASK DesiredAccess
,
1068 OUT PLSA_HANDLE AccountHandle
)
1072 TRACE("LsaOpenAccount(%p %p 0x%08lx %p)\n",
1073 PolicyHandle
, AccountSid
, DesiredAccess
, AccountHandle
);
1077 Status
= LsarOpenAccount((LSAPR_HANDLE
)PolicyHandle
,
1082 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1084 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1092 /******************************************************************************
1105 LsaOpenPolicy(IN PLSA_UNICODE_STRING SystemName OPTIONAL
,
1106 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes
,
1107 IN ACCESS_MASK DesiredAccess
,
1108 OUT PLSA_HANDLE PolicyHandle
)
1112 TRACE("LsaOpenPolicy(%s %p 0x%08lx %p)\n",
1113 SystemName
? debugstr_w(SystemName
->Buffer
) : "(null)",
1114 ObjectAttributes
, DesiredAccess
, PolicyHandle
);
1116 /* FIXME: RPC should take care of this */
1117 if (!LsapIsLocalComputer(SystemName
))
1118 return RPC_NT_SERVER_UNAVAILABLE
;
1122 *PolicyHandle
= NULL
;
1124 Status
= LsarOpenPolicy(SystemName
? SystemName
->Buffer
: NULL
,
1125 (PLSAPR_OBJECT_ATTRIBUTES
)ObjectAttributes
,
1129 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1131 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1135 TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status
);
1146 LsaOpenPolicySce(IN PLSA_UNICODE_STRING SystemName OPTIONAL
,
1147 IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes
,
1148 IN ACCESS_MASK DesiredAccess
,
1149 OUT PLSA_HANDLE PolicyHandle
)
1151 FIXME("LsaOpenPolicySce(%s %p 0x%08lx %p)\n",
1152 SystemName
? debugstr_w(SystemName
->Buffer
) : "(null)",
1153 ObjectAttributes
, DesiredAccess
, PolicyHandle
);
1154 return STATUS_NOT_IMPLEMENTED
;
1163 LsaOpenSecret(IN LSA_HANDLE PolicyHandle
,
1164 IN PLSA_UNICODE_STRING SecretName
,
1165 IN ACCESS_MASK DesiredAccess
,
1166 OUT PLSA_HANDLE SecretHandle
)
1170 TRACE("LsaOpenSecret(%p %p 0x%08lx %p)\n",
1171 PolicyHandle
, SecretName
, DesiredAccess
, SecretHandle
);
1175 *SecretHandle
= NULL
;
1177 Status
= LsarOpenSecret((LSAPR_HANDLE
)PolicyHandle
,
1178 (PRPC_UNICODE_STRING
)SecretName
,
1182 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1184 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1188 TRACE("LsaOpenSecret() done (Status: 0x%08lx)\n", Status
);
1199 LsaOpenTrustedDomain(IN LSA_HANDLE PolicyHandle
,
1200 IN PSID TrustedDomainSid
,
1201 IN ACCESS_MASK DesiredAccess
,
1202 OUT PLSA_HANDLE TrustedDomainHandle
)
1206 TRACE("LsaOpenTrustedDomain(%p %p 0x%08lx %p)\n",
1207 PolicyHandle
, TrustedDomainSid
, DesiredAccess
, TrustedDomainHandle
);
1211 Status
= LsarOpenTrustedDomain((LSAPR_HANDLE
)PolicyHandle
,
1212 (PRPC_SID
)TrustedDomainSid
,
1214 (PLSAPR_HANDLE
)TrustedDomainHandle
);
1216 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1218 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1231 LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle
,
1232 IN PLSA_UNICODE_STRING TrustedDomainName
,
1233 IN ACCESS_MASK DesiredAccess
,
1234 OUT PLSA_HANDLE TrustedDomainHandle
)
1238 TRACE("LsaOpenTrustedDomainByName(%p %p 0x%08lx %p)\n",
1239 PolicyHandle
, TrustedDomainName
, DesiredAccess
, TrustedDomainHandle
);
1243 Status
= LsarOpenTrustedDomainByName((LSAPR_HANDLE
)PolicyHandle
,
1244 (PRPC_UNICODE_STRING
)TrustedDomainName
,
1246 TrustedDomainHandle
);
1248 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1250 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1263 LsaQueryDomainInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1264 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass
,
1267 PLSAPR_POLICY_DOMAIN_INFORMATION PolicyInformation
= NULL
;
1270 TRACE("LsaQueryDomainInformationPolicy(%p %lu %p)\n",
1271 PolicyHandle
, InformationClass
, Buffer
);
1275 Status
= LsarQueryDomainInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1277 &PolicyInformation
);
1279 *Buffer
= PolicyInformation
;
1281 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1283 if (PolicyInformation
!= NULL
)
1284 MIDL_user_free(PolicyInformation
);
1286 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1299 LsaQueryForestTrustInformation(IN LSA_HANDLE PolicyHandle
,
1300 IN PLSA_UNICODE_STRING TrustedDomainName
,
1301 OUT PLSA_FOREST_TRUST_INFORMATION
*ForestTrustInfo
)
1305 TRACE("LsaQueryForestTrustInformation(%p %p %p)\n",
1306 PolicyHandle
, TrustedDomainName
, ForestTrustInfo
);
1310 Status
= LsarQueryForestTrustInformation((LSAPR_HANDLE
)PolicyHandle
,
1312 ForestTrustDomainInfo
,
1315 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1317 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1330 LsaQueryInfoTrustedDomain(IN LSA_HANDLE TrustedDomainHandle
,
1331 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1334 FIXME("LsaQueryInfoTrustedDomain(%p %d %p) stub\n",
1335 TrustedDomainHandle
, InformationClass
, Buffer
);
1336 return STATUS_NOT_IMPLEMENTED
;
1345 LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1346 IN POLICY_INFORMATION_CLASS InformationClass
,
1349 PLSAPR_POLICY_INFORMATION PolicyInformation
= NULL
;
1352 TRACE("LsaQueryInformationPolicy(%p %d %p)\n",
1353 PolicyHandle
, InformationClass
, Buffer
);
1357 Status
= LsarQueryInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1359 &PolicyInformation
);
1360 *Buffer
= PolicyInformation
;
1362 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1364 if (PolicyInformation
!= NULL
)
1365 MIDL_user_free(PolicyInformation
);
1367 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1371 TRACE("Done (Status: 0x%08x)\n", Status
);
1382 LsaQuerySecret(IN LSA_HANDLE SecretHandle
,
1383 OUT PLSA_UNICODE_STRING
*CurrentValue OPTIONAL
,
1384 OUT PLARGE_INTEGER CurrentValueSetTime OPTIONAL
,
1385 OUT PLSA_UNICODE_STRING
*OldValue OPTIONAL
,
1386 OUT PLARGE_INTEGER OldValueSetTime OPTIONAL
)
1388 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue
= NULL
;
1389 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue
= NULL
;
1390 PLSA_UNICODE_STRING DecryptedCurrentValue
= NULL
;
1391 PLSA_UNICODE_STRING DecryptedOldValue
= NULL
;
1395 TRACE("LsaQuerySecret(%p %p %p %p %p)\n",
1396 SecretHandle
, CurrentValue
, CurrentValueSetTime
,
1397 OldValue
, OldValueSetTime
);
1401 Status
= LsarQuerySecret((PLSAPR_HANDLE
)SecretHandle
,
1402 &EncryptedCurrentValue
,
1403 CurrentValueSetTime
,
1407 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1409 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1413 if (!NT_SUCCESS(Status
))
1416 /* Decrypt the current value */
1417 if (CurrentValue
!= NULL
)
1419 if (EncryptedCurrentValue
== NULL
)
1421 *CurrentValue
= NULL
;
1425 /* FIXME: Decrypt the current value */
1426 BufferSize
= sizeof(LSA_UNICODE_STRING
) + EncryptedCurrentValue
->MaximumLength
;
1427 DecryptedCurrentValue
= midl_user_allocate(BufferSize
);
1428 if (DecryptedCurrentValue
== NULL
)
1430 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1434 DecryptedCurrentValue
->Length
= (USHORT
)EncryptedCurrentValue
->Length
;
1435 DecryptedCurrentValue
->MaximumLength
= (USHORT
)EncryptedCurrentValue
->MaximumLength
;
1436 DecryptedCurrentValue
->Buffer
= (PWSTR
)(DecryptedCurrentValue
+ 1);
1437 RtlCopyMemory(DecryptedCurrentValue
->Buffer
,
1438 EncryptedCurrentValue
->Buffer
,
1439 EncryptedCurrentValue
->Length
);
1441 *CurrentValue
= DecryptedCurrentValue
;
1445 /* Decrypt the old value */
1446 if (OldValue
!= NULL
)
1448 if (EncryptedOldValue
== NULL
)
1454 /* FIXME: Decrypt the old value */
1455 BufferSize
= sizeof(LSA_UNICODE_STRING
) + EncryptedOldValue
->MaximumLength
;
1456 DecryptedOldValue
= midl_user_allocate(BufferSize
);
1457 if (DecryptedOldValue
== NULL
)
1459 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1463 DecryptedOldValue
->Length
= (USHORT
)EncryptedOldValue
->Length
;
1464 DecryptedOldValue
->MaximumLength
= (USHORT
)EncryptedOldValue
->MaximumLength
;
1465 DecryptedOldValue
->Buffer
= (PWSTR
)(DecryptedOldValue
+ 1);
1466 RtlCopyMemory(DecryptedOldValue
->Buffer
,
1467 EncryptedOldValue
->Buffer
,
1468 EncryptedOldValue
->Length
);
1470 *OldValue
= DecryptedOldValue
;
1475 if (!NT_SUCCESS(Status
))
1477 if (DecryptedCurrentValue
!= NULL
)
1478 midl_user_free(DecryptedCurrentValue
);
1480 if (DecryptedOldValue
!= NULL
)
1481 midl_user_free(DecryptedOldValue
);
1483 if (CurrentValue
!= NULL
)
1484 *CurrentValue
= NULL
;
1486 if (OldValue
!= NULL
)
1490 if (EncryptedCurrentValue
!= NULL
)
1491 midl_user_free(EncryptedCurrentValue
);
1493 if (EncryptedOldValue
!= NULL
)
1494 midl_user_free(EncryptedOldValue
);
1505 LsaQuerySecurityObject(IN LSA_HANDLE ObjectHandle
,
1506 IN SECURITY_INFORMATION SecurityInformation
,
1507 OUT PSECURITY_DESCRIPTOR
*SecurityDescriptor
)
1509 LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer
;
1510 PLSAPR_SR_SECURITY_DESCRIPTOR SdPointer
;
1513 TRACE("LsaQuerySecurityObject(%p %lx %p)\n",
1514 ObjectHandle
, SecurityInformation
, SecurityDescriptor
);
1516 SdBuffer
.Length
= 0;
1517 SdBuffer
.SecurityDescriptor
= NULL
;
1519 SdPointer
= &SdBuffer
;
1523 Status
= LsarQuerySecurityObject((LSAPR_HANDLE
)ObjectHandle
,
1524 SecurityInformation
,
1526 if (NT_SUCCESS(Status
))
1528 *SecurityDescriptor
= SdBuffer
.SecurityDescriptor
;
1532 *SecurityDescriptor
= NULL
;
1535 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1537 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1550 LsaQueryTrustedDomainInfo(IN LSA_HANDLE PolicyHandle
,
1551 IN PSID TrustedDomainSid
,
1552 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1555 FIXME("LsaQueryTrustedDomainInfo(%p %p %d %p) stub\n",
1556 PolicyHandle
, TrustedDomainSid
, InformationClass
, Buffer
);
1557 return STATUS_OBJECT_NAME_NOT_FOUND
;
1566 LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle
,
1567 IN PLSA_UNICODE_STRING TrustedDomainName
,
1568 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1573 TRACE("LsaQueryTrustedDomainInfoByName(%p %p %d %p)\n",
1574 PolicyHandle
, TrustedDomainName
, InformationClass
, Buffer
);
1576 if (InformationClass
== TrustedDomainAuthInformationInternal
||
1577 InformationClass
== TrustedDomainFullInformationInternal
)
1578 return STATUS_INVALID_INFO_CLASS
;
1582 Status
= LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE
)PolicyHandle
,
1583 (PRPC_UNICODE_STRING
)TrustedDomainName
,
1585 (PLSAPR_TRUSTED_DOMAIN_INFO
*)Buffer
);
1587 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1589 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1602 LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle
,
1604 IN BOOLEAN AllRights
,
1605 IN PLSA_UNICODE_STRING UserRights
,
1606 IN ULONG CountOfRights
)
1608 LSAPR_USER_RIGHT_SET UserRightSet
;
1610 TRACE("LsaRemoveAccountRights(%p %p %d %p %lu)\n",
1611 PolicyHandle
, AccountSid
, AllRights
, UserRights
, CountOfRights
);
1613 UserRightSet
.Entries
= CountOfRights
;
1614 UserRightSet
.UserRights
= (PRPC_UNICODE_STRING
)UserRights
;
1618 LsarRemoveAccountRights((LSAPR_HANDLE
)PolicyHandle
,
1619 (PRPC_SID
)AccountSid
,
1623 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1625 I_RpcMapWin32Status(RpcExceptionCode());
1629 return STATUS_SUCCESS
;
1638 LsaRemovePrivilegesFromAccount(IN LSA_HANDLE AccountHandle
,
1639 IN BOOLEAN AllPrivileges
,
1640 IN PPRIVILEGE_SET Privileges OPTIONAL
)
1646 Status
= LsarRemovePrivilegesFromAccount((LSAPR_HANDLE
)AccountHandle
,
1648 (PLSAPR_PRIVILEGE_SET
)Privileges
);
1650 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1652 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1665 LsaRetrievePrivateData(IN LSA_HANDLE PolicyHandle
,
1666 IN PLSA_UNICODE_STRING KeyName
,
1667 OUT PLSA_UNICODE_STRING
*PrivateData
)
1669 FIXME("LsaRetrievePrivateData(%p %p %p) stub\n",
1670 PolicyHandle
, KeyName
, PrivateData
);
1671 return STATUS_OBJECT_NAME_NOT_FOUND
;
1680 LsaSetDomainInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1681 IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass
,
1682 IN PVOID Buffer OPTIONAL
)
1686 TRACE("LsaSetDomainInformationPolicy(%p %d %p)\n",
1687 PolicyHandle
, InformationClass
, Buffer
);
1691 Status
= LsarSetDomainInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1693 (PLSAPR_POLICY_DOMAIN_INFORMATION
)Buffer
);
1695 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1697 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1710 LsaSetForestTrustInformation(IN LSA_HANDLE PolicyHandle
,
1711 IN PLSA_UNICODE_STRING TrustedDomainName
,
1712 IN PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo
,
1714 OUT PLSA_FOREST_TRUST_COLLISION_INFORMATION
*CollisionInfo
)
1718 TRACE("LsaSetForestTrustInformation(%p %p %p %d %p)\n",
1719 PolicyHandle
, TrustedDomainName
, ForestTrustInfo
, CheckOnly
, CollisionInfo
);
1723 Status
= LsarSetForestTrustInformation((LSAPR_HANDLE
)PolicyHandle
,
1725 ForestTrustDomainInfo
,
1730 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1732 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1745 LsaSetInformationPolicy(IN LSA_HANDLE PolicyHandle
,
1746 IN POLICY_INFORMATION_CLASS InformationClass
,
1751 TRACE("LsaSetInformationPolicy(%p %d %p)\n",
1752 PolicyHandle
, InformationClass
, Buffer
);
1756 Status
= LsarSetInformationPolicy((LSAPR_HANDLE
)PolicyHandle
,
1758 (PLSAPR_POLICY_INFORMATION
)Buffer
);
1760 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1762 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1775 LsaSetInformationTrustedDomain(IN LSA_HANDLE TrustedDomainHandle
,
1776 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1779 FIXME("LsaSetInformationTrustedDomain(%p %d %p)\n",
1780 TrustedDomainHandle
, InformationClass
, Buffer
);
1781 return STATUS_NOT_IMPLEMENTED
;
1790 LsaSetQuotasForAccount(IN LSA_HANDLE AccountHandle
,
1791 IN PQUOTA_LIMITS QuotaLimits
)
1795 TRACE("LsaSetQuotasForAccount(%p %p)\n",
1796 AccountHandle
, QuotaLimits
);
1800 Status
= LsarSetQuotasForAccount((LSAPR_HANDLE
)AccountHandle
,
1803 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1805 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1818 LsaSetSecret(IN LSA_HANDLE SecretHandle
,
1819 IN PLSA_UNICODE_STRING CurrentValue OPTIONAL
,
1820 IN PLSA_UNICODE_STRING OldValue OPTIONAL
)
1822 PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue
= NULL
;
1823 PLSAPR_CR_CIPHER_VALUE EncryptedOldValue
= NULL
;
1827 TRACE("LsaSetSecret(%p %p %p)\n",
1828 SecretHandle
, EncryptedCurrentValue
, EncryptedOldValue
);
1830 if (CurrentValue
!= NULL
)
1832 BufferSize
= sizeof(LSAPR_CR_CIPHER_VALUE
) + CurrentValue
->MaximumLength
;
1833 EncryptedCurrentValue
= midl_user_allocate(BufferSize
);
1834 if (EncryptedCurrentValue
== NULL
)
1836 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1840 EncryptedCurrentValue
->Length
= CurrentValue
->Length
;
1841 EncryptedCurrentValue
->MaximumLength
= CurrentValue
->MaximumLength
;
1842 EncryptedCurrentValue
->Buffer
= (BYTE
*)(EncryptedCurrentValue
+ 1);
1843 if (EncryptedCurrentValue
->Buffer
!= NULL
)
1844 memcpy(EncryptedCurrentValue
->Buffer
, CurrentValue
->Buffer
, CurrentValue
->Length
);
1847 if (OldValue
!= NULL
)
1849 BufferSize
= sizeof(LSAPR_CR_CIPHER_VALUE
) + OldValue
->MaximumLength
;
1850 EncryptedOldValue
= midl_user_allocate(BufferSize
);
1851 if (EncryptedOldValue
== NULL
)
1853 Status
= STATUS_INSUFFICIENT_RESOURCES
;
1857 EncryptedOldValue
->Length
= OldValue
->Length
;
1858 EncryptedOldValue
->MaximumLength
= OldValue
->MaximumLength
;
1859 EncryptedOldValue
->Buffer
= (BYTE
*)(EncryptedOldValue
+ 1);
1860 if (EncryptedOldValue
->Buffer
!= NULL
)
1861 memcpy(EncryptedOldValue
->Buffer
, OldValue
->Buffer
, OldValue
->Length
);
1866 Status
= LsarSetSecret((LSAPR_HANDLE
)SecretHandle
,
1867 EncryptedCurrentValue
,
1870 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1872 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1877 if (EncryptedCurrentValue
!= NULL
)
1878 midl_user_free(EncryptedCurrentValue
);
1880 if (EncryptedOldValue
!= NULL
)
1881 midl_user_free(EncryptedOldValue
);
1892 LsaSetSecurityObject(IN LSA_HANDLE ObjectHandle
,
1893 IN SECURITY_INFORMATION SecurityInformation
,
1894 IN PSECURITY_DESCRIPTOR SecurityDescriptor
)
1896 LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer
= {0, NULL
};
1900 TRACE("LsaSetSecurityObject(%p %lx %p)\n",
1901 ObjectHandle
, SecurityInformation
, SecurityDescriptor
);
1903 Status
= RtlMakeSelfRelativeSD(SecurityDescriptor
,
1906 if (Status
!= STATUS_BUFFER_TOO_SMALL
)
1907 return STATUS_INVALID_PARAMETER
;
1909 SdBuffer
.SecurityDescriptor
= MIDL_user_allocate(SdLength
);
1910 if (SdBuffer
.SecurityDescriptor
== NULL
)
1911 return STATUS_INSUFFICIENT_RESOURCES
;
1913 Status
= RtlMakeSelfRelativeSD(SecurityDescriptor
,
1914 (PSECURITY_DESCRIPTOR
)SdBuffer
.SecurityDescriptor
,
1916 if (!NT_SUCCESS(Status
))
1919 SdBuffer
.Length
= SdLength
;
1923 Status
= LsarSetSecurityObject((LSAPR_HANDLE
)ObjectHandle
,
1924 SecurityInformation
,
1927 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1929 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1934 if (SdBuffer
.SecurityDescriptor
!= NULL
)
1935 MIDL_user_free(SdBuffer
.SecurityDescriptor
);
1946 LsaSetSystemAccessAccount(IN LSA_HANDLE AccountHandle
,
1947 IN ULONG SystemAccess
)
1951 TRACE("LsaSetSystemAccessAccount(%p 0x%lx)\n",
1952 AccountHandle
, SystemAccess
);
1956 Status
= LsarSetSystemAccessAccount((LSAPR_HANDLE
)AccountHandle
,
1959 RpcExcept(EXCEPTION_EXECUTE_HANDLER
)
1961 Status
= I_RpcMapWin32Status(RpcExceptionCode());
1974 LsaSetTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle
,
1975 IN PLSA_UNICODE_STRING TrustedDomainName
,
1976 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1979 FIXME("LsaSetTrustedDomainInfoByName(%p %p %d %p) stub\n",
1980 PolicyHandle
, TrustedDomainName
, InformationClass
, Buffer
);
1981 return STATUS_SUCCESS
;
1990 LsaSetTrustedDomainInformation(IN LSA_HANDLE PolicyHandle
,
1991 IN PSID TrustedDomainSid
,
1992 IN TRUSTED_INFORMATION_CLASS InformationClass
,
1995 FIXME("LsaSetTrustedDomainInformation(%p %p %d %p) stub\n",
1996 PolicyHandle
, TrustedDomainSid
, InformationClass
, Buffer
);
1997 return STATUS_SUCCESS
;
2006 LsaStorePrivateData(IN LSA_HANDLE PolicyHandle
,
2007 IN PLSA_UNICODE_STRING KeyName
,
2008 IN PLSA_UNICODE_STRING PrivateData OPTIONAL
)
2010 FIXME("LsaStorePrivateData(%p %p %p) stub\n",
2011 PolicyHandle
, KeyName
, PrivateData
);
2012 return STATUS_OBJECT_NAME_NOT_FOUND
;