lsa.c File Reference

#include <advapi32.h>
#include <lsa_c.h>

Include dependency graph for lsa.c:

Go to the source code of this file.

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (advapi)
static BOOL	LsapIsLocalComputer (PLSA_UNICODE_STRING ServerName)
handle_t __RPC_USER	PLSAPR_SERVER_NAME_bind (PLSAPR_SERVER_NAME pszSystemName)
void __RPC_USER	PLSAPR_SERVER_NAME_unbind (PLSAPR_SERVER_NAME pszSystemName, handle_t hBinding)
NTSTATUS WINAPI	LsaAddAccountRights (IN LSA_HANDLE PolicyHandle, IN PSID AccountSid, IN PLSA_UNICODE_STRING UserRights, IN ULONG CountOfRights)
NTSTATUS WINAPI	LsaAddPrivilegesToAccount (IN LSA_HANDLE AccountHandle, IN PPRIVILEGE_SET PrivilegeSet)
NTSTATUS WINAPI	LsaClearAuditLog (IN LSA_HANDLE PolicyHandle)
NTSTATUS WINAPI	LsaClose (IN LSA_HANDLE ObjectHandle)
NTSTATUS WINAPI	LsaCreateAccount (IN LSA_HANDLE PolicyHandle, IN PSID AccountSid, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE AccountHandle)
NTSTATUS WINAPI	LsaCreateSecret (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING SecretName, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE SecretHandle)
NTSTATUS WINAPI	LsaCreateTrustedDomain (IN LSA_HANDLE PolicyHandle, IN PLSA_TRUST_INFORMATION TrustedDomainInformation, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE TrustedDomainHandle)
NTSTATUS WINAPI	LsaCreateTrustedDomainEx (IN LSA_HANDLE PolicyHandle, IN PTRUSTED_DOMAIN_INFORMATION_EX TrustedDomainInformation, IN PTRUSTED_DOMAIN_AUTH_INFORMATION AuthenticationInformation, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE TrustedDomainHandle)
NTSTATUS WINAPI	LsaDelete (IN LSA_HANDLE ObjectHandle)
NTSTATUS WINAPI	LsaDeleteTrustedDomain (IN LSA_HANDLE PolicyHandle, IN PSID TrustedDomainSid)
NTSTATUS WINAPI	LsaEnumerateAccountRights (IN LSA_HANDLE PolicyHandle, IN PSID AccountSid, OUT PLSA_UNICODE_STRING *UserRights, OUT PULONG CountOfRights)
NTSTATUS WINAPI	LsaEnumerateAccounts (IN LSA_HANDLE PolicyHandle, IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext, OUT PVOID *Buffer, IN ULONG PreferedMaximumLength, OUT PULONG CountReturned)
NTSTATUS WINAPI	LsaEnumerateAccountsWithUserRight (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING UserRight OPTIONAL, OUT PVOID *Buffer, OUT PULONG CountReturned)
NTSTATUS WINAPI	LsaEnumeratePrivileges (IN LSA_HANDLE PolicyHandle, IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext, OUT PVOID *Buffer, IN ULONG PreferedMaximumLength, OUT PULONG CountReturned)
NTSTATUS WINAPI	LsaEnumeratePrivilegesOfAccount (IN LSA_HANDLE AccountHandle, OUT PPRIVILEGE_SET *Privileges)
NTSTATUS WINAPI	LsaEnumerateTrustedDomains (IN LSA_HANDLE PolicyHandle, IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext, OUT PVOID *Buffer, IN ULONG PreferedMaximumLength, OUT PULONG CountReturned)
NTSTATUS WINAPI	LsaEnumerateTrustedDomainsEx (IN LSA_HANDLE PolicyHandle, IN OUT PLSA_ENUMERATION_HANDLE EnumerationContext, OUT PVOID *Buffer, IN ULONG PreferedMaximumLength, OUT PULONG CountReturned)
NTSTATUS WINAPI	LsaFreeMemory (IN PVOID Buffer)
NTSTATUS WINAPI	LsaGetQuotasForAccount (IN LSA_HANDLE AccountHandle, OUT PQUOTA_LIMITS QuotaLimits)
NTSTATUS WINAPI	LsaGetRemoteUserName (IN PLSA_UNICODE_STRING SystemName OPTIONAL, OUT PLSA_UNICODE_STRING *UserName, OUT PLSA_UNICODE_STRING *DomainName OPTIONAL)
NTSTATUS WINAPI	LsaGetSystemAccessAccount (IN LSA_HANDLE AccountHandle, OUT PULONG SystemAccess)
NTSTATUS WINAPI	LsaGetUserName (OUT PUNICODE_STRING *UserName, OUT PUNICODE_STRING *DomainName OPTIONAL)
NTSTATUS WINAPI	LsaLookupNames (IN LSA_HANDLE PolicyHandle, IN ULONG Count, IN PLSA_UNICODE_STRING Names, OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains, OUT PLSA_TRANSLATED_SID *Sids)
NTSTATUS WINAPI	LsaLookupNames2 (IN LSA_HANDLE PolicyHandle, IN ULONG Flags, IN ULONG Count, IN PLSA_UNICODE_STRING Names, OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains, OUT PLSA_TRANSLATED_SID2 *Sids)
NTSTATUS WINAPI	LsaLookupPrivilegeDisplayName (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING Name, OUT PLSA_UNICODE_STRING *DisplayName, OUT PUSHORT LanguageReturned)
NTSTATUS WINAPI	LsaLookupPrivilegeName (IN LSA_HANDLE PolicyHandle, IN PLUID Value, OUT PUNICODE_STRING *Name)
NTSTATUS WINAPI	LsaLookupPrivilegeValue (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING Name, OUT PLUID Value)
NTSTATUS WINAPI	LsaLookupSids (IN LSA_HANDLE PolicyHandle, IN ULONG Count, IN PSID *Sids, OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains, OUT PLSA_TRANSLATED_NAME *Names)
ULONG WINAPI	LsaNtStatusToWinError (IN NTSTATUS Status)
NTSTATUS WINAPI	LsaOpenAccount (IN LSA_HANDLE PolicyHandle, IN PSID AccountSid, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE AccountHandle)
NTSTATUS WINAPI	LsaOpenPolicy (IN PLSA_UNICODE_STRING SystemName OPTIONAL, IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE PolicyHandle)
NTSTATUS WINAPI	LsaOpenPolicySce (IN PLSA_UNICODE_STRING SystemName OPTIONAL, IN PLSA_OBJECT_ATTRIBUTES ObjectAttributes, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE PolicyHandle)
NTSTATUS WINAPI	LsaOpenSecret (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING SecretName, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE SecretHandle)
NTSTATUS WINAPI	LsaOpenTrustedDomain (IN LSA_HANDLE PolicyHandle, IN PSID TrustedDomainSid, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE TrustedDomainHandle)
NTSTATUS WINAPI	LsaOpenTrustedDomainByName (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING TrustedDomainName, IN ACCESS_MASK DesiredAccess, OUT PLSA_HANDLE TrustedDomainHandle)
NTSTATUS WINAPI	LsaQueryDomainInformationPolicy (IN LSA_HANDLE PolicyHandle, IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass, OUT PVOID *Buffer)
NTSTATUS WINAPI	LsaQueryForestTrustInformation (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING TrustedDomainName, OUT PLSA_FOREST_TRUST_INFORMATION *ForestTrustInfo)
NTSTATUS WINAPI	LsaQueryInfoTrustedDomain (IN LSA_HANDLE TrustedDomainHandle, IN TRUSTED_INFORMATION_CLASS InformationClass, OUT PVOID *Buffer)
NTSTATUS WINAPI	LsaQueryInformationPolicy (IN LSA_HANDLE PolicyHandle, IN POLICY_INFORMATION_CLASS InformationClass, OUT PVOID *Buffer)
NTSTATUS WINAPI	LsaQuerySecret (IN LSA_HANDLE SecretHandle, OUT PLSA_UNICODE_STRING *CurrentValue OPTIONAL, OUT PLARGE_INTEGER CurrentValueSetTime OPTIONAL, OUT PLSA_UNICODE_STRING *OldValue OPTIONAL, OUT PLARGE_INTEGER OldValueSetTime OPTIONAL)
NTSTATUS WINAPI	LsaQuerySecurityObject (IN LSA_HANDLE ObjectHandle, IN SECURITY_INFORMATION SecurityInformation, OUT PSECURITY_DESCRIPTOR *SecurityDescriptor)
NTSTATUS WINAPI	LsaQueryTrustedDomainInfo (IN LSA_HANDLE PolicyHandle, IN PSID TrustedDomainSid, IN TRUSTED_INFORMATION_CLASS InformationClass, OUT PVOID *Buffer)
NTSTATUS WINAPI	LsaQueryTrustedDomainInfoByName (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING TrustedDomainName, IN TRUSTED_INFORMATION_CLASS InformationClass, OUT PVOID *Buffer)
NTSTATUS WINAPI	LsaRemoveAccountRights (IN LSA_HANDLE PolicyHandle, IN PSID AccountSid, IN BOOLEAN AllRights, IN PLSA_UNICODE_STRING UserRights, IN ULONG CountOfRights)
NTSTATUS WINAPI	LsaRemovePrivilegesFromAccount (IN LSA_HANDLE AccountHandle, IN BOOLEAN AllPrivileges, IN PPRIVILEGE_SET Privileges OPTIONAL)
NTSTATUS WINAPI	LsaRetrievePrivateData (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING KeyName, OUT PLSA_UNICODE_STRING *PrivateData)
NTSTATUS WINAPI	LsaSetDomainInformationPolicy (IN LSA_HANDLE PolicyHandle, IN POLICY_DOMAIN_INFORMATION_CLASS InformationClass, IN PVOID Buffer OPTIONAL)
NTSTATUS WINAPI	LsaSetForestTrustInformation (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING TrustedDomainName, IN PLSA_FOREST_TRUST_INFORMATION ForestTrustInfo, IN BOOLEAN CheckOnly, OUT PLSA_FOREST_TRUST_COLLISION_INFORMATION *CollisionInfo)
NTSTATUS WINAPI	LsaSetInformationPolicy (IN LSA_HANDLE PolicyHandle, IN POLICY_INFORMATION_CLASS InformationClass, IN PVOID Buffer)
NTSTATUS WINAPI	LsaSetInformationTrustedDomain (IN LSA_HANDLE TrustedDomainHandle, IN TRUSTED_INFORMATION_CLASS InformationClass, IN PVOID Buffer)
NTSTATUS WINAPI	LsaSetQuotasForAccount (IN LSA_HANDLE AccountHandle, IN PQUOTA_LIMITS QuotaLimits)
NTSTATUS WINAPI	LsaSetSecret (IN LSA_HANDLE SecretHandle, IN PLSA_UNICODE_STRING CurrentValue OPTIONAL, IN PLSA_UNICODE_STRING OldValue OPTIONAL)
NTSTATUS WINAPI	LsaSetSecurityObject (IN LSA_HANDLE ObjectHandle, IN SECURITY_INFORMATION SecurityInformation, IN PSECURITY_DESCRIPTOR SecurityDescriptor)
NTSTATUS WINAPI	LsaSetSystemAccessAccount (IN LSA_HANDLE AccountHandle, IN ULONG SystemAccess)
NTSTATUS WINAPI	LsaSetTrustedDomainInfoByName (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING TrustedDomainName, IN TRUSTED_INFORMATION_CLASS InformationClass, IN PVOID Buffer)
NTSTATUS WINAPI	LsaSetTrustedDomainInformation (IN LSA_HANDLE PolicyHandle, IN PSID TrustedDomainSid, IN TRUSTED_INFORMATION_CLASS InformationClass, IN PVOID Buffer)
NTSTATUS WINAPI	LsaStorePrivateData (IN LSA_HANDLE PolicyHandle, IN PLSA_UNICODE_STRING KeyName, IN PLSA_UNICODE_STRING PrivateData OPTIONAL)

Function Documentation

LsaAddAccountRights()

NTSTATUS WINAPI LsaAddAccountRights	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	AccountSid,
		IN PLSA_UNICODE_STRING	UserRights,
		IN ULONG	CountOfRights
	)

Definition at line 105 of file lsa.c.

{
    LSAPR_USER_RIGHT_SET UserRightSet;
    NTSTATUS Status;
 
    TRACE("LsaAddAccountRights(%p %p %p 0x%08x)\n",
          PolicyHandle, AccountSid, UserRights, CountOfRights);
 
    UserRightSet.Entries = CountOfRights;
    UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
 
    RpcTryExcept
    {
        Status = LsarAddAccountRights((LSAPR_HANDLE)PolicyHandle,
                                      (PRPC_SID)AccountSid,
                                      &UserRightSet);
 
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by AddImpersonatePrivilege(), and InstallPrivileges().

LsaAddPrivilegesToAccount()

NTSTATUS WINAPI LsaAddPrivilegesToAccount	(	IN LSA_HANDLE	AccountHandle,
		IN PPRIVILEGE_SET	PrivilegeSet
	)

Definition at line 141 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaAddPrivilegesToAccount(%p %p)\n",
          AccountHandle, PrivilegeSet);
 
    RpcTryExcept
    {
        Status = LsarAddPrivilegesToAccount((LSAPR_HANDLE)AccountHandle,
                                            (PLSAPR_PRIVILEGE_SET)PrivilegeSet);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaClearAuditLog()

NTSTATUS WINAPI LsaClearAuditLog

(

IN LSA_HANDLE

PolicyHandle

)

Definition at line 169 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaClearAuditLog(%p)\n", PolicyHandle);
 
    RpcTryExcept
    {
        Status = LsarClearAuditLog((LSAPR_HANDLE)PolicyHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaClose()

NTSTATUS WINAPI LsaClose

(

IN LSA_HANDLE

ObjectHandle

)

Definition at line 194 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaClose(%p) called\n", ObjectHandle);
 
    RpcTryExcept
    {
        Status = LsarClose((PLSAPR_HANDLE)&ObjectHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by AccRewriteSetEntriesInAcl(), AddImpersonatePrivilege(), ApplyAccountSettings(), ApplyAuditEvents(), ApplyLockoutSettings(), ApplyPasswordSettings(), BuildSidListFromDomainAndName(), CleanupSidCacheMgr(), CreateSidCacheMgr(), fill_sid(), GetAccountDomainSid(), GetComputerObjectNameW(), GetLsaDefaultPassword(), InstallBuiltinAccounts(), InstallPrivileges(), LookupAccountNameW(), LookupAccountSidW(), LookupPrivilegeDisplayNameW(), LookupPrivilegeNameW(), LookupPrivilegeValueW(), NetLocalGroupGetMembers(), NetpGetJoinInformation(), NetpSetPrimaryDomain(), NetrWkstaGetInfo(), SampGetAccountDomainInfo(), ScmSetServicePassword(), SetAccountsDomainSid(), SetAdministratorPassword(), SetPrimaryDomain(), test_lsa(), test_LsaLookupNames2(), and test_LsaLookupSids().

LsaCreateAccount()

NTSTATUS WINAPI LsaCreateAccount	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	AccountSid,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	AccountHandle
	)

Definition at line 219 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaCreateAccount(%p %p 0x%08lx %p)\n",
          PolicyHandle, AccountSid, DesiredAccess, AccountHandle);
 
    RpcTryExcept
    {
        Status = LsarCreateAccount((LSAPR_HANDLE)PolicyHandle,
                                   AccountSid,
                                   DesiredAccess,
                                   AccountHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by InstallBuiltinAccounts().

LsaCreateSecret()

NTSTATUS WINAPI LsaCreateSecret	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	SecretName,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	SecretHandle
	)

Definition at line 251 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaCreateSecret(%p %p 0x%08lx %p)\n",
          PolicyHandle, SecretName, DesiredAccess, SecretHandle);
 
    RpcTryExcept
    {
        Status = LsarCreateSecret((LSAPR_HANDLE)PolicyHandle,
                                  (PRPC_UNICODE_STRING)SecretName,
                                  DesiredAccess,
                                  SecretHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaCreateTrustedDomain()

NTSTATUS WINAPI LsaCreateTrustedDomain	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_TRUST_INFORMATION	TrustedDomainInformation,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	TrustedDomainHandle
	)

Definition at line 283 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaCreateTrustedDomain(%p %p 0x%08lx %p)\n",
          PolicyHandle, TrustedDomainInformation, DesiredAccess, TrustedDomainHandle);
 
    RpcTryExcept
    {
        Status = LsarCreateTrustedDomain((LSAPR_HANDLE)PolicyHandle,
                                         (PLSAPR_TRUST_INFORMATION)TrustedDomainInformation,
                                         DesiredAccess,
                                         (PLSAPR_HANDLE)TrustedDomainHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaCreateTrustedDomainEx()

NTSTATUS WINAPI LsaCreateTrustedDomainEx	(	IN LSA_HANDLE	PolicyHandle,
		IN PTRUSTED_DOMAIN_INFORMATION_EX	TrustedDomainInformation,
		IN PTRUSTED_DOMAIN_AUTH_INFORMATION	AuthenticationInformation,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	TrustedDomainHandle
	)

Definition at line 315 of file lsa.c.

{
    PLSAPR_TRUSTED_DOMAIN_AUTH_INFORMATION_INTERNAL EncryptedAuthInfo = NULL;
    NTSTATUS Status;
 
    TRACE("LsaCreateTrustedDomainEx(%p %p %p 0x%08lx %p) stub\n",
          PolicyHandle, TrustedDomainInformation, AuthenticationInformation,
          DesiredAccess, TrustedDomainHandle);
 
    RpcTryExcept
    {
        /* FIXME: Encrypt AuthenticationInformation */
 
        Status = LsarCreateTrustedDomainEx2((LSAPR_HANDLE)PolicyHandle,
                                            (PLSAPR_TRUSTED_DOMAIN_INFORMATION_EX)TrustedDomainInformation,
                                            EncryptedAuthInfo,
                                            DesiredAccess,
                                            (PLSAPR_HANDLE)TrustedDomainHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaDelete()

NTSTATUS WINAPI LsaDelete

(

IN LSA_HANDLE

ObjectHandle

)

Definition at line 353 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaDelete(%p)\n", ObjectHandle);
 
    RpcTryExcept
    {
        Status = LsarDelete((LSAPR_HANDLE)ObjectHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaDeleteTrustedDomain()

NTSTATUS WINAPI LsaDeleteTrustedDomain	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	TrustedDomainSid
	)

Definition at line 378 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaDeleteTrustedDomain(%p %p)\n",
          PolicyHandle, TrustedDomainSid);
 
    RpcTryExcept
    {
        Status = LsarDeleteTrustedDomain((LSAPR_HANDLE)PolicyHandle,
                                         TrustedDomainSid);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaEnumerateAccountRights()

NTSTATUS WINAPI LsaEnumerateAccountRights	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	AccountSid,
		OUT PLSA_UNICODE_STRING *	UserRights,
		OUT PULONG	CountOfRights
	)

Definition at line 406 of file lsa.c.

{
    LSAPR_USER_RIGHT_SET UserRightsSet;
    NTSTATUS Status;
 
    TRACE("LsaEnumerateAccountRights(%p %p %p %p)\n",
          PolicyHandle, AccountSid, UserRights, CountOfRights);
 
    UserRightsSet.Entries = 0;
    UserRightsSet.UserRights = NULL;
 
    RpcTryExcept
    {
        Status = LsarEnumerateAccountRights((LSAPR_HANDLE)PolicyHandle,
                                            AccountSid,
                                            &UserRightsSet);
 
        *UserRights = (PUNICODE_STRING)UserRightsSet.UserRights;
        *CountOfRights = UserRightsSet.Entries;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
 
        if (UserRightsSet.UserRights != NULL)
            MIDL_user_free(UserRightsSet.UserRights);
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by test_lsa().

LsaEnumerateAccounts()

NTSTATUS WINAPI LsaEnumerateAccounts	(	IN LSA_HANDLE	PolicyHandle,
		IN OUT PLSA_ENUMERATION_HANDLE	EnumerationContext,
		OUT PVOID *	Buffer,
		IN ULONG	PreferedMaximumLength,
		OUT PULONG	CountReturned
	)

Definition at line 447 of file lsa.c.

{
    LSAPR_ACCOUNT_ENUM_BUFFER AccountEnumBuffer;
    NTSTATUS Status;
 
    TRACE("LsaEnumerateAccounts(%p %p %p %lu %p)\n",
          PolicyHandle, EnumerationContext, Buffer,
          PreferedMaximumLength, CountReturned);
 
    AccountEnumBuffer.EntriesRead = 0;
    AccountEnumBuffer.Information = NULL;
 
    RpcTryExcept
    {
        Status = LsarEnumerateAccounts((LSAPR_HANDLE)PolicyHandle,
                                       EnumerationContext,
                                       &AccountEnumBuffer,
                                       PreferedMaximumLength);
 
        *Buffer = AccountEnumBuffer.Information;
        *CountReturned = AccountEnumBuffer.EntriesRead;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (AccountEnumBuffer.Information != NULL)
            MIDL_user_free(AccountEnumBuffer.Information);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaEnumerateAccountsWithUserRight()

NTSTATUS WINAPI LsaEnumerateAccountsWithUserRight	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING UserRight	OPTIONAL,
		OUT PVOID *	Buffer,
		OUT PULONG	CountReturned
	)

Definition at line 491 of file lsa.c.

{
    LSAPR_ACCOUNT_ENUM_BUFFER AccountEnumBuffer;
    NTSTATUS Status;
 
    TRACE("LsaEnumerateAccountsWithUserRight(%p %p %p %p) stub\n",
          PolicyHandle, UserRight, Buffer, CountReturned);
 
    AccountEnumBuffer.EntriesRead = 0;
    AccountEnumBuffer.Information = NULL;
 
    RpcTryExcept
    {
        Status = LsarEnumerateAccountsWithUserRight((LSAPR_HANDLE)PolicyHandle,
                                                    (PRPC_UNICODE_STRING)UserRight,
                                                    &AccountEnumBuffer);
 
        *Buffer = AccountEnumBuffer.Information;
        *CountReturned = AccountEnumBuffer.EntriesRead;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (AccountEnumBuffer.Information != NULL)
            MIDL_user_free(AccountEnumBuffer.Information);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaEnumeratePrivileges()

NTSTATUS WINAPI LsaEnumeratePrivileges	(	IN LSA_HANDLE	PolicyHandle,
		IN OUT PLSA_ENUMERATION_HANDLE	EnumerationContext,
		OUT PVOID *	Buffer,
		IN ULONG	PreferedMaximumLength,
		OUT PULONG	CountReturned
	)

Definition at line 532 of file lsa.c.

{
    LSAPR_PRIVILEGE_ENUM_BUFFER PrivilegeEnumBuffer;
    NTSTATUS Status;
 
    TRACE("LsaEnumeratePrivileges(%p %p %p %lu %p)\n",
          PolicyHandle, EnumerationContext, Buffer,
          PreferedMaximumLength, CountReturned);
 
    PrivilegeEnumBuffer.Entries = 0;
    PrivilegeEnumBuffer.Privileges = NULL;
 
    RpcTryExcept
    {
        Status = LsarEnumeratePrivileges((LSAPR_HANDLE)PolicyHandle,
                                         EnumerationContext,
                                         &PrivilegeEnumBuffer,
                                         PreferedMaximumLength);
 
        *Buffer = PrivilegeEnumBuffer.Privileges;
        *CountReturned = PrivilegeEnumBuffer.Entries;
 
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (PrivilegeEnumBuffer.Privileges != NULL)
            MIDL_user_free(PrivilegeEnumBuffer.Privileges);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaEnumeratePrivilegesOfAccount()

NTSTATUS WINAPI LsaEnumeratePrivilegesOfAccount	(	IN LSA_HANDLE	AccountHandle,
		OUT PPRIVILEGE_SET *	Privileges
	)

Definition at line 577 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaEnumeratePrivilegesOfAccount(%p %p)\n",
          AccountHandle, Privileges);
 
    RpcTryExcept
    {
        Status = LsarEnumeratePrivilegesAccount((LSAPR_HANDLE)AccountHandle,
                                                (LSAPR_PRIVILEGE_SET **)Privileges);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaEnumerateTrustedDomains()

NTSTATUS WINAPI LsaEnumerateTrustedDomains	(	IN LSA_HANDLE	PolicyHandle,
		IN OUT PLSA_ENUMERATION_HANDLE	EnumerationContext,
		OUT PVOID *	Buffer,
		IN ULONG	PreferedMaximumLength,
		OUT PULONG	CountReturned
	)

Definition at line 605 of file lsa.c.

{
    LSAPR_TRUSTED_ENUM_BUFFER TrustedEnumBuffer;
    NTSTATUS Status;
 
    TRACE("LsaEnumerateTrustedDomains(%p %p %p %lu %p)\n",
          PolicyHandle, EnumerationContext, Buffer,
          PreferedMaximumLength, CountReturned);
 
    if (Buffer == NULL)
        return STATUS_INVALID_PARAMETER;
 
    TrustedEnumBuffer.EntriesRead = 0;
    TrustedEnumBuffer.Information = NULL;
 
    RpcTryExcept
    {
        Status = LsarEnumerateTrustedDomains((LSAPR_HANDLE)PolicyHandle,
                                             EnumerationContext,
                                             &TrustedEnumBuffer,
                                             PreferedMaximumLength);
 
        *Buffer = TrustedEnumBuffer.Information;
        *CountReturned = TrustedEnumBuffer.EntriesRead;
 
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (TrustedEnumBuffer.Information != NULL)
            MIDL_user_free(TrustedEnumBuffer.Information);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaEnumerateTrustedDomainsEx()

NTSTATUS WINAPI LsaEnumerateTrustedDomainsEx	(	IN LSA_HANDLE	PolicyHandle,
		IN OUT PLSA_ENUMERATION_HANDLE	EnumerationContext,
		OUT PVOID *	Buffer,
		IN ULONG	PreferedMaximumLength,
		OUT PULONG	CountReturned
	)

Definition at line 653 of file lsa.c.

{
    LSAPR_TRUSTED_ENUM_BUFFER_EX TrustedEnumBuffer;
    NTSTATUS Status;
 
    TRACE("LsaEnumerateTrustedDomainsEx(%p %p %p %lu %p)\n",
          PolicyHandle, EnumerationContext, Buffer,
          PreferedMaximumLength, CountReturned);
 
    if (Buffer == NULL)
        return STATUS_INVALID_PARAMETER;
 
    TrustedEnumBuffer.EntriesRead = 0;
    TrustedEnumBuffer.EnumerationBuffer = NULL;
 
    RpcTryExcept
    {
        Status = LsarEnumerateTrustedDomainsEx((LSAPR_HANDLE)PolicyHandle,
                                               EnumerationContext,
                                               &TrustedEnumBuffer,
                                               PreferedMaximumLength);
 
        *Buffer = TrustedEnumBuffer.EnumerationBuffer;
        *CountReturned = TrustedEnumBuffer.EntriesRead;
 
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (TrustedEnumBuffer.EnumerationBuffer != NULL)
            MIDL_user_free(TrustedEnumBuffer.EnumerationBuffer);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaFreeMemory()

NTSTATUS WINAPI LsaFreeMemory

(

IN PVOID

Buffer

)

Definition at line 701 of file lsa.c.

{
    TRACE("LsaFreeMemory(%p)\n", Buffer);
    return RtlFreeHeap(RtlGetProcessHeap(), 0, Buffer);
}

Referenced by AccpLookupSidByName(), ApplyAccountSettings(), ApplyLockoutSettings(), ApplyPasswordSettings(), BuildSidListFromDomainAndName(), fill_sid(), GetAccountDomainSid(), GetComputerObjectNameW(), GetLsaDefaultPassword(), InstallPrivileges(), LookupAccountNameW(), LookupAccountSidW(), LookupPrivilegeDisplayNameW(), LookupPrivilegeNameW(), LookupSidInformation(), NetLocalGroupGetMembers(), NetpGetJoinInformation(), NetrWkstaGetInfo(), SampInitializeSAM(), SetAccountsDomainSid(), SetAdministratorPassword(), SetPrimaryDomain(), test_lsa(), test_LsaLookupNames2(), test_LsaLookupPrivilegeName(), and test_LsaLookupSids().

LsaGetQuotasForAccount()

NTSTATUS WINAPI LsaGetQuotasForAccount	(	IN LSA_HANDLE	AccountHandle,
		OUT PQUOTA_LIMITS	QuotaLimits
	)

Definition at line 713 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaGetQuotasForAccount(%p %p)\n",
          AccountHandle, QuotaLimits);
 
    RpcTryExcept
    {
        Status = LsarGetQuotasForAccount((LSAPR_HANDLE)AccountHandle,
                                         QuotaLimits);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaGetRemoteUserName()

NTSTATUS WINAPI LsaGetRemoteUserName	(	IN PLSA_UNICODE_STRING SystemName	OPTIONAL,
		OUT PLSA_UNICODE_STRING *	UserName,
		OUT PLSA_UNICODE_STRING *DomainName	OPTIONAL
	)

Definition at line 741 of file lsa.c.

{
    PRPC_UNICODE_STRING UserNameString = NULL;
    PRPC_UNICODE_STRING DomainNameString = NULL;
    NTSTATUS Status;
 
    TRACE("LsaGetRemoteUserName(%s %p %p)\n",
          SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
          UserName, DomainName);
 
    RpcTryExcept
    {
        Status = LsarGetUserName((PLSAPR_SERVER_NAME)SystemName,
                                 &UserNameString,
                                 (DomainName != NULL) ? &DomainNameString : NULL);
 
        *UserName = (PLSA_UNICODE_STRING)UserNameString;
 
        if (DomainName != NULL)
            *DomainName = (PLSA_UNICODE_STRING)DomainNameString;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (UserNameString != NULL)
            MIDL_user_free(UserNameString);
 
        if (DomainNameString != NULL)
            MIDL_user_free(DomainNameString);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaGetSystemAccessAccount()

NTSTATUS WINAPI LsaGetSystemAccessAccount	(	IN LSA_HANDLE	AccountHandle,
		OUT PULONG	SystemAccess
	)

Definition at line 785 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaGetSystemAccessAccount(%p %p)\n",
          AccountHandle, SystemAccess);
 
    RpcTryExcept
    {
        Status = LsarGetSystemAccessAccount((LSAPR_HANDLE)AccountHandle,
                                            (ACCESS_MASK *)SystemAccess);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaGetUserName()

NTSTATUS WINAPI LsaGetUserName	(	OUT PUNICODE_STRING *	UserName,
		OUT PUNICODE_STRING *DomainName	OPTIONAL
	)

Definition at line 813 of file lsa.c.

{
    PRPC_UNICODE_STRING UserNameString = NULL;
    PRPC_UNICODE_STRING DomainNameString = NULL;
    NTSTATUS Status;
 
    TRACE("LsaGetUserName(%p %p)\n",
          UserName, DomainName);
 
    RpcTryExcept
    {
        Status = LsarGetUserName(NULL,
                                 &UserNameString,
                                 (DomainName != NULL) ? &DomainNameString : NULL);
 
        *UserName = (PUNICODE_STRING)UserNameString;
 
        if (DomainName != NULL)
            *DomainName = (PUNICODE_STRING)DomainNameString;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (UserNameString != NULL)
            MIDL_user_free(UserNameString);
 
        if (DomainNameString != NULL)
            MIDL_user_free(DomainNameString);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaLookupNames()

NTSTATUS WINAPI LsaLookupNames	(	IN LSA_HANDLE	PolicyHandle,
		IN ULONG	Count,
		IN PLSA_UNICODE_STRING	Names,
		OUT PLSA_REFERENCED_DOMAIN_LIST *	ReferencedDomains,
		OUT PLSA_TRANSLATED_SID *	Sids
	)

Definition at line 855 of file lsa.c.

{
    LSAPR_TRANSLATED_SIDS TranslatedSids = {0, NULL};
    ULONG MappedCount = 0;
    NTSTATUS Status;
 
    TRACE("LsaLookupNames(%p %lu %p %p %p)\n",
          PolicyHandle, Count, Names, ReferencedDomains, Sids);
 
    if (ReferencedDomains == NULL || Sids == NULL)
        return STATUS_INVALID_PARAMETER;
 
    RpcTryExcept
    {
        *ReferencedDomains = NULL;
        *Sids = NULL;
 
        TranslatedSids.Entries = Count;
 
        Status = LsarLookupNames((LSAPR_HANDLE)PolicyHandle,
                                 Count,
                                 (PRPC_UNICODE_STRING)Names,
                                 (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
                                 &TranslatedSids,
                                 LsapLookupWksta,
                                 &MappedCount);
 
        *Sids = (PLSA_TRANSLATED_SID)TranslatedSids.Sids;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (TranslatedSids.Sids != NULL)
            MIDL_user_free(TranslatedSids.Sids);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by BuildSidListFromDomainAndName(), and LookupAccountNameW().

LsaLookupNames2()

NTSTATUS WINAPI LsaLookupNames2	(	IN LSA_HANDLE	PolicyHandle,
		IN ULONG	Flags,
		IN ULONG	Count,
		IN PLSA_UNICODE_STRING	Names,
		OUT PLSA_REFERENCED_DOMAIN_LIST *	ReferencedDomains,
		OUT PLSA_TRANSLATED_SID2 *	Sids
	)

Definition at line 906 of file lsa.c.

{
    LSAPR_TRANSLATED_SIDS_EX2 TranslatedSids = {0, NULL};
    ULONG MappedCount = 0;
    NTSTATUS Status;
 
    TRACE("LsaLookupNames2(%p 0x%08x %lu %p %p %p)\n",
          PolicyHandle, Flags, Count, Names, ReferencedDomains, Sids);
 
    if (ReferencedDomains == NULL || Sids == NULL)
        return STATUS_INVALID_PARAMETER;
 
    RpcTryExcept
    {
        *ReferencedDomains = NULL;
        *Sids = NULL;
 
        TranslatedSids.Entries = Count;
 
        Status = LsarLookupNames3((LSAPR_HANDLE)PolicyHandle,
                                  Count,
                                  (PRPC_UNICODE_STRING)Names,
                                  (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
                                  &TranslatedSids,
                                  LsapLookupWksta,
                                  &MappedCount,
                                  Flags,
                                  2);
 
        *Sids = (PLSA_TRANSLATED_SID2)TranslatedSids.Sids;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (TranslatedSids.Sids != NULL)
            MIDL_user_free(TranslatedSids.Sids);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by AccpLookupSidByName(), InstallPrivileges(), and test_LsaLookupNames2().

LsaLookupPrivilegeDisplayName()

NTSTATUS WINAPI LsaLookupPrivilegeDisplayName	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	Name,
		OUT PLSA_UNICODE_STRING *	DisplayName,
		OUT PUSHORT	LanguageReturned
	)

Definition at line 960 of file lsa.c.

{
    PRPC_UNICODE_STRING DisplayNameBuffer = NULL;
    NTSTATUS Status;
 
    TRACE("LsaLookupPrivilegeDisplayName(%p %p %p %p)\n",
          PolicyHandle, Name, DisplayName, LanguageReturned);
 
    RpcTryExcept
    {
        Status = LsarLookupPrivilegeDisplayName(PolicyHandle,
                                                (PRPC_UNICODE_STRING)Name,
                                                GetUserDefaultUILanguage(),
                                                GetSystemDefaultUILanguage(),
                                                &DisplayNameBuffer,
                                                LanguageReturned);
 
        *DisplayName = (PUNICODE_STRING)DisplayNameBuffer;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (DisplayNameBuffer != NULL)
            MIDL_user_free(DisplayNameBuffer);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by LookupPrivilegeDisplayNameW().

LsaLookupPrivilegeName()

NTSTATUS WINAPI LsaLookupPrivilegeName	(	IN LSA_HANDLE	PolicyHandle,
		IN PLUID	Value,
		OUT PUNICODE_STRING *	Name
	)

Definition at line 1000 of file lsa.c.

{
    PRPC_UNICODE_STRING NameBuffer = NULL;
    NTSTATUS Status;
 
    TRACE("LsaLookupPrivilegeName(%p %p %p)\n",
          PolicyHandle, Value, Name);
 
    RpcTryExcept
    {
        Status = LsarLookupPrivilegeName(PolicyHandle,
                                         Value,
                                         &NameBuffer);
 
        *Name = (PUNICODE_STRING)NameBuffer;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (NameBuffer != NULL)
            MIDL_user_free(NameBuffer);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by LookupPrivilegeNameW(), and test_LsaLookupPrivilegeName().

LsaLookupPrivilegeValue()

NTSTATUS WINAPI LsaLookupPrivilegeValue	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	Name,
		OUT PLUID	Value
	)

Definition at line 1036 of file lsa.c.

{
    LUID Luid;
    NTSTATUS Status;
 
    TRACE("LsaLookupPrivilegeValue(%p %p %p)\n",
          PolicyHandle, Name, Value);
 
    RpcTryExcept
    {
        Status = LsarLookupPrivilegeValue(PolicyHandle,
                                          (PRPC_UNICODE_STRING)Name,
                                          &Luid);
        if (Status == STATUS_SUCCESS)
            *Value = Luid;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by LookupPrivilegeValueW().

LsaLookupSids()

NTSTATUS WINAPI LsaLookupSids	(	IN LSA_HANDLE	PolicyHandle,
		IN ULONG	Count,
		IN PSID *	Sids,
		OUT PLSA_REFERENCED_DOMAIN_LIST *	ReferencedDomains,
		OUT PLSA_TRANSLATED_NAME *	Names
	)

Definition at line 1069 of file lsa.c.

{
    LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
    LSAPR_TRANSLATED_NAMES TranslatedNames;
    ULONG MappedCount = 0;
    NTSTATUS  Status;
 
    TRACE("LsaLookupSids(%p %lu %p %p %p)\n",
          PolicyHandle, Count, Sids, ReferencedDomains, Names);
 
    if (Count == 0)
        return STATUS_INVALID_PARAMETER;
 
    SidEnumBuffer.Entries = Count;
    SidEnumBuffer.SidInfo = (PLSAPR_SID_INFORMATION)Sids;
 
    RpcTryExcept
    {
        *ReferencedDomains = NULL;
        *Names = NULL;
 
        TranslatedNames.Entries = 0;
        TranslatedNames.Names = NULL;
 
        Status = LsarLookupSids((LSAPR_HANDLE)PolicyHandle,
                                &SidEnumBuffer,
                                (PLSAPR_REFERENCED_DOMAIN_LIST *)ReferencedDomains,
                                &TranslatedNames,
                                LsapLookupWksta,
                                &MappedCount);
 
        *Names = (PLSA_TRANSLATED_NAME)TranslatedNames.Names;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (TranslatedNames.Names != NULL)
        {
            MIDL_user_free(TranslatedNames.Names);
        }
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by fill_sid(), LookupAccountSidW(), LookupSidInformation(), NetLocalGroupGetMembers(), and test_LsaLookupSids().

LsaNtStatusToWinError()

ULONG WINAPI LsaNtStatusToWinError

(

IN NTSTATUS

Status

)

Definition at line 1131 of file lsa.c.

{
    TRACE("LsaNtStatusToWinError(0x%lx)\n", Status);
    return RtlNtStatusToDosError(Status);
}

Referenced by AccpLookupSidByName(), AccpOpenLSAPolicyHandle(), DsRolepGetBasicInfo(), GetComputerObjectNameW(), LookupAccountNameW(), LookupAccountSidW(), LookupPrivilegeDisplayNameW(), LookupPrivilegeNameW(), LookupPrivilegeValueW(), NetpGetJoinInformation(), NetpSetPrimaryDomain(), NetrWkstaGetInfo(), OpenLSAPolicyHandle(), and WinMain().

LsaOpenAccount()

NTSTATUS WINAPI LsaOpenAccount	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	AccountSid,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	AccountHandle
	)

Definition at line 1143 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaOpenAccount(%p %p 0x%08lx %p)\n",
          PolicyHandle, AccountSid, DesiredAccess, AccountHandle);
 
    RpcTryExcept
    {
        Status = LsarOpenAccount((LSAPR_HANDLE)PolicyHandle,
                                 AccountSid,
                                 DesiredAccess,
                                 AccountHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaOpenPolicy()

NTSTATUS WINAPI LsaOpenPolicy	(	IN PLSA_UNICODE_STRING SystemName	OPTIONAL,
		IN PLSA_OBJECT_ATTRIBUTES	ObjectAttributes,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	PolicyHandle
	)

Definition at line 1183 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaOpenPolicy(%s %p 0x%08lx %p)\n",
          SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
          ObjectAttributes, DesiredAccess, PolicyHandle);
 
    /* FIXME: RPC should take care of this */
    if (!LsapIsLocalComputer(SystemName))
        return RPC_NT_SERVER_UNAVAILABLE;
 
    RpcTryExcept
    {
        *PolicyHandle = NULL;
 
        Status = LsarOpenPolicy(SystemName ? SystemName->Buffer : NULL,
                                (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
                                DesiredAccess,
                                PolicyHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    TRACE("LsaOpenPolicy() done (Status: 0x%08lx)\n", Status);
 
    return Status;
}

Referenced by AccpOpenLSAPolicyHandle(), AddImpersonatePrivilege(), ApplyAccountSettings(), ApplyAuditEvents(), ApplyLockoutSettings(), ApplyPasswordSettings(), BuildSidListFromDomainAndName(), fill_sid(), GetAccountDomainSid(), GetComputerObjectNameW(), GetLsaDefaultPassword(), InstallBuiltinAccounts(), InstallPrivileges(), LookupAccountNameW(), LookupAccountSidW(), LookupPrivilegeDisplayNameW(), LookupPrivilegeNameW(), LookupPrivilegeValueW(), NetLocalGroupGetMembers(), NetpGetJoinInformation(), NetpSetPrimaryDomain(), NetrWkstaGetInfo(), OpenLSAPolicyHandle(), SampGetAccountDomainInfo(), ScmSetServicePassword(), SetAccountsDomainSid(), SetAdministratorPassword(), SetPrimaryDomain(), test_lsa(), test_LsaLookupNames2(), test_LsaLookupPrivilegeName(), and test_LsaLookupSids().

LsaOpenPolicySce()

NTSTATUS WINAPI LsaOpenPolicySce	(	IN PLSA_UNICODE_STRING SystemName	OPTIONAL,
		IN PLSA_OBJECT_ATTRIBUTES	ObjectAttributes,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	PolicyHandle
	)

Definition at line 1224 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaOpenPolicySce(%s %p 0x%08lx %p)\n",
          SystemName ? debugstr_w(SystemName->Buffer) : "(null)",
          ObjectAttributes, DesiredAccess, PolicyHandle);
 
    /* FIXME: RPC should take care of this */
    if (!LsapIsLocalComputer(SystemName))
        return RPC_NT_SERVER_UNAVAILABLE;
 
    RpcTryExcept
    {
        *PolicyHandle = NULL;
 
        Status = LsarOpenPolicySce(SystemName ? SystemName->Buffer : NULL,
                                   (PLSAPR_OBJECT_ATTRIBUTES)ObjectAttributes,
                                   DesiredAccess,
                                   PolicyHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    TRACE("LsaOpenPolicySce() done (Status: 0x%08lx)\n", Status);
 
    return Status;
}

LsaOpenSecret()

NTSTATUS WINAPI LsaOpenSecret	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	SecretName,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	SecretHandle
	)

Definition at line 1265 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaOpenSecret(%p %p 0x%08lx %p)\n",
          PolicyHandle, SecretName, DesiredAccess, SecretHandle);
 
    RpcTryExcept
    {
        *SecretHandle = NULL;
 
        Status = LsarOpenSecret((LSAPR_HANDLE)PolicyHandle,
                                (PRPC_UNICODE_STRING)SecretName,
                                DesiredAccess,
                                SecretHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    TRACE("LsaOpenSecret() done (Status: 0x%08lx)\n", Status);
 
    return Status;
}

LsaOpenTrustedDomain()

NTSTATUS WINAPI LsaOpenTrustedDomain	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	TrustedDomainSid,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	TrustedDomainHandle
	)

Definition at line 1301 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaOpenTrustedDomain(%p %p 0x%08lx %p)\n",
          PolicyHandle, TrustedDomainSid, DesiredAccess, TrustedDomainHandle);
 
    RpcTryExcept
    {
        Status = LsarOpenTrustedDomain((LSAPR_HANDLE)PolicyHandle,
                                       (PRPC_SID)TrustedDomainSid,
                                       DesiredAccess,
                                       (PLSAPR_HANDLE)TrustedDomainHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaOpenTrustedDomainByName()

NTSTATUS WINAPI LsaOpenTrustedDomainByName	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	TrustedDomainName,
		IN ACCESS_MASK	DesiredAccess,
		OUT PLSA_HANDLE	TrustedDomainHandle
	)

Definition at line 1333 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaOpenTrustedDomainByName(%p %p 0x%08lx %p)\n",
          PolicyHandle, TrustedDomainName, DesiredAccess, TrustedDomainHandle);
 
    RpcTryExcept
    {
        Status = LsarOpenTrustedDomainByName((LSAPR_HANDLE)PolicyHandle,
                                             (PRPC_UNICODE_STRING)TrustedDomainName,
                                             DesiredAccess,
                                             TrustedDomainHandle);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsapIsLocalComputer()

static BOOL LsapIsLocalComputer ( PLSA_UNICODE_STRING  ServerName )

static

Definition at line 21 of file lsa.c.

{
    DWORD dwSize = MAX_COMPUTERNAME_LENGTH + 1;
    BOOL Result;
    LPWSTR buf;
    PCWSTR pSrvName;
 
    if (ServerName == NULL || ServerName->Length == 0 || ServerName->Buffer == NULL)
        return TRUE;
 
    pSrvName = ServerName->Buffer;
    buf = HeapAlloc(GetProcessHeap(), 0, dwSize * sizeof(WCHAR));
    Result = GetComputerNameW(buf, &dwSize);
    if (Result && (pSrvName[0] == L'\\') && (pSrvName[1] == L'\\'))
        pSrvName += 2;
    Result = Result && !lstrcmpW(pSrvName, buf);
    HeapFree(GetProcessHeap(), 0, buf);
 
    return Result;
}

Referenced by LsaOpenPolicy(), and LsaOpenPolicySce().

LsaQueryDomainInformationPolicy()

NTSTATUS WINAPI LsaQueryDomainInformationPolicy	(	IN LSA_HANDLE	PolicyHandle,
		IN POLICY_DOMAIN_INFORMATION_CLASS	InformationClass,
		OUT PVOID *	Buffer
	)

Definition at line 1365 of file lsa.c.

{
    PLSAPR_POLICY_DOMAIN_INFORMATION PolicyInformation = NULL;
    NTSTATUS Status;
 
    TRACE("LsaQueryDomainInformationPolicy(%p %lu %p)\n",
          PolicyHandle, InformationClass, Buffer);
 
    RpcTryExcept
    {
        Status = LsarQueryDomainInformationPolicy((LSAPR_HANDLE)PolicyHandle,
                                                  InformationClass,
                                                  &PolicyInformation);
 
        *Buffer = PolicyInformation;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (PolicyInformation != NULL)
            MIDL_user_free(PolicyInformation);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaQueryForestTrustInformation()

NTSTATUS WINAPI LsaQueryForestTrustInformation	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	TrustedDomainName,
		OUT PLSA_FOREST_TRUST_INFORMATION *	ForestTrustInfo
	)

Definition at line 1401 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaQueryForestTrustInformation(%p %p %p)\n",
          PolicyHandle, TrustedDomainName, ForestTrustInfo);
 
    RpcTryExcept
    {
        Status = LsarQueryForestTrustInformation((LSAPR_HANDLE)PolicyHandle,
                                                 TrustedDomainName,
                                                 ForestTrustDomainInfo,
                                                 ForestTrustInfo);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaQueryInformationPolicy()

NTSTATUS WINAPI LsaQueryInformationPolicy	(	IN LSA_HANDLE	PolicyHandle,
		IN POLICY_INFORMATION_CLASS	InformationClass,
		OUT PVOID *	Buffer
	)

Definition at line 1473 of file lsa.c.

{
    PLSAPR_POLICY_INFORMATION PolicyInformation = NULL;
    NTSTATUS Status;
 
    TRACE("LsaQueryInformationPolicy(%p %d %p)\n",
          PolicyHandle, InformationClass, Buffer);
 
    RpcTryExcept
    {
        Status = LsarQueryInformationPolicy((LSAPR_HANDLE)PolicyHandle,
                                            InformationClass,
                                            &PolicyInformation);
        *Buffer = PolicyInformation;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (PolicyInformation != NULL)
            MIDL_user_free(PolicyInformation);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    TRACE("Done (Status: 0x%08x)\n", Status);
 
    return Status;
}

Referenced by ApplyAccountSettings(), ApplyLockoutSettings(), ApplyPasswordSettings(), GetAccountDomainSid(), GetComputerObjectNameW(), LookupSidInformation(), NetpGetJoinInformation(), NetrWkstaGetInfo(), SampGetAccountDomainInfo(), SetAccountsDomainSid(), SetAdministratorPassword(), SetPrimaryDomain(), and test_lsa().

LsaQueryInfoTrustedDomain()

NTSTATUS WINAPI LsaQueryInfoTrustedDomain	(	IN LSA_HANDLE	TrustedDomainHandle,
		IN TRUSTED_INFORMATION_CLASS	InformationClass,
		OUT PVOID *	Buffer
	)

Definition at line 1432 of file lsa.c.

{
    PLSAPR_TRUSTED_DOMAIN_INFO TrustedDomainInformation = NULL;
    NTSTATUS Status;
 
    TRACE("LsaQueryInfoTrustedDomain(%p %d %p) stub\n",
          TrustedDomainHandle, InformationClass, Buffer);
 
    if (InformationClass == TrustedDomainAuthInformationInternal ||
        InformationClass == TrustedDomainFullInformationInternal)
        return STATUS_INVALID_INFO_CLASS;
 
    RpcTryExcept
    {
        Status = LsarQueryInfoTrustedDomain((LSAPR_HANDLE)TrustedDomainHandle,
                                            InformationClass,
                                            &TrustedDomainInformation);
        *Buffer = TrustedDomainInformation;
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        if (TrustedDomainInformation != NULL)
            MIDL_user_free(TrustedDomainInformation);
 
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    TRACE("Done (Status: 0x%08x)\n", Status);
 
    return Status;
}

LsaQuerySecret()

NTSTATUS WINAPI LsaQuerySecret	(	IN LSA_HANDLE	SecretHandle,
		OUT PLSA_UNICODE_STRING *CurrentValue	OPTIONAL,
		OUT PLARGE_INTEGER CurrentValueSetTime	OPTIONAL,
		OUT PLSA_UNICODE_STRING *OldValue	OPTIONAL,
		OUT PLARGE_INTEGER OldValueSetTime	OPTIONAL
	)

Definition at line 1510 of file lsa.c.

{
    PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue = NULL;
    PLSAPR_CR_CIPHER_VALUE EncryptedOldValue = NULL;
    PLSA_UNICODE_STRING DecryptedCurrentValue = NULL;
    PLSA_UNICODE_STRING DecryptedOldValue = NULL;
    SIZE_T BufferSize;
    NTSTATUS Status;
 
    TRACE("LsaQuerySecret(%p %p %p %p %p)\n",
          SecretHandle, CurrentValue, CurrentValueSetTime,
          OldValue, OldValueSetTime);
 
    RpcTryExcept
    {
        Status = LsarQuerySecret((PLSAPR_HANDLE)SecretHandle,
                                 &EncryptedCurrentValue,
                                 CurrentValueSetTime,
                                 &EncryptedOldValue,
                                 OldValueSetTime);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (!NT_SUCCESS(Status))
        goto done;
 
    /* Decrypt the current value */
    if (CurrentValue != NULL)
    {
         if (EncryptedCurrentValue == NULL)
         {
             *CurrentValue = NULL;
         }
         else
         {
             /* FIXME: Decrypt the current value */
             BufferSize = sizeof(LSA_UNICODE_STRING) + EncryptedCurrentValue->MaximumLength;
             DecryptedCurrentValue = midl_user_allocate(BufferSize);
             if (DecryptedCurrentValue == NULL)
             {
                 Status = STATUS_INSUFFICIENT_RESOURCES;
                 goto done;
             }
 
             DecryptedCurrentValue->Length = (USHORT)EncryptedCurrentValue->Length;
             DecryptedCurrentValue->MaximumLength = (USHORT)EncryptedCurrentValue->MaximumLength;
             DecryptedCurrentValue->Buffer = (PWSTR)(DecryptedCurrentValue + 1);
             RtlCopyMemory(DecryptedCurrentValue->Buffer,
                           EncryptedCurrentValue->Buffer,
                           EncryptedCurrentValue->Length);
 
             *CurrentValue = DecryptedCurrentValue;
         }
    }
 
    /* Decrypt the old value */
    if (OldValue != NULL)
    {
         if (EncryptedOldValue == NULL)
         {
             *OldValue = NULL;
         }
         else
         {
             /* FIXME: Decrypt the old value */
             BufferSize = sizeof(LSA_UNICODE_STRING) + EncryptedOldValue->MaximumLength;
             DecryptedOldValue = midl_user_allocate(BufferSize);
             if (DecryptedOldValue == NULL)
             {
                 Status = STATUS_INSUFFICIENT_RESOURCES;
                 goto done;
             }
 
             DecryptedOldValue->Length = (USHORT)EncryptedOldValue->Length;
             DecryptedOldValue->MaximumLength = (USHORT)EncryptedOldValue->MaximumLength;
             DecryptedOldValue->Buffer = (PWSTR)(DecryptedOldValue + 1);
             RtlCopyMemory(DecryptedOldValue->Buffer,
                           EncryptedOldValue->Buffer,
                           EncryptedOldValue->Length);
 
             *OldValue = DecryptedOldValue;
         }
    }
 
done:
    if (!NT_SUCCESS(Status))
    {
        if (DecryptedCurrentValue != NULL)
            midl_user_free(DecryptedCurrentValue);
 
        if (DecryptedOldValue != NULL)
            midl_user_free(DecryptedOldValue);
 
        if (CurrentValue != NULL)
            *CurrentValue = NULL;
 
        if (OldValue != NULL)
            *OldValue = NULL;
    }
 
    if (EncryptedCurrentValue != NULL)
        midl_user_free(EncryptedCurrentValue);
 
    if (EncryptedOldValue != NULL)
        midl_user_free(EncryptedOldValue);
 
    return Status;
}

LsaQuerySecurityObject()

NTSTATUS WINAPI LsaQuerySecurityObject	(	IN LSA_HANDLE	ObjectHandle,
		IN SECURITY_INFORMATION	SecurityInformation,
		OUT PSECURITY_DESCRIPTOR *	SecurityDescriptor
	)

Definition at line 1633 of file lsa.c.

{
    LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer;
    PLSAPR_SR_SECURITY_DESCRIPTOR SdPointer;
    NTSTATUS Status;
 
    TRACE("LsaQuerySecurityObject(%p %lx %p)\n",
          ObjectHandle, SecurityInformation, SecurityDescriptor);
 
    SdBuffer.Length = 0;
    SdBuffer.SecurityDescriptor = NULL;
 
    SdPointer = &SdBuffer;
 
    RpcTryExcept
    {
        Status = LsarQuerySecurityObject((LSAPR_HANDLE)ObjectHandle,
                                         SecurityInformation,
                                         &SdPointer);
        if (NT_SUCCESS(Status))
        {
            *SecurityDescriptor = SdBuffer.SecurityDescriptor;
        }
        else
        {
            *SecurityDescriptor = NULL;
        }
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaQueryTrustedDomainInfo()

NTSTATUS WINAPI LsaQueryTrustedDomainInfo	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	TrustedDomainSid,
		IN TRUSTED_INFORMATION_CLASS	InformationClass,
		OUT PVOID *	Buffer
	)

Definition at line 1678 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaQueryTrustedDomainInfo(%p %p %d %p) stub\n",
          PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
 
    if (InformationClass == TrustedDomainAuthInformationInternal ||
        InformationClass == TrustedDomainFullInformationInternal)
        return STATUS_INVALID_INFO_CLASS;
 
    RpcTryExcept
    {
        Status = LsarQueryTrustedDomainInfo((LSAPR_HANDLE)PolicyHandle,
                                            (PRPC_SID)TrustedDomainSid,
                                            InformationClass,
                                            (PLSAPR_TRUSTED_DOMAIN_INFO *)Buffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaQueryTrustedDomainInfoByName()

NTSTATUS WINAPI LsaQueryTrustedDomainInfoByName	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	TrustedDomainName,
		IN TRUSTED_INFORMATION_CLASS	InformationClass,
		OUT PVOID *	Buffer
	)

Definition at line 1714 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaQueryTrustedDomainInfoByName(%p %p %d %p)\n",
          PolicyHandle, TrustedDomainName, InformationClass, Buffer);
 
    if (InformationClass == TrustedDomainAuthInformationInternal ||
        InformationClass == TrustedDomainFullInformationInternal)
        return STATUS_INVALID_INFO_CLASS;
 
    RpcTryExcept
    {
        Status = LsarQueryTrustedDomainInfoByName((LSAPR_HANDLE)PolicyHandle,
                                                  (PRPC_UNICODE_STRING)TrustedDomainName,
                                                  InformationClass,
                                                  (PLSAPR_TRUSTED_DOMAIN_INFO *)Buffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaRemoveAccountRights()

NTSTATUS WINAPI LsaRemoveAccountRights	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	AccountSid,
		IN BOOLEAN	AllRights,
		IN PLSA_UNICODE_STRING	UserRights,
		IN ULONG	CountOfRights
	)

Definition at line 1750 of file lsa.c.

{
    NTSTATUS Status;
    LSAPR_USER_RIGHT_SET UserRightSet;
 
    TRACE("LsaRemoveAccountRights(%p %p %d %p %lu)\n",
          PolicyHandle, AccountSid, AllRights, UserRights, CountOfRights);
 
    UserRightSet.Entries = CountOfRights;
    UserRightSet.UserRights = (PRPC_UNICODE_STRING)UserRights;
 
    RpcTryExcept
    {
        Status = LsarRemoveAccountRights((LSAPR_HANDLE)PolicyHandle,
                                         (PRPC_SID)AccountSid,
                                         AllRights,
                                         &UserRightSet);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaRemovePrivilegesFromAccount()

NTSTATUS WINAPI LsaRemovePrivilegesFromAccount	(	IN LSA_HANDLE	AccountHandle,
		IN BOOLEAN	AllPrivileges,
		IN PPRIVILEGE_SET Privileges	OPTIONAL
	)

Definition at line 1787 of file lsa.c.

{
    NTSTATUS Status;
 
    RpcTryExcept
    {
        Status = LsarRemovePrivilegesFromAccount((LSAPR_HANDLE)AccountHandle,
                                                 AllPrivileges,
                                                 (PLSAPR_PRIVILEGE_SET)Privileges);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaRetrievePrivateData()

NTSTATUS WINAPI LsaRetrievePrivateData	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	KeyName,
		OUT PLSA_UNICODE_STRING *	PrivateData
	)

Definition at line 1814 of file lsa.c.

{
    PLSAPR_CR_CIPHER_VALUE EncryptedData = NULL;
    PLSA_UNICODE_STRING DecryptedData = NULL;
    SIZE_T BufferSize;
    NTSTATUS Status;
 
    TRACE("LsaRetrievePrivateData(%p %p %p)\n",
          PolicyHandle, KeyName, PrivateData);
 
    RpcTryExcept
    {
        Status = LsarRetrievePrivateData((LSAPR_HANDLE)PolicyHandle,
                                         (PRPC_UNICODE_STRING)KeyName,
                                         &EncryptedData);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    if (EncryptedData == NULL)
    {
        *PrivateData = NULL;
    }
    else
    {
        BufferSize = sizeof(LSA_UNICODE_STRING) + EncryptedData->MaximumLength;
        DecryptedData = midl_user_allocate(BufferSize);
        if (DecryptedData == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto done;
        }
 
        DecryptedData->Length = (USHORT)EncryptedData->Length;
        DecryptedData->MaximumLength = (USHORT)EncryptedData->MaximumLength;
        DecryptedData->Buffer = (PWSTR)(DecryptedData + 1);
        RtlCopyMemory(DecryptedData->Buffer,
                      EncryptedData->Buffer,
                      EncryptedData->Length);
 
        *PrivateData = DecryptedData;
    }
 
done:
    if (!NT_SUCCESS(Status))
    {
        if (DecryptedData != NULL)
            midl_user_free(DecryptedData);
 
        *PrivateData = NULL;
    }
 
    if (EncryptedData != NULL)
        midl_user_free(EncryptedData);
 
    return Status;
}

Referenced by GetLsaDefaultPassword().

LsaSetDomainInformationPolicy()

NTSTATUS WINAPI LsaSetDomainInformationPolicy	(	IN LSA_HANDLE	PolicyHandle,
		IN POLICY_DOMAIN_INFORMATION_CLASS	InformationClass,
		IN PVOID Buffer	OPTIONAL
	)

Definition at line 1883 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaSetDomainInformationPolicy(%p %d %p)\n",
          PolicyHandle, InformationClass, Buffer);
 
    RpcTryExcept
    {
        Status = LsarSetDomainInformationPolicy((LSAPR_HANDLE)PolicyHandle,
                                                InformationClass,
                                                (PLSAPR_POLICY_DOMAIN_INFORMATION)Buffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaSetForestTrustInformation()

NTSTATUS WINAPI LsaSetForestTrustInformation	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	TrustedDomainName,
		IN PLSA_FOREST_TRUST_INFORMATION	ForestTrustInfo,
		IN BOOLEAN	CheckOnly,
		OUT PLSA_FOREST_TRUST_COLLISION_INFORMATION *	CollisionInfo
	)

Definition at line 1913 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaSetForestTrustInformation(%p %p %p %d %p)\n",
          PolicyHandle, TrustedDomainName, ForestTrustInfo, CheckOnly, CollisionInfo);
 
    RpcTryExcept
    {
        Status = LsarSetForestTrustInformation((LSAPR_HANDLE)PolicyHandle,
                                               TrustedDomainName,
                                               ForestTrustDomainInfo,
                                               ForestTrustInfo,
                                               CheckOnly,
                                               CollisionInfo);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaSetInformationPolicy()

NTSTATUS WINAPI LsaSetInformationPolicy	(	IN LSA_HANDLE	PolicyHandle,
		IN POLICY_INFORMATION_CLASS	InformationClass,
		IN PVOID	Buffer
	)

Definition at line 1948 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaSetInformationPolicy(%p %d %p)\n",
          PolicyHandle, InformationClass, Buffer);
 
    RpcTryExcept
    {
        Status = LsarSetInformationPolicy((LSAPR_HANDLE)PolicyHandle,
                                          InformationClass,
                                          (PLSAPR_POLICY_INFORMATION)Buffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

Referenced by ApplyAuditEvents(), NetpSetPrimaryDomain(), SetAccountsDomainSid(), and SetPrimaryDomain().

LsaSetInformationTrustedDomain()

NTSTATUS WINAPI LsaSetInformationTrustedDomain	(	IN LSA_HANDLE	TrustedDomainHandle,
		IN TRUSTED_INFORMATION_CLASS	InformationClass,
		IN PVOID	Buffer
	)

Definition at line 1978 of file lsa.c.

{
    FIXME("LsaSetInformationTrustedDomain(%p %d %p)\n",
          TrustedDomainHandle, InformationClass, Buffer);
    return STATUS_NOT_IMPLEMENTED;
}

LsaSetQuotasForAccount()

NTSTATUS WINAPI LsaSetQuotasForAccount	(	IN LSA_HANDLE	AccountHandle,
		IN PQUOTA_LIMITS	QuotaLimits
	)

Definition at line 1993 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaSetQuotasForAccount(%p %p)\n",
          AccountHandle, QuotaLimits);
 
    RpcTryExcept
    {
        Status = LsarSetQuotasForAccount((LSAPR_HANDLE)AccountHandle,
                                         QuotaLimits);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaSetSecret()

NTSTATUS WINAPI LsaSetSecret	(	IN LSA_HANDLE	SecretHandle,
		IN PLSA_UNICODE_STRING CurrentValue	OPTIONAL,
		IN PLSA_UNICODE_STRING OldValue	OPTIONAL
	)

Definition at line 2021 of file lsa.c.

{
    PLSAPR_CR_CIPHER_VALUE EncryptedCurrentValue = NULL;
    PLSAPR_CR_CIPHER_VALUE EncryptedOldValue = NULL;
    SIZE_T BufferSize;
    NTSTATUS Status;
 
    TRACE("LsaSetSecret(%p %p %p)\n",
          SecretHandle, EncryptedCurrentValue, EncryptedOldValue);
 
    if (CurrentValue != NULL)
    {
        BufferSize = sizeof(LSAPR_CR_CIPHER_VALUE) + CurrentValue->MaximumLength;
        EncryptedCurrentValue = midl_user_allocate(BufferSize);
        if (EncryptedCurrentValue == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto done;
        }
 
        EncryptedCurrentValue->Length = CurrentValue->Length;
        EncryptedCurrentValue->MaximumLength = CurrentValue->MaximumLength;
        EncryptedCurrentValue->Buffer = (BYTE *)(EncryptedCurrentValue + 1);
        if (EncryptedCurrentValue->Buffer != NULL)
            memcpy(EncryptedCurrentValue->Buffer, CurrentValue->Buffer, CurrentValue->Length);
    }
 
    if (OldValue != NULL)
    {
        BufferSize = sizeof(LSAPR_CR_CIPHER_VALUE) + OldValue->MaximumLength;
        EncryptedOldValue = midl_user_allocate(BufferSize);
        if (EncryptedOldValue == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto done;
        }
 
        EncryptedOldValue->Length = OldValue->Length;
        EncryptedOldValue->MaximumLength = OldValue->MaximumLength;
        EncryptedOldValue->Buffer = (BYTE*)(EncryptedOldValue + 1);
        if (EncryptedOldValue->Buffer != NULL)
            memcpy(EncryptedOldValue->Buffer, OldValue->Buffer, OldValue->Length);
    }
 
    RpcTryExcept
    {
        Status = LsarSetSecret((LSAPR_HANDLE)SecretHandle,
                               EncryptedCurrentValue,
                               EncryptedOldValue);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
done:
    if (EncryptedCurrentValue != NULL)
        midl_user_free(EncryptedCurrentValue);
 
    if (EncryptedOldValue != NULL)
        midl_user_free(EncryptedOldValue);
 
    return Status;
}

LsaSetSecurityObject()

NTSTATUS WINAPI LsaSetSecurityObject	(	IN LSA_HANDLE	ObjectHandle,
		IN SECURITY_INFORMATION	SecurityInformation,
		IN PSECURITY_DESCRIPTOR	SecurityDescriptor
	)

Definition at line 2095 of file lsa.c.

{
    LSAPR_SR_SECURITY_DESCRIPTOR SdBuffer = {0, NULL};
    ULONG SdLength = 0;
    NTSTATUS Status;
 
    TRACE("LsaSetSecurityObject(%p %lx %p)\n",
          ObjectHandle, SecurityInformation, SecurityDescriptor);
 
    Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
                                   NULL,
                                   &SdLength);
    if (Status != STATUS_BUFFER_TOO_SMALL)
        return STATUS_INVALID_PARAMETER;
 
    SdBuffer.SecurityDescriptor = MIDL_user_allocate(SdLength);
    if (SdBuffer.SecurityDescriptor == NULL)
        return STATUS_INSUFFICIENT_RESOURCES;
 
    Status = RtlMakeSelfRelativeSD(SecurityDescriptor,
                                   (PSECURITY_DESCRIPTOR)SdBuffer.SecurityDescriptor,
                                   &SdLength);
    if (!NT_SUCCESS(Status))
        goto done;
 
    SdBuffer.Length = SdLength;
 
    RpcTryExcept
    {
        Status = LsarSetSecurityObject((LSAPR_HANDLE)ObjectHandle,
                                       SecurityInformation,
                                       &SdBuffer);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
done:
    if (SdBuffer.SecurityDescriptor != NULL)
        MIDL_user_free(SdBuffer.SecurityDescriptor);
 
    return Status;
}

LsaSetSystemAccessAccount()

NTSTATUS WINAPI LsaSetSystemAccessAccount	(	IN LSA_HANDLE	AccountHandle,
		IN ULONG	SystemAccess
	)

Definition at line 2149 of file lsa.c.

{
    NTSTATUS Status;
 
    TRACE("LsaSetSystemAccessAccount(%p 0x%lx)\n",
          AccountHandle, SystemAccess);
 
    RpcTryExcept
    {
        Status = LsarSetSystemAccessAccount((LSAPR_HANDLE)AccountHandle,
                                            SystemAccess);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
    return Status;
}

LsaSetTrustedDomainInfoByName()

NTSTATUS WINAPI LsaSetTrustedDomainInfoByName	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	TrustedDomainName,
		IN TRUSTED_INFORMATION_CLASS	InformationClass,
		IN PVOID	Buffer
	)

Definition at line 2177 of file lsa.c.

{
    FIXME("LsaSetTrustedDomainInfoByName(%p %p %d %p) stub\n",
          PolicyHandle, TrustedDomainName, InformationClass, Buffer);
    return STATUS_SUCCESS;
}

LsaSetTrustedDomainInformation()

NTSTATUS WINAPI LsaSetTrustedDomainInformation	(	IN LSA_HANDLE	PolicyHandle,
		IN PSID	TrustedDomainSid,
		IN TRUSTED_INFORMATION_CLASS	InformationClass,
		IN PVOID	Buffer
	)

Definition at line 2193 of file lsa.c.

{
    FIXME("LsaSetTrustedDomainInformation(%p %p %d %p) stub\n",
          PolicyHandle, TrustedDomainSid, InformationClass, Buffer);
    return STATUS_SUCCESS;
}

LsaStorePrivateData()

NTSTATUS WINAPI LsaStorePrivateData	(	IN LSA_HANDLE	PolicyHandle,
		IN PLSA_UNICODE_STRING	KeyName,
		IN PLSA_UNICODE_STRING PrivateData	OPTIONAL
	)

Definition at line 2209 of file lsa.c.

{
    PLSAPR_CR_CIPHER_VALUE EncryptedData = NULL;
    SIZE_T BufferSize;
    NTSTATUS Status;
 
    TRACE("LsaStorePrivateData(%p %p %p)\n",
          PolicyHandle, KeyName, PrivateData);
 
    if (PrivateData != NULL)
    {
        BufferSize = sizeof(LSAPR_CR_CIPHER_VALUE) + PrivateData->MaximumLength;
        EncryptedData = midl_user_allocate(BufferSize);
        if (EncryptedData == NULL)
        {
            Status = STATUS_INSUFFICIENT_RESOURCES;
            goto done;
        }
 
        EncryptedData->Length = PrivateData->Length;
        EncryptedData->MaximumLength = PrivateData->MaximumLength;
        EncryptedData->Buffer = (BYTE *)(EncryptedData + 1);
        if (EncryptedData->Buffer != NULL)
            RtlCopyMemory(EncryptedData->Buffer,
                          PrivateData->Buffer,
                          PrivateData->Length);
    }
 
    RpcTryExcept
    {
        Status = LsarStorePrivateData((LSAPR_HANDLE)PolicyHandle,
                                      (PRPC_UNICODE_STRING)KeyName,
                                      EncryptedData);
    }
    RpcExcept(EXCEPTION_EXECUTE_HANDLER)
    {
        Status = I_RpcMapWin32Status(RpcExceptionCode());
    }
    RpcEndExcept;
 
done:
    if (EncryptedData != NULL)
        midl_user_free(EncryptedData);
 
    return Status;
}

Referenced by ScmSetServicePassword().

PLSAPR_SERVER_NAME_bind()

handle_t __RPC_USER PLSAPR_SERVER_NAME_bind

(

PLSAPR_SERVER_NAME

pszSystemName

)

Definition at line 45 of file lsa.c.

{
    handle_t hBinding = NULL;
    LPWSTR pszStringBinding;
    RPC_STATUS status;
 
    TRACE("PLSAPR_SERVER_NAME_bind() called\n");
 
    status = RpcStringBindingComposeW(NULL,
                                      L"ncacn_np",
                                      pszSystemName,
                                      L"\\pipe\\lsarpc",
                                      NULL,
                                      &pszStringBinding);
    if (status)
    {
        TRACE("RpcStringBindingCompose returned 0x%x\n", status);
        return NULL;
    }
 
    /* Set the binding handle that will be used to bind to the server. */
    status = RpcBindingFromStringBindingW(pszStringBinding,
                                          &hBinding);
    if (status)
    {
        TRACE("RpcBindingFromStringBinding returned 0x%x\n", status);
    }
 
    status = RpcStringFreeW(&pszStringBinding);
    if (status)
    {
        TRACE("RpcStringFree returned 0x%x\n", status);
    }
 
    return hBinding;
}

PLSAPR_SERVER_NAME_unbind()

void __RPC_USER PLSAPR_SERVER_NAME_unbind	(	PLSAPR_SERVER_NAME	pszSystemName,
		handle_t	hBinding
	)

Definition at line 85 of file lsa.c.

{
    RPC_STATUS status;
 
    TRACE("PLSAPR_SERVER_NAME_unbind() called\n");
 
    status = RpcBindingFree(&hBinding);
    if (status)
    {
        TRACE("RpcBindingFree returned 0x%x\n", status);
    }
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

advapi

)