/*
* @implemented
*/
NTSTATUS
WINAPI
LsaLookupPrivilegeName(IN LSA_HANDLE PolicyHandle,
IN PLUID Value,
OUT PUNICODE_STRING *Name)
{
PRPC_UNICODE_STRING NameBuffer = NULL;
NTSTATUS Status;
TRACE("(%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;
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaLookupPrivilegeValue(IN LSA_HANDLE PolicyHandle,
IN PLSA_UNICODE_STRING Name,
OUT PLUID Value)
{
LUID Luid;
NTSTATUS Status;
TRACE("(%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;
}
NET_API_STATUS
WINAPI
NetWkstaUserSetInfo(
LPWSTR reserved,
DWORD level,
LPBYTE buf,
LPDWORD parm_err)
{
NET_API_STATUS status;
TRACE("NetWkstaSetInfo(%s, %d, %p, %p)\n", debugstr_w(reserved),
level, buf, parm_err);
if (reserved != NULL)
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
status = NetrWkstaUserSetInfo(NULL,
level,
(LPWKSTA_USER_INFO)&buf,
parm_err);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetWkstaTransportDel(
LPWSTR servername,
LPWSTR transportname,
DWORD ucond)
{
NET_API_STATUS status;
TRACE("NetWkstaTransportDel(%s, %s, %d)\n", debugstr_w(servername),
debugstr_w(transportname), ucond);
RpcTryExcept
{
status = NetrWkstaTransportDel(servername,
transportname,
ucond);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetUseGetInfo(
LMSTR UncServerName,
LMSTR UseName,
DWORD Level,
LPBYTE *BufPtr)
{
NET_API_STATUS status;
TRACE("NetUseGetInfo(%s, %s, %d, %p)\n", debugstr_w(UncServerName),
debugstr_w(UseName), Level, BufPtr);
*BufPtr = NULL;
RpcTryExcept
{
status = NetrUseGetInfo(UncServerName,
UseName,
Level,
(LPUSE_INFO)BufPtr);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetScheduleJobAdd(
LPCWSTR ServerName,
LPBYTE Buffer,
LPDWORD JobId)
{
NET_API_STATUS status;
TRACE("NetScheduleJobAdd(%s, %p, %p)\n", debugstr_w(ServerName),
Buffer, JobId);
RpcTryExcept
{
status = NetrJobAdd(ServerName,
(LPAT_INFO)Buffer,
JobId);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetRemoteTOD(
LPCWSTR UncServerName,
LPBYTE *BufferPtr)
{
NET_API_STATUS status;
TRACE("NetRemoteTOD(%s, %p)\n", debugstr_w(UncServerName),
BufferPtr);
*BufferPtr = NULL;
RpcTryExcept
{
status = NetrRemoteTOD((SRVSVC_HANDLE)UncServerName,
(LPTIME_OF_DAY_INFO *)BufferPtr);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetScheduleJobDel(
LPCWSTR ServerName,
DWORD MinJobId,
DWORD MaxJobId)
{
NET_API_STATUS status;
TRACE("NetScheduleJobDel(%s, %d, %d)\n", debugstr_w(ServerName),
MinJobId, MaxJobId);
RpcTryExcept
{
status = NetrJobDel(ServerName,
MinJobId,
MaxJobId);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetScheduleJobGetInfo(
LPCWSTR ServerName,
DWORD JobId,
LPBYTE *PointerToBuffer)
{
NET_API_STATUS status;
TRACE("NetScheduleJobGetInfo(%s, %d, %p)\n", debugstr_w(ServerName),
JobId, PointerToBuffer);
RpcTryExcept
{
status = NetrJobGetInfo(ServerName,
JobId,
(LPAT_INFO *)PointerToBuffer);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaOpenAccount(IN LSA_HANDLE PolicyHandle,
IN PSID AccountSid,
IN ULONG Flags,
OUT PLSA_HANDLE AccountHandle)
{
NTSTATUS Status;
TRACE("(%p,%p,0x%08x,%p)\n", PolicyHandle, AccountSid, Flags, AccountHandle);
RpcTryExcept
{
Status = LsarOpenAccount((LSAPR_HANDLE)PolicyHandle,
AccountSid,
Flags,
AccountHandle);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
Status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return Status;
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaCreateTrustedDomain(IN LSA_HANDLE PolicyHandle,
IN PLSA_TRUST_INFORMATION TrustedDomainInformation,
IN ACCESS_MASK DesiredAccess,
OUT PLSA_HANDLE TrustedDomainHandle)
{
NTSTATUS Status;
TRACE("(%p,%p,0x%08x,%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;
}
NET_API_STATUS
WINAPI
NetWkstaGetInfo(
LPWSTR servername,
DWORD level,
LPBYTE *bufptr)
{
NET_API_STATUS status;
TRACE("NetWkstaGetInfo(%s, %d, %p)\n", debugstr_w(servername),
level, bufptr);
if (bufptr == NULL)
return ERROR_INVALID_PARAMETER;
*bufptr = NULL;
RpcTryExcept
{
status = NetrWkstaGetInfo(servername,
level,
(LPWKSTA_INFO)bufptr);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetUseDel(
LMSTR UncServerName,
LMSTR UseName,
DWORD ForceCond)
{
NET_API_STATUS status;
TRACE("NetUseDel(%s %s %d)\n", debugstr_w(UncServerName),
debugstr_w(UseName), ForceCond);
RpcTryExcept
{
status = NetrUseDel(UncServerName,
UseName,
ForceCond);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaRemoveAccountRights(IN LSA_HANDLE PolicyHandle,
IN PSID AccountSid,
IN BOOLEAN AllRights,
IN PLSA_UNICODE_STRING UserRights,
IN ULONG CountOfRights)
{
LSAPR_USER_RIGHT_SET UserRightSet;
NTSTATUS Status;
TRACE("(%p,%p,%d,%p,0x%08x) stub\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_SUCCESS;
}
/******************************************************************************
* DeregisterEventSource [ADVAPI32.@]
* Closes a handle to the specified event log
*
* PARAMS
* hEventLog [I] Handle to event log
*
* RETURNS STD
*/
BOOL WINAPI
DeregisterEventSource(IN HANDLE hEventLog)
{
NTSTATUS Status;
TRACE("%p\n", hEventLog);
RpcTryExcept
{
Status = ElfrDeregisterEventSource(&hEventLog);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
Status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return FALSE;
}
return TRUE;
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaQueryTrustedDomainInfoByName(IN LSA_HANDLE PolicyHandle,
IN PLSA_UNICODE_STRING TrustedDomainName,
IN TRUSTED_INFORMATION_CLASS InformationClass,
OUT PVOID *Buffer)
{
NTSTATUS Status;
TRACE("(%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,
(unsigned long *)Buffer); // Shuld be: (PLSAPR_POLICY_INFORMATION *)Buffer
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
Status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return Status;
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaQueryInformationPolicy(IN LSA_HANDLE PolicyHandle,
IN POLICY_INFORMATION_CLASS InformationClass,
OUT PVOID *Buffer)
{
PLSAPR_POLICY_INFORMATION PolicyInformation = NULL;
NTSTATUS Status;
TRACE("(%p,0x%08x,%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;
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaOpenTrustedDomainByName(IN LSA_HANDLE PolicyHandle,
IN PLSA_UNICODE_STRING TrustedDomainName,
IN ACCESS_MASK DesiredAccess,
OUT PLSA_HANDLE TrustedDomainHandle)
{
NTSTATUS Status;
TRACE("(%p,%p,0x%08x,%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;
}
NET_API_STATUS
NET_API_FUNCTION
NetGetJoinInformation(
LPCWSTR Server,
LPWSTR *Name,
PNETSETUP_JOIN_STATUS type)
{
NET_API_STATUS status;
TRACE("NetGetJoinInformation(%s %p %p)\n", debugstr_w(Server),
Name, type);
if (Name == NULL || type == NULL)
return ERROR_INVALID_PARAMETER;
RpcTryExcept
{
status = NetrGetJoinInformation((LPWSTR)Server,
Name,
type);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetWkstaTransportAdd(
LPWSTR servername,
DWORD level,
LPBYTE buf,
LPDWORD parm_err)
{
NET_API_STATUS status;
TRACE("NetWkstaTransportAdd(%s, %d, %p, %p)\n", debugstr_w(servername),
level, buf, parm_err);
RpcTryExcept
{
status = NetrWkstaTransportAdd(servername,
level,
(LPWKSTA_TRANSPORT_INFO_0)buf,
parm_err);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
NET_API_STATUS
WINAPI
NetUseAdd(
LMSTR UncServerName,
DWORD Level,
LPBYTE Buf,
LPDWORD ParmError)
{
NET_API_STATUS status;
TRACE("NetUseAdd(%s %d %p %p)\n", debugstr_w(UncServerName),
Level, Buf, ParmError);
RpcTryExcept
{
status = NetrUseAdd(UncServerName,
Level,
(LPUSE_INFO)Buf,
ParmError);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
/******************************************************************************
* RegisterEventSourceW [ADVAPI32.@]
* Returns a registered handle to an event log
*
* PARAMS
* lpUNCServerName [I] Server name for source
* lpSourceName [I] Source name for registered handle
*
* RETURNS
* Success: Handle
* Failure: NULL
*/
HANDLE WINAPI
RegisterEventSourceW(IN LPCWSTR lpUNCServerName,
IN LPCWSTR lpSourceName)
{
UNICODE_STRING SourceName;
IELF_HANDLE LogHandle;
NTSTATUS Status;
TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
RtlInitUnicodeString(&SourceName, lpSourceName);
RpcTryExcept
{
Status = ElfrRegisterEventSourceW((LPWSTR)lpUNCServerName,
(PRPC_UNICODE_STRING)&SourceName,
&EmptyStringU,
1,
1,
&LogHandle);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
Status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return NULL;
}
return (HANDLE)LogHandle;
}
NTSTATUS
NTAPI
RpcpStartRpcServer (
_In_ LPCWSTR IfName,
_In_ RPC_IF_HANDLE IfSpec
)
{
NTSTATUS ntStatus;
/* Acquire the lock while we instantiate a new interface */
EnterCriticalSection(&RpcpCriticalSection);
/* Add this interface to the service */
ntStatus = RpcpAddInterface(IfName, IfSpec);
if (!ntStatus)
{
/* Increment the reference count to see if this was the first interface */
if (++RpcpNumInstances == 1)
{
/* It was, so put the server into listening mode now */
ntStatus = RpcServerListen(1, 12345, TRUE);
if (ntStatus == RPC_S_ALREADY_LISTENING) ntStatus = STATUS_SUCCESS;
}
}
/* Release the lock and return back the result to the caller */
LeaveCriticalSection(&RpcpCriticalSection);
return I_RpcMapWin32Status(ntStatus);
}
NET_API_STATUS
WINAPI
NetWkstaTransportEnum(
LPWSTR servername,
DWORD level,
LPBYTE *bufptr,
DWORD prefmaxlen,
LPDWORD entriesread,
LPDWORD totalentries,
LPDWORD resumehandle)
{
WKSTA_TRANSPORT_ENUM_STRUCT TransportEnumInfo;
WKSTA_TRANSPORT_INFO_0_CONTAINER Container0;
NET_API_STATUS status;
TRACE("NetWkstaTransportEnum(%s, %d, %p, %d, %p, %p, %p)\n", debugstr_w(servername),
level, bufptr, prefmaxlen, entriesread, totalentries, resumehandle);
TransportEnumInfo.Level = level;
switch (level)
{
case 0:
TransportEnumInfo.WkstaTransportInfo.Level0 = &Container0;
Container0.EntriesRead = 0;
Container0.Buffer = NULL;
break;
default:
return ERROR_INVALID_PARAMETER;
}
RpcTryExcept
{
status = NetrWkstaTransportEnum(servername,
&TransportEnumInfo,
prefmaxlen,
totalentries,
resumehandle);
if (status == NERR_Success || status == ERROR_MORE_DATA)
{
switch (level)
{
case 0:
*bufptr = (LPBYTE)TransportEnumInfo.WkstaTransportInfo.Level0->Buffer;
*entriesread = TransportEnumInfo.WkstaTransportInfo.Level0->EntriesRead;
break;
}
}
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
return status;
}
/* Function 10 */
NTSTATUS ElfrReadELW(
IELF_HANDLE LogHandle,
DWORD ReadFlags,
DWORD RecordOffset,
RULONG NumberOfBytesToRead,
BYTE *Buffer,
DWORD *NumberOfBytesRead,
DWORD *MinNumberOfBytesNeeded)
{
PLOGHANDLE lpLogHandle;
DWORD dwError;
DWORD RecordNumber;
lpLogHandle = ElfGetLogHandleEntryByHandle(LogHandle);
if (!lpLogHandle)
{
return STATUS_INVALID_HANDLE;
}
if (!Buffer)
return I_RpcMapWin32Status(ERROR_INVALID_PARAMETER);
/* If sequential read, retrieve the CurrentRecord from this log handle */
if (ReadFlags & EVENTLOG_SEQUENTIAL_READ)
{
RecordNumber = lpLogHandle->CurrentRecord;
}
else
{
RecordNumber = RecordOffset;
}
dwError = LogfReadEvent(lpLogHandle->LogFile, ReadFlags, &RecordNumber,
NumberOfBytesToRead, Buffer, NumberOfBytesRead, MinNumberOfBytesNeeded);
/* Update the handles CurrentRecord if success*/
if (dwError == ERROR_SUCCESS)
{
lpLogHandle->CurrentRecord = RecordNumber;
}
return I_RpcMapWin32Status(dwError);
}
NTSTATUS
LsapActivateRpcServer( VOID )
/*++
Routine Description:
This function creates a thread for the RPC server.
The new Thread then goes on to activate the RPC server,
which causes RPC calls to be delivered when recieved.
Arguments:
None.
Return Value:
STATUS_SUCCESS - The thread was successfully created.
Other status values that may be set by CreateThread().
--*/
{
NTSTATUS Status;
ULONG WaitCount = 0;
// Start listening for remote procedure calls. The first
// argument to RpcServerListen is the minimum number of call
// threads to create; the second argument is the maximum number
// of concurrent calls allowed. The final argument indicates that
// this routine should not wait. After everything has been initialized,
// we return.
Status = I_RpcMapWin32Status(RpcServerListen(1, 1234, 1));
ASSERT( Status == RPC_S_OK );
//
// Set event which signals that RPC server is available.
//
LsapSignalRpcIsActive();
return(STATUS_SUCCESS);
}
/*
* @implemented
*/
NTSTATUS
WINAPI
LsaLookupSids(IN LSA_HANDLE PolicyHandle,
IN ULONG Count,
IN PSID *Sids,
OUT PLSA_REFERENCED_DOMAIN_LIST *ReferencedDomains,
OUT PLSA_TRANSLATED_NAME *Names)
{
LSAPR_SID_ENUM_BUFFER SidEnumBuffer;
LSAPR_TRANSLATED_NAMES TranslatedNames;
ULONG MappedCount = 0;
NTSTATUS Status;
TRACE("(%p,%u,%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;
}
/*
* @implemented
*/
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)
{
LSAPR_TRANSLATED_SIDS_EX2 TranslatedSids = {0, NULL};
ULONG MappedCount = 0;
NTSTATUS Status;
TRACE("(%p,0x%08x,0x%08x,%p,%p,%p) stub\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;
}
/******************************************************************************
* OpenBackupEventLogW [ADVAPI32.@]
*
* PARAMS
* lpUNCServerName []
* lpFileName []
*/
HANDLE WINAPI
OpenBackupEventLogW(IN LPCWSTR lpUNCServerName,
IN LPCWSTR lpFileName)
{
UNICODE_STRING FileNameW;
IELF_HANDLE LogHandle;
NTSTATUS Status;
TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpFileName));
if (lpFileName == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
if (!RtlDosPathNameToNtPathName_U(lpFileName, &FileNameW,
NULL, NULL))
{
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
RpcTryExcept
{
Status = ElfrOpenBELW((LPWSTR)lpUNCServerName,
(PRPC_UNICODE_STRING)&FileNameW,
1,
1,
&LogHandle);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
Status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
if (FileNameW.Buffer != NULL)
RtlFreeHeap(RtlGetProcessHeap(), 0, FileNameW.Buffer);
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return NULL;
}
return (HANDLE)LogHandle;
}
/******************************************************************************
* OpenEventLogW [ADVAPI32.@]
*
* PARAMS
* lpUNCServerName []
* lpSourceName []
*/
HANDLE WINAPI
OpenEventLogW(IN LPCWSTR lpUNCServerName,
IN LPCWSTR lpSourceName)
{
LPWSTR UNCServerName;
UNICODE_STRING SourceName;
IELF_HANDLE LogHandle;
NTSTATUS Status;
TRACE("%s, %s\n", debugstr_w(lpUNCServerName), debugstr_w(lpSourceName));
if (lpSourceName == NULL)
{
SetLastError(ERROR_INVALID_PARAMETER);
return NULL;
}
if (lpUNCServerName == NULL || *lpUNCServerName == 0)
UNCServerName = NULL;
else
UNCServerName = (LPWSTR)lpUNCServerName;
RtlInitUnicodeString(&SourceName, lpSourceName);
RpcTryExcept
{
Status = ElfrOpenELW(UNCServerName,
(PRPC_UNICODE_STRING)&SourceName,
&EmptyStringU,
1,
1,
&LogHandle);
}
RpcExcept(EXCEPTION_EXECUTE_HANDLER)
{
Status = I_RpcMapWin32Status(RpcExceptionCode());
}
RpcEndExcept;
if (!NT_SUCCESS(Status))
{
SetLastError(RtlNtStatusToDosError(Status));
return NULL;
}
return (HANDLE)LogHandle;
}
