/* * @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; }