/*++ Copyright (c) 1990 Microsoft Corporation Module Name: trcapi.c Abstract: This module contains implementations of win32 api's used in wmi files. Author: Revision History: --*/ #include #include "wmiump.h" #include "trcapi.h" DWORD g_dwLastErrorToBreakOn = ERROR_SUCCESS; UNICODE_STRING BasePathVariableName = RTL_CONSTANT_STRING(L"PATH"); #define TLS_MASK 0x80000000 #define TMP_TAG 0 #define IsActiveConsoleSession() (USER_SHARED_DATA->ActiveConsoleId == NtCurrentPeb()->SessionId) #if defined(_WIN64) || defined(BUILD_WOW6432) SYSTEM_BASIC_INFORMATION SysInfo; #endif extern BOOLEAN CsrServerProcess; DWORD WmipGetLastError( VOID ) /*++ Routine Description: This function returns the most recent error code set by a Win32 API call. Applications should call this function immediately after a Win32 API call returns a failure indications (e.g. FALSE, NULL or -1) to determine the cause of the failure. The last error code value is a per thread field, so that multiple threads do not overwrite each other's last error code value. Arguments: None. Return Value: The return value is the most recent error code as set by a Win32 API call. --*/ { return (DWORD)NtCurrentTeb()->LastErrorValue; } VOID WmipSetLastError( DWORD dwErrCode ) /*++ Routine Description: This function set the most recent error code and error string in per thread storage. Win32 API functions call this function whenever they return a failure indication (e.g. FALSE, NULL or -1). This function is not called by Win32 API function calls that are successful, so that if three Win32 API function calls are made, and the first one fails and the second two succeed, the error code and string stored by the first one are still available after the second two succeed. Applications can retrieve the values saved by this function using WmipGetLastError. The use of this function is optional, as an application need only call if it is interested in knowing the specific reason for an API function failure. The last error code value is kept in thread local storage so that multiple threads do not overwrite each other's values. Arguments: dwErrCode - Specifies the error code to store in per thread storage for the current thread. Return Value: return-value - Description of conditions needed to return value. - or - None. --*/ { PTEB Teb = NtCurrentTeb(); if ((g_dwLastErrorToBreakOn != ERROR_SUCCESS) && (dwErrCode == g_dwLastErrorToBreakOn)) { DbgBreakPoint(); } // make write breakpoints to this field more meaningful by only writing to it when // the value changes. if (Teb->LastErrorValue != dwErrCode) { Teb->LastErrorValue = dwErrCode; } } DWORD WINAPI WmipGetTimeZoneInformation( LPTIME_ZONE_INFORMATION lpTimeZoneInformation ) /*++ Routine Description: This function allows an application to get the current timezone parameters These parameters control the Universal time to Local time translations. All UTC time to Local time translations are based on the following formula: UTC = LocalTime + Bias The return value of this function is the systems best guess of the current time zone parameters. This is one of: - Unknown - Standard Time - Daylight Savings Time If SetTimeZoneInformation was called without the transition date information, Unknown is returned, but the currect bias is used for local time translation. Otherwise, the system will correctly pick either daylight savings time or standard time. The information returned by this API is identical to the information stored in the last successful call to SetTimeZoneInformation. The exception is the Bias field returns the current Bias value in Arguments: lpTimeZoneInformation - Supplies the address of the time zone information structure. Return Value: TIME_ZONE_ID_UNKNOWN - The system can not determine the current timezone. This is usually due to a previous call to SetTimeZoneInformation where only the Bias was supplied and no transition dates were supplied. TIME_ZONE_ID_STANDARD - The system is operating in the range covered by StandardDate. TIME_ZONE_ID_DAYLIGHT - The system is operating in the range covered by DaylightDate. 0xffffffff - The operation failed. Extended error status is available using WmipGetLastError. --*/ { RTL_TIME_ZONE_INFORMATION tzi; NTSTATUS Status; // // get the timezone data from the system // If it's terminal server session use client time zone Status = NtQuerySystemInformation( SystemCurrentTimeZoneInformation, &tzi, sizeof(tzi), NULL ); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); return 0xffffffff; } lpTimeZoneInformation->Bias = tzi.Bias; lpTimeZoneInformation->StandardBias = tzi.StandardBias; lpTimeZoneInformation->DaylightBias = tzi.DaylightBias; RtlMoveMemory(&lpTimeZoneInformation->StandardName,&tzi.StandardName,sizeof(tzi.StandardName)); RtlMoveMemory(&lpTimeZoneInformation->DaylightName,&tzi.DaylightName,sizeof(tzi.DaylightName)); lpTimeZoneInformation->StandardDate.wYear = tzi.StandardStart.Year ; lpTimeZoneInformation->StandardDate.wMonth = tzi.StandardStart.Month ; lpTimeZoneInformation->StandardDate.wDayOfWeek = tzi.StandardStart.Weekday ; lpTimeZoneInformation->StandardDate.wDay = tzi.StandardStart.Day ; lpTimeZoneInformation->StandardDate.wHour = tzi.StandardStart.Hour ; lpTimeZoneInformation->StandardDate.wMinute = tzi.StandardStart.Minute ; lpTimeZoneInformation->StandardDate.wSecond = tzi.StandardStart.Second ; lpTimeZoneInformation->StandardDate.wMilliseconds = tzi.StandardStart.Milliseconds; lpTimeZoneInformation->DaylightDate.wYear = tzi.DaylightStart.Year ; lpTimeZoneInformation->DaylightDate.wMonth = tzi.DaylightStart.Month ; lpTimeZoneInformation->DaylightDate.wDayOfWeek = tzi.DaylightStart.Weekday ; lpTimeZoneInformation->DaylightDate.wDay = tzi.DaylightStart.Day ; lpTimeZoneInformation->DaylightDate.wHour = tzi.DaylightStart.Hour ; lpTimeZoneInformation->DaylightDate.wMinute = tzi.DaylightStart.Minute ; lpTimeZoneInformation->DaylightDate.wSecond = tzi.DaylightStart.Second ; lpTimeZoneInformation->DaylightDate.wMilliseconds = tzi.DaylightStart.Milliseconds; return USER_SHARED_DATA->TimeZoneId; } BOOL WINAPI WmipGetVersionExW( LPOSVERSIONINFOW lpVersionInformation ) { PPEB Peb; NTSTATUS Status; if (lpVersionInformation->dwOSVersionInfoSize != sizeof( OSVERSIONINFOEXW ) && lpVersionInformation->dwOSVersionInfoSize != sizeof( *lpVersionInformation ) ) { WmipSetLastError( ERROR_INSUFFICIENT_BUFFER ); return FALSE; } Status = RtlGetVersion(lpVersionInformation); if (Status == STATUS_SUCCESS) { Peb = NtCurrentPeb(); if (Peb->CSDVersion.Buffer) wcscpy( lpVersionInformation->szCSDVersion, Peb->CSDVersion.Buffer ); if (lpVersionInformation->dwOSVersionInfoSize == sizeof( OSVERSIONINFOEXW)) ((POSVERSIONINFOEXW)lpVersionInformation)->wReserved = (UCHAR)BaseRCNumber; return TRUE; } else { return FALSE; } } BOOL WINAPI WmipGetVersionExA( LPOSVERSIONINFOA lpVersionInformation ) { OSVERSIONINFOEXW VersionInformationU; ANSI_STRING AnsiString; UNICODE_STRING UnicodeString; NTSTATUS Status; if (lpVersionInformation->dwOSVersionInfoSize != sizeof( OSVERSIONINFOEXA ) && lpVersionInformation->dwOSVersionInfoSize != sizeof( *lpVersionInformation ) ) { WmipSetLastError( ERROR_INSUFFICIENT_BUFFER ); return FALSE; } VersionInformationU.dwOSVersionInfoSize = sizeof( VersionInformationU ); if (WmipGetVersionExW( (LPOSVERSIONINFOW)&VersionInformationU )) { lpVersionInformation->dwMajorVersion = VersionInformationU.dwMajorVersion; lpVersionInformation->dwMinorVersion = VersionInformationU.dwMinorVersion; lpVersionInformation->dwBuildNumber = VersionInformationU.dwBuildNumber; lpVersionInformation->dwPlatformId = VersionInformationU.dwPlatformId; if (lpVersionInformation->dwOSVersionInfoSize == sizeof( OSVERSIONINFOEXA )) { ((POSVERSIONINFOEXA)lpVersionInformation)->wServicePackMajor = VersionInformationU.wServicePackMajor; ((POSVERSIONINFOEXA)lpVersionInformation)->wServicePackMinor = VersionInformationU.wServicePackMinor; ((POSVERSIONINFOEXA)lpVersionInformation)->wSuiteMask = VersionInformationU.wSuiteMask; ((POSVERSIONINFOEXA)lpVersionInformation)->wProductType = VersionInformationU.wProductType; ((POSVERSIONINFOEXA)lpVersionInformation)->wReserved = VersionInformationU.wReserved; } AnsiString.Buffer = lpVersionInformation->szCSDVersion; AnsiString.Length = 0; AnsiString.MaximumLength = sizeof( lpVersionInformation->szCSDVersion ); RtlInitUnicodeString( &UnicodeString, VersionInformationU.szCSDVersion ); Status = RtlUnicodeStringToAnsiString( &AnsiString, &UnicodeString, FALSE ); if (NT_SUCCESS( Status )) { return TRUE; } else { return FALSE; } } else { return FALSE; } } ULONG WmipBaseSetLastNTError( IN NTSTATUS Status ) /*++ Routine Description: This API sets the "last error value" and the "last error string" based on the value of Status. For status codes that don't have a corresponding error string, the string is set to null. Arguments: Status - Supplies the status value to store as the last error value. Return Value: The corresponding Win32 error code that was stored in the "last error value" thread variable. --*/ { ULONG dwErrorCode; dwErrorCode = RtlNtStatusToDosError( Status ); WmipSetLastError( dwErrorCode ); return( dwErrorCode ); } PUNICODE_STRING WmipBasep8BitStringToStaticUnicodeString( IN LPCSTR lpSourceString ) /*++ Routine Description: Captures and converts a 8-bit (OEM or ANSI) string into the Teb Static Unicode String Arguments: lpSourceString - string in OEM or ANSI Return Value: Pointer to the Teb static string if conversion was successful, NULL otherwise. If a failure occurred, the last error is set. --*/ { PUNICODE_STRING StaticUnicode; ANSI_STRING AnsiString; NTSTATUS Status; // // Get pointer to static per-thread string // StaticUnicode = &NtCurrentTeb()->StaticUnicodeString; // // Convert input string into unicode string // RtlInitAnsiString( &AnsiString, lpSourceString ); //Status = Basep8BitStringToUnicodeString( StaticUnicode, &AnsiString, FALSE ); Status = RtlAnsiStringToUnicodeString( StaticUnicode, &AnsiString, FALSE ); // // If we couldn't convert the string // if ( !NT_SUCCESS( Status ) ) { if ( Status == STATUS_BUFFER_OVERFLOW ) { WmipSetLastError( ERROR_FILENAME_EXCED_RANGE ); } else { WmipBaseSetLastNTError( Status ); } return NULL; } else { return StaticUnicode; } } HANDLE WINAPI WmipCreateFileW( LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile ) /*++ Routine Description: A file can be created, opened, or truncated, and a handle opened to access the new file using CreateFile. This API is used to create or open a file and obtain a handle to it that allows reading data, writing data, and moving the file pointer. This API allows the caller to specify the following creation dispositions: - Create a new file and fail if the file exists ( CREATE_NEW ) - Create a new file and succeed if it exists ( CREATE_ALWAYS ) - Open an existing file ( OPEN_EXISTING ) - Open and existing file or create it if it does not exist ( OPEN_ALWAYS ) - Truncate and existing file ( TRUNCATE_EXISTING ) If this call is successful, a handle is returned that has appropriate access to the specified file. If as a result of this call, a file is created, - The attributes of the file are determined by the value of the FileAttributes parameter or'd with the FILE_ATTRIBUTE_ARCHIVE bit. - The length of the file will be set to zero. - If the hTemplateFile parameter is specified, any extended attributes associated with the file are assigned to the new file. If a new file is not created, then the hTemplateFile is ignored as are any extended attributes. For DOS based systems running share.exe the file sharing semantics work as described above. Without share.exe no share level protection exists. This call is logically equivalent to DOS (int 21h, function 5Bh), or DOS (int 21h, function 3Ch) depending on the value of the FailIfExists parameter. Arguments: lpFileName - Supplies the file name of the file to open. Depending on the value of the FailIfExists parameter, this name may or may not already exist. dwDesiredAccess - Supplies the caller's desired access to the file. DesiredAccess Flags: GENERIC_READ - Read access to the file is requested. This allows data to be read from the file and the file pointer to be modified. GENERIC_WRITE - Write access to the file is requested. This allows data to be written to the file and the file pointer to be modified. dwShareMode - Supplies a set of flags that indicates how this file is to be shared with other openers of the file. A value of zero for this parameter indicates no sharing of the file, or exclusive access to the file is to occur. ShareMode Flags: FILE_SHARE_READ - Other open operations may be performed on the file for read access. FILE_SHARE_WRITE - Other open operations may be performed on the file for write access. lpSecurityAttributes - An optional parameter that, if present, and supported on the target file system supplies a security descriptor for the new file. dwCreationDisposition - Supplies a creation disposition that specifies how this call is to operate. This parameter must be one of the following values. dwCreationDisposition Value: CREATE_NEW - Create a new file. If the specified file already exists, then fail. The attributes for the new file are what is specified in the dwFlagsAndAttributes parameter or'd with FILE_ATTRIBUTE_ARCHIVE. If the hTemplateFile is specified, then any extended attributes associated with that file are propogated to the new file. CREATE_ALWAYS - Always create the file. If the file already exists, then it is overwritten. The attributes for the new file are what is specified in the dwFlagsAndAttributes parameter or'd with FILE_ATTRIBUTE_ARCHIVE. If the hTemplateFile is specified, then any extended attributes associated with that file are propogated to the new file. OPEN_EXISTING - Open the file, but if it does not exist, then fail the call. OPEN_ALWAYS - Open the file if it exists. If it does not exist, then create the file using the same rules as if the disposition were CREATE_NEW. TRUNCATE_EXISTING - Open the file, but if it does not exist, then fail the call. Once opened, the file is truncated such that its size is zero bytes. This disposition requires that the caller open the file with at least GENERIC_WRITE access. dwFlagsAndAttributes - Specifies flags and attributes for the file. The attributes are only used when the file is created (as opposed to opened or truncated). Any combination of attribute flags is acceptable except that all other attribute flags override the normal file attribute, FILE_ATTRIBUTE_NORMAL. The FILE_ATTRIBUTE_ARCHIVE flag is always implied. dwFlagsAndAttributes Flags: FILE_ATTRIBUTE_NORMAL - A normal file should be created. FILE_ATTRIBUTE_READONLY - A read-only file should be created. FILE_ATTRIBUTE_HIDDEN - A hidden file should be created. FILE_ATTRIBUTE_SYSTEM - A system file should be created. FILE_FLAG_WRITE_THROUGH - Indicates that the system should always write through any intermediate cache and go directly to the file. The system may still cache writes, but may not lazily flush the writes. FILE_FLAG_OVERLAPPED - Indicates that the system should initialize the file so that ReadFile and WriteFile operations that may take a significant time to complete will return ERROR_IO_PENDING. An event will be set to the signalled state when the operation completes. When FILE_FLAG_OVERLAPPED is specified the system will not maintain the file pointer. The position to read/write from is passed to the system as part of the OVERLAPPED structure which is an optional parameter to ReadFile and WriteFile. FILE_FLAG_NO_BUFFERING - Indicates that the file is to be opened with no intermediate buffering or caching done by the system. Reads and writes to the file must be done on sector boundries. Buffer addresses for reads and writes must be aligned on at least disk sector boundries in memory. FILE_FLAG_RANDOM_ACCESS - Indicates that access to the file may be random. The system cache manager may use this to influence its caching strategy for this file. FILE_FLAG_SEQUENTIAL_SCAN - Indicates that access to the file may be sequential. The system cache manager may use this to influence its caching strategy for this file. The file may in fact be accessed randomly, but the cache manager may optimize its cacheing policy for sequential access. FILE_FLAG_DELETE_ON_CLOSE - Indicates that the file is to be automatically deleted when the last handle to it is closed. FILE_FLAG_BACKUP_SEMANTICS - Indicates that the file is being opened or created for the purposes of either a backup or a restore operation. Thus, the system should make whatever checks are appropriate to ensure that the caller is able to override whatever security checks have been placed on the file to allow this to happen. FILE_FLAG_POSIX_SEMANTICS - Indicates that the file being opened should be accessed in a manner compatible with the rules used by POSIX. This includes allowing multiple files with the same name, differing only in case. WARNING: Use of this flag may render it impossible for a DOS, WIN-16, or WIN-32 application to access the file. FILE_FLAG_OPEN_REPARSE_POINT - Indicates that the file being opened should be accessed as if it were a reparse point. WARNING: Use of this flag may inhibit the operation of file system filter drivers present in the I/O subsystem. FILE_FLAG_OPEN_NO_RECALL - Indicates that all the state of the file should be acessed without changing its storage location. Thus, in the case of files that have parts of its state stored at a remote servicer, no permanent recall of data is to happen. Security Quality of Service information may also be specified in the dwFlagsAndAttributes parameter. These bits are meaningful only if the file being opened is the client side of a Named Pipe. Otherwise they are ignored. SECURITY_SQOS_PRESENT - Indicates that the Security Quality of Service bits contain valid values. Impersonation Levels: SECURITY_ANONYMOUS - Specifies that the client should be impersonated at Anonymous impersonation level. SECURITY_IDENTIFICAION - Specifies that the client should be impersonated at Identification impersonation level. SECURITY_IMPERSONATION - Specifies that the client should be impersonated at Impersonation impersonation level. SECURITY_DELEGATION - Specifies that the client should be impersonated at Delegation impersonation level. Context Tracking: SECURITY_CONTEXT_TRACKING - A boolean flag that when set, specifies that the Security Tracking Mode should be Dynamic, otherwise Static. SECURITY_EFFECTIVE_ONLY - A boolean flag indicating whether the entire security context of the client is to be made available to the server or only the effective aspects of the context. hTemplateFile - An optional parameter, then if specified, supplies a handle with GENERIC_READ access to a template file. The template file is used to supply extended attributes for the file being created. When the new file is created, the relevant attributes from the template file are used in creating the new file. Return Value: Not -1 - Returns an open handle to the specified file. Subsequent access to the file is controlled by the DesiredAccess parameter. 0xffffffff - The operation failed. Extended error status is available using WmipGetLastError. --*/ { NTSTATUS Status; OBJECT_ATTRIBUTES Obja; HANDLE Handle; UNICODE_STRING FileName; IO_STATUS_BLOCK IoStatusBlock; BOOLEAN TranslationStatus; RTL_RELATIVE_NAME RelativeName; PVOID FreeBuffer; ULONG CreateDisposition; ULONG CreateFlags; FILE_ALLOCATION_INFORMATION AllocationInfo; FILE_EA_INFORMATION EaInfo; PFILE_FULL_EA_INFORMATION EaBuffer; ULONG EaSize; PUNICODE_STRING lpConsoleName; BOOL bInheritHandle; BOOL EndsInSlash; DWORD SQOSFlags; BOOLEAN ContextTrackingMode = FALSE; BOOLEAN EffectiveOnly = FALSE; SECURITY_IMPERSONATION_LEVEL ImpersonationLevel = 0; SECURITY_QUALITY_OF_SERVICE SecurityQualityOfService; switch ( dwCreationDisposition ) { case CREATE_NEW : CreateDisposition = FILE_CREATE; break; case CREATE_ALWAYS : CreateDisposition = FILE_OVERWRITE_IF; break; case OPEN_EXISTING : CreateDisposition = FILE_OPEN; break; case OPEN_ALWAYS : CreateDisposition = FILE_OPEN_IF; break; case TRUNCATE_EXISTING : CreateDisposition = FILE_OPEN; if ( !(dwDesiredAccess & GENERIC_WRITE) ) { WmipBaseSetLastNTError(STATUS_INVALID_PARAMETER); return INVALID_HANDLE_VALUE; } break; default : WmipBaseSetLastNTError(STATUS_INVALID_PARAMETER); return INVALID_HANDLE_VALUE; } // temporary routing code RtlInitUnicodeString(&FileName,lpFileName); if ( FileName.Length > 1 && lpFileName[(FileName.Length >> 1)-1] == (WCHAR)'\\' ) { EndsInSlash = TRUE; } else { EndsInSlash = FALSE; } /* if ((lpConsoleName = WmipBaseIsThisAConsoleName(&FileName,dwDesiredAccess)) ) { Handle = INVALID_HANDLE_VALUE; bInheritHandle = FALSE; if ( ARGUMENT_PRESENT(lpSecurityAttributes) ) { bInheritHandle = lpSecurityAttributes->bInheritHandle; } Handle = WmipOpenConsoleW(lpConsoleName, dwDesiredAccess, bInheritHandle, FILE_SHARE_READ | FILE_SHARE_WRITE //dwShareMode ); if ( Handle == INVALID_HANDLE_VALUE ) { WmipBaseSetLastNTError(STATUS_ACCESS_DENIED); return INVALID_HANDLE_VALUE; } else { WmipSetLastError(0); return Handle; } }*/ // end temporary code CreateFlags = 0; TranslationStatus = RtlDosPathNameToNtPathName_U( lpFileName, &FileName, NULL, &RelativeName ); if ( !TranslationStatus ) { WmipSetLastError(ERROR_PATH_NOT_FOUND); return INVALID_HANDLE_VALUE; } FreeBuffer = FileName.Buffer; if ( RelativeName.RelativeName.Length ) { FileName = *(PUNICODE_STRING)&RelativeName.RelativeName; } else { RelativeName.ContainingDirectory = NULL; } InitializeObjectAttributes( &Obja, &FileName, dwFlagsAndAttributes & FILE_FLAG_POSIX_SEMANTICS ? 0 : OBJ_CASE_INSENSITIVE, RelativeName.ContainingDirectory, NULL ); SQOSFlags = dwFlagsAndAttributes & SECURITY_VALID_SQOS_FLAGS; if ( SQOSFlags & SECURITY_SQOS_PRESENT ) { SQOSFlags &= ~SECURITY_SQOS_PRESENT; if (SQOSFlags & SECURITY_CONTEXT_TRACKING) { SecurityQualityOfService.ContextTrackingMode = (SECURITY_CONTEXT_TRACKING_MODE) TRUE; SQOSFlags &= ~SECURITY_CONTEXT_TRACKING; } else { SecurityQualityOfService.ContextTrackingMode = (SECURITY_CONTEXT_TRACKING_MODE) FALSE; } if (SQOSFlags & SECURITY_EFFECTIVE_ONLY) { SecurityQualityOfService.EffectiveOnly = TRUE; SQOSFlags &= ~SECURITY_EFFECTIVE_ONLY; } else { SecurityQualityOfService.EffectiveOnly = FALSE; } SecurityQualityOfService.ImpersonationLevel = SQOSFlags >> 16; } else { SecurityQualityOfService.ContextTrackingMode = SECURITY_DYNAMIC_TRACKING; SecurityQualityOfService.ImpersonationLevel = SecurityImpersonation; SecurityQualityOfService.EffectiveOnly = TRUE; } SecurityQualityOfService.Length = sizeof( SECURITY_QUALITY_OF_SERVICE ); Obja.SecurityQualityOfService = &SecurityQualityOfService; if ( ARGUMENT_PRESENT(lpSecurityAttributes) ) { Obja.SecurityDescriptor = lpSecurityAttributes->lpSecurityDescriptor; if ( lpSecurityAttributes->bInheritHandle ) { Obja.Attributes |= OBJ_INHERIT; } } EaBuffer = NULL; EaSize = 0; if ( ARGUMENT_PRESENT(hTemplateFile) ) { Status = NtQueryInformationFile( hTemplateFile, &IoStatusBlock, &EaInfo, sizeof(EaInfo), FileEaInformation ); if ( NT_SUCCESS(Status) && EaInfo.EaSize ) { EaSize = EaInfo.EaSize; do { EaSize *= 2; EaBuffer = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( TMP_TAG ), EaSize); if ( !EaBuffer ) { RtlFreeHeap(RtlProcessHeap(), 0, FreeBuffer); WmipBaseSetLastNTError(STATUS_NO_MEMORY); return INVALID_HANDLE_VALUE; } Status = NtQueryEaFile( hTemplateFile, &IoStatusBlock, EaBuffer, EaSize, FALSE, (PVOID)NULL, 0, (PULONG)NULL, TRUE ); if ( !NT_SUCCESS(Status) ) { RtlFreeHeap(RtlProcessHeap(), 0,EaBuffer); EaBuffer = NULL; IoStatusBlock.Information = 0; } } while ( Status == STATUS_BUFFER_OVERFLOW || Status == STATUS_BUFFER_TOO_SMALL ); EaSize = (ULONG)IoStatusBlock.Information; } } CreateFlags |= (dwFlagsAndAttributes & FILE_FLAG_NO_BUFFERING ? FILE_NO_INTERMEDIATE_BUFFERING : 0 ); CreateFlags |= (dwFlagsAndAttributes & FILE_FLAG_WRITE_THROUGH ? FILE_WRITE_THROUGH : 0 ); CreateFlags |= (dwFlagsAndAttributes & FILE_FLAG_OVERLAPPED ? 0 : FILE_SYNCHRONOUS_IO_NONALERT ); CreateFlags |= (dwFlagsAndAttributes & FILE_FLAG_SEQUENTIAL_SCAN ? FILE_SEQUENTIAL_ONLY : 0 ); CreateFlags |= (dwFlagsAndAttributes & FILE_FLAG_RANDOM_ACCESS ? FILE_RANDOM_ACCESS : 0 ); CreateFlags |= (dwFlagsAndAttributes & FILE_FLAG_BACKUP_SEMANTICS ? FILE_OPEN_FOR_BACKUP_INTENT : 0 ); if ( dwFlagsAndAttributes & FILE_FLAG_DELETE_ON_CLOSE ) { CreateFlags |= FILE_DELETE_ON_CLOSE; dwDesiredAccess |= DELETE; } if ( dwFlagsAndAttributes & FILE_FLAG_OPEN_REPARSE_POINT ) { CreateFlags |= FILE_OPEN_REPARSE_POINT; } if ( dwFlagsAndAttributes & FILE_FLAG_OPEN_NO_RECALL ) { CreateFlags |= FILE_OPEN_NO_RECALL; } // // Backup semantics allow directories to be opened // if ( !(dwFlagsAndAttributes & FILE_FLAG_BACKUP_SEMANTICS) ) { CreateFlags |= FILE_NON_DIRECTORY_FILE; } else { // // Backup intent was specified... Now look to see if we are to allow // directory creation // if ( (dwFlagsAndAttributes & FILE_ATTRIBUTE_DIRECTORY ) && (dwFlagsAndAttributes & FILE_FLAG_POSIX_SEMANTICS ) && (CreateDisposition == FILE_CREATE) ) { CreateFlags |= FILE_DIRECTORY_FILE; } } Status = NtCreateFile( &Handle, (ACCESS_MASK)dwDesiredAccess | SYNCHRONIZE | FILE_READ_ATTRIBUTES, &Obja, &IoStatusBlock, NULL, dwFlagsAndAttributes & (FILE_ATTRIBUTE_VALID_FLAGS & ~FILE_ATTRIBUTE_DIRECTORY), dwShareMode, CreateDisposition, CreateFlags, EaBuffer, EaSize ); RtlFreeHeap(RtlProcessHeap(), 0,FreeBuffer); RtlFreeHeap(RtlProcessHeap(), 0, EaBuffer); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); if ( Status == STATUS_OBJECT_NAME_COLLISION ) { WmipSetLastError(ERROR_FILE_EXISTS); } else if ( Status == STATUS_FILE_IS_A_DIRECTORY ) { if ( EndsInSlash ) { WmipSetLastError(ERROR_PATH_NOT_FOUND); } else { WmipSetLastError(ERROR_ACCESS_DENIED); } } return INVALID_HANDLE_VALUE; } // // if NT returns supersede/overwritten, it means that a create_always, openalways // found an existing copy of the file. In this case ERROR_ALREADY_EXISTS is returned // if ( (dwCreationDisposition == CREATE_ALWAYS && IoStatusBlock.Information == FILE_OVERWRITTEN) || (dwCreationDisposition == OPEN_ALWAYS && IoStatusBlock.Information == FILE_OPENED) ){ WmipSetLastError(ERROR_ALREADY_EXISTS); } else { WmipSetLastError(0); } // // Truncate the file if required // if ( dwCreationDisposition == TRUNCATE_EXISTING) { AllocationInfo.AllocationSize.QuadPart = 0; Status = NtSetInformationFile( Handle, &IoStatusBlock, &AllocationInfo, sizeof(AllocationInfo), FileAllocationInformation ); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); NtClose(Handle); Handle = INVALID_HANDLE_VALUE; } } // // Deal with hTemplateFile // return Handle; } HANDLE WmipBaseGetNamedObjectDirectory( VOID ) { OBJECT_ATTRIBUTES Obja; NTSTATUS Status; UNICODE_STRING RestrictedObjectDirectory; ACCESS_MASK DirAccess = DIRECTORY_ALL_ACCESS & ~(DELETE | WRITE_DAC | WRITE_OWNER); HANDLE hRootNamedObject; HANDLE BaseHandle; if ( BaseNamedObjectDirectory != NULL) { return BaseNamedObjectDirectory; } RtlAcquirePebLock(); if ( !BaseNamedObjectDirectory ) { BASE_READ_REMOTE_STR_TEMP(TempStr); InitializeObjectAttributes( &Obja, BASE_READ_REMOTE_STR(BaseStaticServerData->NamedObjectDirectory, TempStr), OBJ_CASE_INSENSITIVE, NULL, NULL ); Status = NtOpenDirectoryObject( &BaseHandle, DirAccess, &Obja ); // if the intial open failed, try again with just traverse, and // open the restricted subdirectory if ( !NT_SUCCESS(Status) ) { Status = NtOpenDirectoryObject( &hRootNamedObject, DIRECTORY_TRAVERSE, &Obja ); if ( NT_SUCCESS(Status) ) { RtlInitUnicodeString( &RestrictedObjectDirectory, L"Restricted"); InitializeObjectAttributes( &Obja, &RestrictedObjectDirectory, OBJ_CASE_INSENSITIVE, hRootNamedObject, NULL ); Status = NtOpenDirectoryObject( &BaseHandle, DirAccess, &Obja ); NtClose( hRootNamedObject ); } } if ( NT_SUCCESS(Status) ) { BaseNamedObjectDirectory = BaseHandle; } } RtlReleasePebLock(); return BaseNamedObjectDirectory; } POBJECT_ATTRIBUTES WmipBaseFormatObjectAttributes( OUT POBJECT_ATTRIBUTES ObjectAttributes, IN PSECURITY_ATTRIBUTES SecurityAttributes, IN PUNICODE_STRING ObjectName ) /*++ Routine Description: This function transforms a Win32 security attributes structure into an NT object attributes structure. It returns the address of the resulting structure (or NULL if SecurityAttributes was not specified). Arguments: ObjectAttributes - Returns an initialized NT object attributes structure that contains a superset of the information provided by the security attributes structure. SecurityAttributes - Supplies the address of a security attributes structure that needs to be transformed into an NT object attributes structure. ObjectName - Supplies a name for the object relative to the BaseNamedObjectDirectory object directory. Return Value: NULL - A value of null should be used to mimic the behavior of the specified SecurityAttributes structure. NON-NULL - Returns the ObjectAttributes value. The structure is properly initialized by this function. --*/ { HANDLE RootDirectory; ULONG Attributes; PVOID SecurityDescriptor; if ( ARGUMENT_PRESENT(SecurityAttributes) || ARGUMENT_PRESENT(ObjectName) ) { if ( ARGUMENT_PRESENT(ObjectName) ) { RootDirectory = WmipBaseGetNamedObjectDirectory(); } else { RootDirectory = NULL; } if ( SecurityAttributes ) { Attributes = (SecurityAttributes->bInheritHandle ? OBJ_INHERIT : 0); SecurityDescriptor = SecurityAttributes->lpSecurityDescriptor; } else { Attributes = 0; SecurityDescriptor = NULL; } if ( ARGUMENT_PRESENT(ObjectName) ) { Attributes |= OBJ_OPENIF; } InitializeObjectAttributes( ObjectAttributes, ObjectName, Attributes, RootDirectory, SecurityDescriptor ); return ObjectAttributes; } else { return NULL; } } HANDLE WINAPI WmipCreateFileA( LPCSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile ) /*++ Routine Description: ANSI thunk to CreateFileW --*/ { PUNICODE_STRING Unicode; Unicode = WmipBasep8BitStringToStaticUnicodeString( lpFileName ); if (Unicode == NULL) { return INVALID_HANDLE_VALUE; } return WmipCreateFileW( Unicode->Buffer, dwDesiredAccess, dwShareMode, lpSecurityAttributes, dwCreationDisposition, dwFlagsAndAttributes, hTemplateFile ); } HANDLE APIENTRY WmipCreateEventW( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCWSTR lpName ) /*++ Routine Description: An event object is created and a handle opened for access to the object with the CreateEvent function. The CreateEvent function creates an event object with the specified initial state. If an event is in the Signaled state (TRUE), a wait operation on the event does not block. If the event is in the Not- Signaled state (FALSE), a wait operation on the event blocks until the specified event attains a state of Signaled, or the timeout value is exceeded. In addition to the STANDARD_RIGHTS_REQUIRED access flags, the following object type specific access flags are valid for event objects: - EVENT_MODIFY_STATE - Modify state access (set and reset) to the event is desired. - SYNCHRONIZE - Synchronization access (wait) to the event is desired. - EVENT_ALL_ACCESS - This set of access flags specifies all of the possible access flags for an event object. Arguments: lpEventAttributes - An optional parameter that may be used to specify the attributes of the new event. If the parameter is not specified, then the event is created without a security descriptor, and the resulting handle is not inherited on process creation. bManualReset - Supplies a flag which if TRUE specifies that the event must be manually reset. If the value is FALSE, then after releasing a single waiter, the system automaticaly resets the event. bInitialState - The initial state of the event object, one of TRUE or FALSE. If the InitialState is specified as TRUE, the event's current state value is set to one, otherwise it is set to zero. lpName - Optional unicode name of event Return Value: NON-NULL - Returns a handle to the new event. The handle has full access to the new event and may be used in any API that requires a handle to an event object. FALSE/NULL - The operation failed. Extended error status is available using WmipGetLastError. --*/ { NTSTATUS Status; OBJECT_ATTRIBUTES Obja; POBJECT_ATTRIBUTES pObja; HANDLE Handle; UNICODE_STRING ObjectName; PWCHAR pstrNewObjName = NULL; if ( ARGUMENT_PRESENT(lpName) ) { if (gpTermsrvFormatObjectName && (pstrNewObjName = gpTermsrvFormatObjectName(lpName))) { RtlInitUnicodeString(&ObjectName,pstrNewObjName); } else { RtlInitUnicodeString(&ObjectName,lpName); } pObja = WmipBaseFormatObjectAttributes(&Obja,lpEventAttributes,&ObjectName); } else { pObja = WmipBaseFormatObjectAttributes(&Obja,lpEventAttributes,NULL); } Status = NtCreateEvent( &Handle, EVENT_ALL_ACCESS, pObja, bManualReset ? NotificationEvent : SynchronizationEvent, (BOOLEAN)bInitialState ); if (pstrNewObjName) { RtlFreeHeap(RtlProcessHeap(), 0, pstrNewObjName); } if ( NT_SUCCESS(Status) ) { if ( Status == STATUS_OBJECT_NAME_EXISTS ) { WmipSetLastError(ERROR_ALREADY_EXISTS); } else { WmipSetLastError(0); } return Handle; } else { WmipBaseSetLastNTError(Status); return NULL; } } // // Event Services // HANDLE APIENTRY WmipCreateEventA( LPSECURITY_ATTRIBUTES lpEventAttributes, BOOL bManualReset, BOOL bInitialState, LPCSTR lpName ) /*++ Routine Description: ANSI thunk to CreateEventW --*/ { PUNICODE_STRING Unicode; ANSI_STRING AnsiString; NTSTATUS Status; LPCWSTR NameBuffer; NameBuffer = NULL; if ( ARGUMENT_PRESENT(lpName) ) { Unicode = &NtCurrentTeb()->StaticUnicodeString; RtlInitAnsiString(&AnsiString,lpName); Status = RtlAnsiStringToUnicodeString(Unicode,&AnsiString,FALSE); if ( !NT_SUCCESS(Status) ) { if ( Status == STATUS_BUFFER_OVERFLOW ) { WmipSetLastError(ERROR_FILENAME_EXCED_RANGE); } else { WmipBaseSetLastNTError(Status); } return NULL; } NameBuffer = (LPCWSTR)Unicode->Buffer; } return WmipCreateEventW( lpEventAttributes, bManualReset, bInitialState, NameBuffer ); } DWORD WINAPI WmipSetFilePointer( HANDLE hFile, LONG lDistanceToMove, PLONG lpDistanceToMoveHigh, DWORD dwMoveMethod ) /*++ Routine Description: An open file's file pointer can be set using SetFilePointer. The purpose of this function is to update the current value of a file's file pointer. Care should be taken in multi-threaded applications that have multiple threads sharing a file handle with each thread updating the file pointer and then doing a read. This sequence should be treated as a critical section of code and should be protected using either a critical section object or a mutex object. This API provides the same functionality as DOS (int 21h, function 42h) and OS/2's DosSetFilePtr. Arguments: hFile - Supplies an open handle to a file whose file pointer is to be moved. The file handle must have been created with GENERIC_READ or GENERIC_WRITE access to the file. lDistanceToMove - Supplies the number of bytes to move the file pointer. A positive value moves the pointer forward in the file and a negative value moves backwards in the file. lpDistanceToMoveHigh - An optional parameter that if specified supplies the high order 32-bits of the 64-bit distance to move. If the value of this parameter is NULL, this API can only operate on files whose maximum size is (2**32)-2. If this parameter is specified, than the maximum file size is (2**64)-2. This value also returns the high order 32-bits of the new value of the file pointer. If this value, and the return value are 0xffffffff, then an error is indicated. dwMoveMethod - Supplies a value that specifies the starting point for the file pointer move. FILE_BEGIN - The starting point is zero or the beginning of the file. If FILE_BEGIN is specified, then DistanceToMove is interpreted as an unsigned location for the new file pointer. FILE_CURRENT - The current value of the file pointer is used as the starting point. FILE_END - The current end of file position is used as the starting point. Return Value: Not -1 - Returns the low order 32-bits of the new value of the file pointer. 0xffffffff - If the value of lpDistanceToMoveHigh was NULL, then The operation failed. Extended error status is available using WmipGetLastError. Otherwise, this is the low order 32-bits of the new value of the file pointer. --*/ { NTSTATUS Status; IO_STATUS_BLOCK IoStatusBlock; FILE_POSITION_INFORMATION CurrentPosition; FILE_STANDARD_INFORMATION StandardInfo; LARGE_INTEGER Large; if (CONSOLE_HANDLE(hFile)) { WmipBaseSetLastNTError(STATUS_INVALID_HANDLE); return (DWORD)-1; } if (ARGUMENT_PRESENT(lpDistanceToMoveHigh)) { Large.HighPart = *lpDistanceToMoveHigh; Large.LowPart = lDistanceToMove; } else { Large.QuadPart = lDistanceToMove; } switch (dwMoveMethod) { case FILE_BEGIN : CurrentPosition.CurrentByteOffset = Large; break; case FILE_CURRENT : // // Get the current position of the file pointer // Status = NtQueryInformationFile( hFile, &IoStatusBlock, &CurrentPosition, sizeof(CurrentPosition), FilePositionInformation ); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); return (DWORD)-1; } CurrentPosition.CurrentByteOffset.QuadPart += Large.QuadPart; break; case FILE_END : Status = NtQueryInformationFile( hFile, &IoStatusBlock, &StandardInfo, sizeof(StandardInfo), FileStandardInformation ); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); return (DWORD)-1; } CurrentPosition.CurrentByteOffset.QuadPart = StandardInfo.EndOfFile.QuadPart + Large.QuadPart; break; default: WmipSetLastError(ERROR_INVALID_PARAMETER); return (DWORD)-1; break; } // // If the resulting file position is negative, or if the app is not // prepared for greater than // then 32 bits than fail // if ( CurrentPosition.CurrentByteOffset.QuadPart < 0 ) { WmipSetLastError(ERROR_NEGATIVE_SEEK); return (DWORD)-1; } if ( !ARGUMENT_PRESENT(lpDistanceToMoveHigh) && (CurrentPosition.CurrentByteOffset.HighPart & MAXLONG) ) { WmipSetLastError(ERROR_INVALID_PARAMETER); return (DWORD)-1; } // // Set the current file position // Status = NtSetInformationFile( hFile, &IoStatusBlock, &CurrentPosition, sizeof(CurrentPosition), FilePositionInformation ); if ( NT_SUCCESS(Status) ) { if (ARGUMENT_PRESENT(lpDistanceToMoveHigh)){ *lpDistanceToMoveHigh = CurrentPosition.CurrentByteOffset.HighPart; } if ( CurrentPosition.CurrentByteOffset.LowPart == -1 ) { WmipSetLastError(0); } return CurrentPosition.CurrentByteOffset.LowPart; } else { WmipBaseSetLastNTError(Status); if (ARGUMENT_PRESENT(lpDistanceToMoveHigh)){ *lpDistanceToMoveHigh = -1; } return (DWORD)-1; } } BOOL WINAPI WmipReadFile( HANDLE hFile, LPVOID lpBuffer, DWORD nNumberOfBytesToRead, LPDWORD lpNumberOfBytesRead, LPOVERLAPPED lpOverlapped ) /*++ Routine Description: Data can be read from a file using ReadFile. This API is used to read data from a file. Data is read from the file from the position indicated by the file pointer. After the read completes, the file pointer is adjusted by the number of bytes actually read. A return value of TRUE coupled with a bytes read of 0 indicates that the file pointer was beyond the current end of the file at the time of the read. Arguments: hFile - Supplies an open handle to a file that is to be read. The file handle must have been created with GENERIC_READ access to the file. lpBuffer - Supplies the address of a buffer to receive the data read from the file. nNumberOfBytesToRead - Supplies the number of bytes to read from the file. lpNumberOfBytesRead - Returns the number of bytes read by this call. This parameter is always set to 0 before doing any IO or error checking. lpOverlapped - Optionally points to an OVERLAPPED structure to be used with the request. If NULL then the transfer starts at the current file position and ReadFile will not return until the operation completes. If the handle hFile was created without specifying FILE_FLAG_OVERLAPPED the file pointer is moved to the specified offset plus lpNumberOfBytesRead before ReadFile returns. ReadFile will wait for the request to complete before returning (it will not return ERROR_IO_PENDING). When FILE_FLAG_OVERLAPPED is specified, ReadFile may return ERROR_IO_PENDING to allow the calling function to continue processing while the operation completes. The event (or hFile if hEvent is NULL) will be set to the signalled state upon completion of the request. When the handle is created with FILE_FLAG_OVERLAPPED and lpOverlapped is set to NULL, ReadFile will return ERROR_INVALID_PARAMTER because the file offset is required. Return Value: TRUE - The operation was successul. FALSE - The operation failed. Extended error status is available using WmipGetLastError. --*/ { NTSTATUS Status; IO_STATUS_BLOCK IoStatusBlock; PPEB Peb; DWORD InputMode; if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) { *lpNumberOfBytesRead = 0; } Peb = NtCurrentPeb(); switch( HandleToUlong(hFile) ) { case STD_INPUT_HANDLE: hFile = Peb->ProcessParameters->StandardInput; break; case STD_OUTPUT_HANDLE: hFile = Peb->ProcessParameters->StandardOutput; break; case STD_ERROR_HANDLE: hFile = Peb->ProcessParameters->StandardError; break; } if ( ARGUMENT_PRESENT( lpOverlapped ) ) { LARGE_INTEGER Li; lpOverlapped->Internal = (DWORD)STATUS_PENDING; Li.LowPart = lpOverlapped->Offset; Li.HighPart = lpOverlapped->OffsetHigh; Status = NtReadFile( hFile, lpOverlapped->hEvent, NULL, (ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped, (PIO_STATUS_BLOCK)&lpOverlapped->Internal, lpBuffer, nNumberOfBytesToRead, &Li, NULL ); if ( NT_SUCCESS(Status) && Status != STATUS_PENDING) { if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) { try { *lpNumberOfBytesRead = (DWORD)lpOverlapped->InternalHigh; } except(EXCEPTION_EXECUTE_HANDLER) { *lpNumberOfBytesRead = 0; } } return TRUE; } else if (Status == STATUS_END_OF_FILE) { if ( ARGUMENT_PRESENT(lpNumberOfBytesRead) ) { *lpNumberOfBytesRead = 0; } WmipBaseSetLastNTError(Status); return FALSE; } else { WmipBaseSetLastNTError(Status); return FALSE; } } else { Status = NtReadFile( hFile, NULL, NULL, NULL, &IoStatusBlock, lpBuffer, nNumberOfBytesToRead, NULL, NULL ); if ( Status == STATUS_PENDING) { // Operation must complete before return & IoStatusBlock destroyed Status = NtWaitForSingleObject( hFile, FALSE, NULL ); if ( NT_SUCCESS(Status)) { Status = IoStatusBlock.Status; } } if ( NT_SUCCESS(Status) ) { *lpNumberOfBytesRead = (DWORD)IoStatusBlock.Information; return TRUE; } else if (Status == STATUS_END_OF_FILE) { *lpNumberOfBytesRead = 0; return TRUE; } else { if ( NT_WARNING(Status) ) { *lpNumberOfBytesRead = (DWORD)IoStatusBlock.Information; } WmipBaseSetLastNTError(Status); return FALSE; } } } BOOL WmipCloseHandle( HANDLE hObject ) { NTSTATUS Status; Status = NtClose(hObject); if ( NT_SUCCESS(Status) ) { return TRUE; } else { WmipBaseSetLastNTError(Status); return FALSE; } } DWORD APIENTRY WmipWaitForSingleObjectEx( HANDLE hHandle, DWORD dwMilliseconds, BOOL bAlertable ) /*++ Routine Description: A wait operation on a waitable object is accomplished with the WaitForSingleObjectEx function. Waiting on an object checks the current state of the object. If the current state of the object allows continued execution, any adjustments to the object state are made (for example, decrementing the semaphore count for a semaphore object) and the thread continues execution. If the current state of the object does not allow continued execution, the thread is placed into the wait state pending the change of the object's state or time-out. If the bAlertable parameter is FALSE, the only way the wait terminates is because the specified timeout period expires, or because the specified object entered the signaled state. If the bAlertable parameter is TRUE, then the wait can return due to any one of the above wait termination conditions, or because an I/O completion callback terminated the wait early (return value of WAIT_IO_COMPLETION). Arguments: hHandle - An open handle to a waitable object. The handle must have SYNCHRONIZE access to the object. dwMilliseconds - A time-out value that specifies the relative time, in milliseconds, over which the wait is to be completed. A timeout value of 0 specified that the wait is to timeout immediately. This allows an application to test an object to determine if it is in the signaled state. A timeout value of 0xffffffff specifies an infinite timeout period. bAlertable - Supplies a flag that controls whether or not the wait may terminate early due to an I/O completion callback. A value of TRUE allows this API to complete early due to an I/O completion callback. A value of FALSE will not allow I/O completion callbacks to terminate this call early. Return Value: WAIT_TIME_OUT - Indicates that the wait was terminated due to the TimeOut conditions. 0 - indicates the specified object attained a Signaled state thus completing the wait. 0xffffffff - The wait terminated due to an error. WmipGetLastError may be used to get additional error information. WAIT_ABANDONED - indicates the specified object attained a Signaled state but was abandoned. WAIT_IO_COMPLETION - The wait terminated due to one or more I/O completion callbacks. --*/ { NTSTATUS Status; LARGE_INTEGER TimeOut; PLARGE_INTEGER pTimeOut; PPEB Peb; RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME Frame = { sizeof(Frame), RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_FORMAT_WHISTLER }; RtlActivateActivationContextUnsafeFast(&Frame, NULL); // make the process default activation context active so that APCs are delivered under it __try { Peb = NtCurrentPeb(); switch( HandleToUlong(hHandle) ) { case STD_INPUT_HANDLE: hHandle = Peb->ProcessParameters->StandardInput; break; case STD_OUTPUT_HANDLE: hHandle = Peb->ProcessParameters->StandardOutput; break; case STD_ERROR_HANDLE: hHandle = Peb->ProcessParameters->StandardError; break; } pTimeOut = WmipBaseFormatTimeOut(&TimeOut,dwMilliseconds); rewait: Status = NtWaitForSingleObject(hHandle,(BOOLEAN)bAlertable,pTimeOut); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); Status = (NTSTATUS)0xffffffff; } else { if ( bAlertable && Status == STATUS_ALERTED ) { goto rewait; } } } __finally { RtlDeactivateActivationContextUnsafeFast(&Frame); } return (DWORD)Status; } BOOL WINAPI WmipGetOverlappedResult( HANDLE hFile, LPOVERLAPPED lpOverlapped, LPDWORD lpNumberOfBytesTransferred, BOOL bWait ) /*++ Routine Description: The GetOverlappedResult function returns the result of the last operation that used lpOverlapped and returned ERROR_IO_PENDING. Arguments: hFile - Supplies the open handle to the file that the overlapped structure lpOverlapped was supplied to ReadFile, WriteFile, ConnectNamedPipe, WaitNamedPipe or TransactNamedPipe. lpOverlapped - Points to an OVERLAPPED structure previously supplied to ReadFile, WriteFile, ConnectNamedPipe, WaitNamedPipe or TransactNamedPipe. lpNumberOfBytesTransferred - Returns the number of bytes transferred by the operation. bWait - A boolean value that affects the behavior when the operation is still in progress. If TRUE and the operation is still in progress, GetOverlappedResult will wait for the operation to complete before returning. If FALSE and the operation is incomplete, GetOverlappedResult will return FALSE. In this case the extended error information available from the WmipGetLastError function will be set to ERROR_IO_INCOMPLETE. Return Value: TRUE -- The operation was successful, the pipe is in the connected state. FALSE -- The operation failed. Extended error status is available using WmipGetLastError. --*/ { DWORD WaitReturn; // // Did caller specify an event to the original operation or was the // default (file handle) used? // if (lpOverlapped->Internal == (DWORD)STATUS_PENDING ) { if ( bWait ) { WaitReturn = WmipWaitForSingleObject( ( lpOverlapped->hEvent != NULL ) ? lpOverlapped->hEvent : hFile, INFINITE ); } else { WaitReturn = WAIT_TIMEOUT; } if ( WaitReturn == WAIT_TIMEOUT ) { // !bWait and event in not signalled state WmipSetLastError( ERROR_IO_INCOMPLETE ); return FALSE; } if ( WaitReturn != 0 ) { return FALSE; // WaitForSingleObject calls BaseSetLastError } } *lpNumberOfBytesTransferred = (DWORD)lpOverlapped->InternalHigh; if ( NT_SUCCESS((NTSTATUS)lpOverlapped->Internal) ){ return TRUE; } else { WmipBaseSetLastNTError( (NTSTATUS)lpOverlapped->Internal ); return FALSE; } } PLARGE_INTEGER WmipBaseFormatTimeOut( OUT PLARGE_INTEGER TimeOut, IN DWORD Milliseconds ) /*++ Routine Description: This function translates a Win32 style timeout to an NT relative timeout value. Arguments: TimeOut - Returns an initialized NT timeout value that is equivalent to the Milliseconds parameter. Milliseconds - Supplies the timeout value in milliseconds. A value of -1 indicates indefinite timeout. Return Value: NULL - A value of null should be used to mimic the behavior of the specified Milliseconds parameter. NON-NULL - Returns the TimeOut value. The structure is properly initialized by this function. --*/ { if ( (LONG) Milliseconds == -1 ) { return( NULL ); } TimeOut->QuadPart = UInt32x32To64( Milliseconds, 10000 ); TimeOut->QuadPart *= -1; return TimeOut; } DWORD WmipWaitForSingleObject( HANDLE hHandle, DWORD dwMilliseconds ) /*++ Routine Description: A wait operation on a waitable object is accomplished with the WaitForSingleObject function. Waiting on an object checks the current state of the object. If the current state of the object allows continued execution, any adjustments to the object state are made (for example, decrementing the semaphore count for a semaphore object) and the thread continues execution. If the current state of the object does not allow continued execution, the thread is placed into the wait state pending the change of the object's state or time-out. Arguments: hHandle - An open handle to a waitable object. The handle must have SYNCHRONIZE access to the object. dwMilliseconds - A time-out value that specifies the relative time, in milliseconds, over which the wait is to be completed. A timeout value of 0 specified that the wait is to timeout immediately. This allows an application to test an object to determine if it is in the signaled state. A timeout value of -1 specifies an infinite timeout period. Return Value: WAIT_TIME_OUT - Indicates that the wait was terminated due to the TimeOut conditions. 0 - indicates the specified object attained a Signaled state thus completing the wait. WAIT_ABANDONED - indicates the specified object attained a Signaled state but was abandoned. --*/ { return WmipWaitForSingleObjectEx(hHandle,dwMilliseconds,FALSE); } BOOL WINAPI WmipDeviceIoControl( HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped ) /*++ Routine Description: An operation on a device may be performed by calling the device driver directly using the DeviceIoContrl function. The device driver must first be opened to get a valid handle. Arguments: hDevice - Supplies an open handle a device on which the operation is to be performed. dwIoControlCode - Supplies the control code for the operation. This control code determines on which type of device the operation must be performed and determines exactly what operation is to be performed. lpInBuffer - Suplies an optional pointer to an input buffer that contains the data required to perform the operation. Whether or not the buffer is actually optional is dependent on the IoControlCode. nInBufferSize - Supplies the length of the input buffer in bytes. lpOutBuffer - Suplies an optional pointer to an output buffer into which the output data will be copied. Whether or not the buffer is actually optional is dependent on the IoControlCode. nOutBufferSize - Supplies the length of the output buffer in bytes. lpBytesReturned - Supplies a pointer to a dword which will receive the actual length of the data returned in the output buffer. lpOverlapped - An optional parameter that supplies an overlap structure to be used with the request. If NULL or the handle was created without FILE_FLAG_OVERLAPPED then the DeviceIoControl will not return until the operation completes. When lpOverlapped is supplied and FILE_FLAG_OVERLAPPED was specified when the handle was created, DeviceIoControl may return ERROR_IO_PENDING to allow the caller to continue processing while the operation completes. The event (or File handle if hEvent == NULL) will be set to the not signalled state before ERROR_IO_PENDING is returned. The event will be set to the signalled state upon completion of the request. GetOverlappedResult is used to determine the result when ERROR_IO_PENDING is returned. Return Value: TRUE -- The operation was successful. FALSE -- The operation failed. Extended error status is available using WmipGetLastError. --*/ { NTSTATUS Status; BOOLEAN DevIoCtl; if ( dwIoControlCode >> 16 == FILE_DEVICE_FILE_SYSTEM ) { DevIoCtl = FALSE; } else { DevIoCtl = TRUE; } if ( ARGUMENT_PRESENT( lpOverlapped ) ) { lpOverlapped->Internal = (DWORD)STATUS_PENDING; if ( DevIoCtl ) { Status = NtDeviceIoControlFile( hDevice, lpOverlapped->hEvent, NULL, // APC routine (ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped, (PIO_STATUS_BLOCK)&lpOverlapped->Internal, dwIoControlCode, // IoControlCode lpInBuffer, // Buffer for data to the FS nInBufferSize, lpOutBuffer, // OutputBuffer for data from the FS nOutBufferSize // OutputBuffer Length ); } else { Status = NtFsControlFile( hDevice, lpOverlapped->hEvent, NULL, // APC routine (ULONG_PTR)lpOverlapped->hEvent & 1 ? NULL : lpOverlapped, (PIO_STATUS_BLOCK)&lpOverlapped->Internal, dwIoControlCode, // IoControlCode lpInBuffer, // Buffer for data to the FS nInBufferSize, lpOutBuffer, // OutputBuffer for data from the FS nOutBufferSize // OutputBuffer Length ); } // handle warning value STATUS_BUFFER_OVERFLOW somewhat correctly if ( !NT_ERROR(Status) && ARGUMENT_PRESENT(lpBytesReturned) ) { try { *lpBytesReturned = (DWORD)lpOverlapped->InternalHigh; } except(EXCEPTION_EXECUTE_HANDLER) { *lpBytesReturned = 0; } } if ( NT_SUCCESS(Status) && Status != STATUS_PENDING) { return TRUE; } else { WmipBaseSetLastNTError(Status); return FALSE; } } else { IO_STATUS_BLOCK Iosb; if ( DevIoCtl ) { Status = NtDeviceIoControlFile( hDevice, NULL, NULL, // APC routine NULL, // APC Context &Iosb, dwIoControlCode, // IoControlCode lpInBuffer, // Buffer for data to the FS nInBufferSize, lpOutBuffer, // OutputBuffer for data from the FS nOutBufferSize // OutputBuffer Length ); } else { Status = NtFsControlFile( hDevice, NULL, NULL, // APC routine NULL, // APC Context &Iosb, dwIoControlCode, // IoControlCode lpInBuffer, // Buffer for data to the FS nInBufferSize, lpOutBuffer, // OutputBuffer for data from the FS nOutBufferSize // OutputBuffer Length ); } if ( Status == STATUS_PENDING) { // Operation must complete before return & Iosb destroyed Status = NtWaitForSingleObject( hDevice, FALSE, NULL ); if ( NT_SUCCESS(Status)) { Status = Iosb.Status; } } if ( NT_SUCCESS(Status) ) { *lpBytesReturned = (DWORD)Iosb.Information; return TRUE; } else { // handle warning value STATUS_BUFFER_OVERFLOW somewhat correctly if ( !NT_ERROR(Status) ) { *lpBytesReturned = (DWORD)Iosb.Information; } WmipBaseSetLastNTError(Status); return FALSE; } } } BOOL WINAPI WmipCancelIo( HANDLE hFile ) /*++ Routine Description: This routine cancels all of the outstanding I/O for the specified handle for the specified file. Arguments: hFile - Supplies the handle to the file whose pending I/O is to be canceled. Return Value: TRUE -- The operation was successful. FALSE -- The operation failed. Extended error status is available using WmipGetLastError. --*/ { NTSTATUS Status; IO_STATUS_BLOCK IoStatusBlock; // // Simply cancel the I/O for the specified file. // Status = NtCancelIoFile(hFile, &IoStatusBlock); if ( NT_SUCCESS(Status) ) { return TRUE; } else { WmipBaseSetLastNTError(Status); return FALSE; } } VOID APIENTRY WmipExitThread( DWORD dwExitCode ) { RtlExitUserThread(dwExitCode); } DWORD WINAPI WmipGetCurrentProcessId( VOID ) /*++ Routine Description: The process ID of the current process may be retrieved using GetCurrentProcessId. Arguments: None. Return Value: Returns a unique value representing the process ID of the currently executing process. The return value may be used to open a handle to a process. --*/ { return HandleToUlong(NtCurrentTeb()->ClientId.UniqueProcess); } DWORD APIENTRY WmipGetCurrentThreadId( VOID ) /*++ Routine Description: The thread ID of the current thread may be retrieved using GetCurrentThreadId. Arguments: None. Return Value: Returns a unique value representing the thread ID of the currently executing thread. The return value may be used to identify a thread in the system. --*/ { return HandleToUlong(NtCurrentTeb()->ClientId.UniqueThread); } HANDLE WINAPI WmipGetCurrentProcess( VOID ) /*++ Routine Description: A pseudo handle to the current process may be retrieved using GetCurrentProcess. A special constant is exported by Win32 that is interpreted as a handle to the current process. This handle may be used to specify the current process whenever a process handle is required. On Win32, this handle has PROCESS_ALL_ACCESS to the current process. On NT/Win32, this handle has the maximum access allowed by any security descriptor placed on the current process. Arguments: None. Return Value: Returns the pseudo handle of the current process. --*/ { return NtCurrentProcess(); } BOOL WmipSetEvent( HANDLE hEvent ) /*++ Routine Description: An event can be set to the signaled state (TRUE) with the SetEvent function. Setting the event causes the event to attain a state of Signaled, which releases all currently waiting threads (for manual reset events), or a single waiting thread (for automatic reset events). Arguments: hEvent - Supplies an open handle to an event object. The handle must have EVENT_MODIFY_STATE access to the event. Return Value: TRUE - The operation was successful FALSE/NULL - The operation failed. Extended error status is available using WmipGetLastError. --*/ { NTSTATUS Status; Status = NtSetEvent(hEvent,NULL); if ( NT_SUCCESS(Status) ) { return TRUE; } else { WmipBaseSetLastNTError(Status); return FALSE; } } VOID WINAPI WmipGetSystemInfo( LPSYSTEM_INFO lpSystemInfo ) /*++ Routine Description: The GetSystemInfo function is used to return information about the current system. This includes the processor type, page size, oem id, and other interesting pieces of information. Arguments: lpSystemInfo - Returns information about the current system. SYSTEM_INFO Structure: WORD wProcessorArchitecture - returns the architecture of the processors in the system: e.g. Intel, Mips, Alpha or PowerPC DWORD dwPageSize - Returns the page size. This is specifies the granularity of page protection and commitment. LPVOID lpMinimumApplicationAddress - Returns the lowest memory address accessible to applications and DLLs. LPVOID lpMaximumApplicationAddress - Returns the highest memory address accessible to applications and DLLs. DWORD dwActiveProcessorMask - Returns a mask representing the set of processors configured into the system. Bit 0 is processor 0, bit 31 is processor 31. DWORD dwNumberOfProcessors - Returns the number of processors in the system. WORD wProcessorLevel - Returns the level of the processors in the system. All processors are assumed to be of the same level, stepping, and are configured with the same options. WORD wProcessorRevision - Returns the revision or stepping of the processors in the system. All processors are assumed to be of the same level, stepping, and are configured with the same options. Return Value: None. --*/ { NTSTATUS Status; SYSTEM_BASIC_INFORMATION BasicInfo; SYSTEM_PROCESSOR_INFORMATION ProcessorInfo; RtlZeroMemory(lpSystemInfo,sizeof(*lpSystemInfo)); Status = NtQuerySystemInformation( SystemBasicInformation, &BasicInfo, sizeof(BasicInfo), NULL ); if ( !NT_SUCCESS(Status) ) { return; } Status = NtQuerySystemInformation( SystemProcessorInformation, &ProcessorInfo, sizeof(ProcessorInfo), NULL ); if ( !NT_SUCCESS(Status) ) { return; } lpSystemInfo->wProcessorArchitecture = ProcessorInfo.ProcessorArchitecture; lpSystemInfo->wReserved = 0; lpSystemInfo->dwPageSize = BasicInfo.PageSize; lpSystemInfo->lpMinimumApplicationAddress = (LPVOID)BasicInfo.MinimumUserModeAddress; lpSystemInfo->lpMaximumApplicationAddress = (LPVOID)BasicInfo.MaximumUserModeAddress; lpSystemInfo->dwActiveProcessorMask = BasicInfo.ActiveProcessorsAffinityMask; lpSystemInfo->dwNumberOfProcessors = BasicInfo.NumberOfProcessors; lpSystemInfo->wProcessorLevel = ProcessorInfo.ProcessorLevel; lpSystemInfo->wProcessorRevision = ProcessorInfo.ProcessorRevision; if (ProcessorInfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_INTEL) { if (ProcessorInfo.ProcessorLevel == 3) { lpSystemInfo->dwProcessorType = PROCESSOR_INTEL_386; } else if (ProcessorInfo.ProcessorLevel == 4) { lpSystemInfo->dwProcessorType = PROCESSOR_INTEL_486; } else { lpSystemInfo->dwProcessorType = PROCESSOR_INTEL_PENTIUM; } } else if (ProcessorInfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_MIPS) { lpSystemInfo->dwProcessorType = PROCESSOR_MIPS_R4000; } else if (ProcessorInfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_ALPHA) { lpSystemInfo->dwProcessorType = PROCESSOR_ALPHA_21064; } else if (ProcessorInfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_PPC) { lpSystemInfo->dwProcessorType = 604; // backward compatibility } else if (ProcessorInfo.ProcessorArchitecture == PROCESSOR_ARCHITECTURE_IA64) { lpSystemInfo->dwProcessorType = PROCESSOR_INTEL_IA64; } else { lpSystemInfo->dwProcessorType = 0; } lpSystemInfo->dwAllocationGranularity = BasicInfo.AllocationGranularity; // // for apps less than 3.51, then return 0 in dwReserved. This allows borlands // debugger to continue to run since it mistakenly used dwReserved // as AllocationGranularity // /* commented by Digvijay if ( WmipGetProcessVersion(0) < 0x30033 ) { lpSystemInfo->wProcessorLevel = 0; lpSystemInfo->wProcessorRevision = 0; }*/ return; } VOID WINAPI WmipGlobalMemoryStatus( LPMEMORYSTATUS lpBuffer ) { DWORD NumberOfPhysicalPages; SYSTEM_PERFORMANCE_INFORMATION PerfInfo; VM_COUNTERS VmCounters; QUOTA_LIMITS QuotaLimits; NTSTATUS Status; PPEB Peb; PIMAGE_NT_HEADERS NtHeaders; DWORDLONG Memory64; #if defined(BUILD_WOW6432) || defined(_WIN64) Status = NtQuerySystemInformation(SystemBasicInformation, &SysInfo, sizeof(SYSTEM_BASIC_INFORMATION), NULL ); if (!NT_SUCCESS(Status)) { return; } #endif Status = NtQuerySystemInformation( SystemPerformanceInformation, &PerfInfo, sizeof(PerfInfo), NULL ); ASSERT(NT_SUCCESS(Status)); lpBuffer->dwLength = sizeof( *lpBuffer ); // // Capture the number of physical pages as it can change dynamically. // If it goes up or down in the middle of this routine, the results may // look strange (ie: available > total, etc), but it will quickly // right itself. // NumberOfPhysicalPages = USER_SHARED_DATA->NumberOfPhysicalPages; // // Determine the memory load. < 100 available pages is 100 // Otherwise load is ((TotalPhys - AvailPhys) * 100) / TotalPhys // if (PerfInfo.AvailablePages < 100) { lpBuffer->dwMemoryLoad = 100; } else { lpBuffer->dwMemoryLoad = ((DWORD)(NumberOfPhysicalPages - PerfInfo.AvailablePages) * 100) / NumberOfPhysicalPages; } Memory64 = (DWORDLONG)NumberOfPhysicalPages * BASE_SYSINFO.PageSize; lpBuffer->dwTotalPhys = (SIZE_T) __min(Memory64, MAXULONG_PTR); Memory64 = ((DWORDLONG)PerfInfo.AvailablePages * (DWORDLONG)BASE_SYSINFO.PageSize); lpBuffer->dwAvailPhys = (SIZE_T) __min(Memory64, MAXULONG_PTR); if (gpTermsrvAdjustPhyMemLimits) { gpTermsrvAdjustPhyMemLimits(&(lpBuffer->dwTotalPhys), &(lpBuffer->dwAvailPhys), BASE_SYSINFO.PageSize); } // // Zero returned values in case the query process fails. // RtlZeroMemory (&QuotaLimits, sizeof (QUOTA_LIMITS)); RtlZeroMemory (&VmCounters, sizeof (VM_COUNTERS)); Status = NtQueryInformationProcess (NtCurrentProcess(), ProcessQuotaLimits, &QuotaLimits, sizeof(QUOTA_LIMITS), NULL ); Status = NtQueryInformationProcess (NtCurrentProcess(), ProcessVmCounters, &VmCounters, sizeof(VM_COUNTERS), NULL ); // // Determine the total page file space with respect to this process. // Memory64 = __min(PerfInfo.CommitLimit, QuotaLimits.PagefileLimit); Memory64 *= BASE_SYSINFO.PageSize; lpBuffer->dwTotalPageFile = (SIZE_T)__min(Memory64, MAXULONG_PTR); // // Determine remaining page file space with respect to this process. // Memory64 = __min(PerfInfo.CommitLimit - PerfInfo.CommittedPages, QuotaLimits.PagefileLimit - VmCounters.PagefileUsage); Memory64 *= BASE_SYSINFO.PageSize; lpBuffer->dwAvailPageFile = (SIZE_T) __min(Memory64, MAXULONG_PTR); lpBuffer->dwTotalVirtual = (BASE_SYSINFO.MaximumUserModeAddress - BASE_SYSINFO.MinimumUserModeAddress) + 1; lpBuffer->dwAvailVirtual = lpBuffer->dwTotalVirtual - VmCounters.VirtualSize; #if !defined(_WIN64) // // Lie about available memory if application can't handle large (>2GB) addresses // Peb = NtCurrentPeb(); NtHeaders = RtlImageNtHeader( Peb->ImageBaseAddress ); if (NtHeaders && !(NtHeaders->FileHeader.Characteristics & IMAGE_FILE_LARGE_ADDRESS_AWARE)) { if (lpBuffer->dwTotalPhys > 0x7FFFFFFF) { lpBuffer->dwTotalPhys = 0x7FFFFFFF; } if (lpBuffer->dwAvailPhys > 0x7FFFFFFF) { lpBuffer->dwAvailPhys = 0x7FFFFFFF; } if (lpBuffer->dwTotalVirtual > 0x7FFFFFFF) { lpBuffer->dwTotalVirtual = 0x7FFFFFFF; } if (lpBuffer->dwAvailVirtual > 0x7FFFFFFF) { lpBuffer->dwAvailVirtual = 0x7FFFFFFF; } } #endif return; } DWORD APIENTRY WmipWaitForMultipleObjectsEx( DWORD nCount, CONST HANDLE *lpHandles, BOOL bWaitAll, DWORD dwMilliseconds, BOOL bAlertable ) /*++ Routine Description: A wait operation on multiple waitable objects (up to MAXIMUM_WAIT_OBJECTS) is accomplished with the WaitForMultipleObjects function. This API can be used to wait on any of the specified objects to enter the signaled state, or all of the objects to enter the signaled state. If the bAlertable parameter is FALSE, the only way the wait terminates is because the specified timeout period expires, or because the specified objects entered the signaled state. If the bAlertable parameter is TRUE, then the wait can return due to any one of the above wait termination conditions, or because an I/O completion callback terminated the wait early (return value of WAIT_IO_COMPLETION). Arguments: nCount - A count of the number of objects that are to be waited on. lpHandles - An array of object handles. Each handle must have SYNCHRONIZE access to the associated object. bWaitAll - A flag that supplies the wait type. A value of TRUE indicates a "wait all". A value of false indicates a "wait any". dwMilliseconds - A time-out value that specifies the relative time, in milliseconds, over which the wait is to be completed. A timeout value of 0 specified that the wait is to timeout immediately. This allows an application to test an object to determine if it is in the signaled state. A timeout value of 0xffffffff specifies an infinite timeout period. bAlertable - Supplies a flag that controls whether or not the wait may terminate early due to an I/O completion callback. A value of TRUE allows this API to complete early due to an I/O completion callback. A value of FALSE will not allow I/O completion callbacks to terminate this call early. Return Value: WAIT_TIME_OUT - indicates that the wait was terminated due to the TimeOut conditions. 0 to MAXIMUM_WAIT_OBJECTS-1, indicates, in the case of wait for any object, the object number which satisfied the wait. In the case of wait for all objects, the value only indicates that the wait was completed successfully. 0xffffffff - The wait terminated due to an error. WmipGetLastError may be used to get additional error information. WAIT_ABANDONED_0 to (WAIT_ABANDONED_0)+(MAXIMUM_WAIT_OBJECTS - 1), indicates, in the case of wait for any object, the object number which satisfied the event, and that the object which satisfied the event was abandoned. In the case of wait for all objects, the value indicates that the wait was completed successfully and at least one of the objects was abandoned. WAIT_IO_COMPLETION - The wait terminated due to one or more I/O completion callbacks. --*/ { NTSTATUS Status; LARGE_INTEGER TimeOut; PLARGE_INTEGER pTimeOut; DWORD i; LPHANDLE HandleArray; HANDLE Handles[ 8 ]; PPEB Peb; RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME Frame = { sizeof(Frame), RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_FORMAT_WHISTLER }; RtlActivateActivationContextUnsafeFast(&Frame, NULL); // make the process default activation context active so that APCs are delivered under it __try { if (nCount > 8) { HandleArray = (LPHANDLE) RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), nCount*sizeof(HANDLE)); if (HandleArray == NULL) { WmipBaseSetLastNTError(STATUS_NO_MEMORY); return 0xffffffff; } } else { HandleArray = Handles; } RtlCopyMemory(HandleArray,(LPVOID)lpHandles,nCount*sizeof(HANDLE)); Peb = NtCurrentPeb(); for (i=0;iProcessParameters->StandardInput; break; case STD_OUTPUT_HANDLE: HandleArray[i] = Peb->ProcessParameters->StandardOutput; break; case STD_ERROR_HANDLE: HandleArray[i] = Peb->ProcessParameters->StandardError; break; } } pTimeOut = WmipBaseFormatTimeOut(&TimeOut,dwMilliseconds); rewait: Status = NtWaitForMultipleObjects( (CHAR)nCount, HandleArray, bWaitAll ? WaitAll : WaitAny, (BOOLEAN)bAlertable, pTimeOut ); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); Status = (NTSTATUS)0xffffffff; } else { if ( bAlertable && Status == STATUS_ALERTED ) { goto rewait; } } if (HandleArray != Handles) { RtlFreeHeap(RtlProcessHeap(), 0, HandleArray); } } __finally { RtlDeactivateActivationContextUnsafeFast(&Frame); } return (DWORD)Status; } VOID WmipSleep( DWORD dwMilliseconds ) /*++ Routine Description: The execution of the current thread can be delayed for a specified interval of time with the Sleep function. The Sleep function causes the current thread to enter a waiting state until the specified interval of time has passed. Arguments: dwMilliseconds - A time-out value that specifies the relative time, in milliseconds, over which the wait is to be completed. A timeout value of 0 specified that the wait is to timeout immediately. This allows an application to test an object to determine if it is in the signaled state. A timeout value of -1 specifies an infinite timeout period. Return Value: None. --*/ { WmipSleepEx(dwMilliseconds,FALSE); } DWORD APIENTRY WmipSleepEx( DWORD dwMilliseconds, BOOL bAlertable ) /*++ Routine Description: The execution of the current thread can be delayed for a specified interval of time with the SleepEx function. The SleepEx function causes the current thread to enter a waiting state until the specified interval of time has passed. If the bAlertable parameter is FALSE, the only way the SleepEx returns is when the specified time interval has passed. If the bAlertable parameter is TRUE, then the SleepEx can return due to the expiration of the time interval (return value of 0), or because an I/O completion callback terminated the SleepEx early (return value of WAIT_IO_COMPLETION). Arguments: dwMilliseconds - A time-out value that specifies the relative time, in milliseconds, over which the wait is to be completed. A timeout value of 0 specified that the wait is to timeout immediately. A timeout value of -1 specifies an infinite timeout period. bAlertable - Supplies a flag that controls whether or not the SleepEx may terminate early due to an I/O completion callback. A value of TRUE allows this API to complete early due to an I/O completion callback. A value of FALSE will not allow I/O completion callbacks to terminate this call early. Return Value: 0 - The SleepEx terminated due to expiration of the time interval. WAIT_IO_COMPLETION - The SleepEx terminated due to one or more I/O completion callbacks. --*/ { LARGE_INTEGER TimeOut; PLARGE_INTEGER pTimeOut; NTSTATUS Status; RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME Frame = { sizeof(Frame), RTL_CALLER_ALLOCATED_ACTIVATION_CONTEXT_STACK_FRAME_FORMAT_WHISTLER }; RtlActivateActivationContextUnsafeFast(&Frame, NULL); // make the process default activation context active so that APCs are delivered under it __try { pTimeOut = WmipBaseFormatTimeOut(&TimeOut,dwMilliseconds); if (pTimeOut == NULL) { // // If Sleep( -1 ) then delay for the longest possible integer // relative to now. // TimeOut.LowPart = 0x0; TimeOut.HighPart = 0x80000000; pTimeOut = &TimeOut; } rewait: Status = NtDelayExecution( (BOOLEAN)bAlertable, pTimeOut ); if ( bAlertable && Status == STATUS_ALERTED ) { goto rewait; } } __finally { RtlDeactivateActivationContextUnsafeFast(&Frame); } return Status == STATUS_USER_APC ? WAIT_IO_COMPLETION : 0; } BOOL APIENTRY WmipSetThreadPriority( HANDLE hThread, int nPriority ) /*++ Routine Description: The specified thread's priority can be set using SetThreadPriority. A thread's priority may be set using SetThreadPriority. This call allows the thread's relative execution importance to be communicated to the system. The system normally schedules threads according to their priority. The system is free to temporarily boost the priority of a thread when signifigant events occur (e.g. keyboard or mouse input...). Similarly, as a thread runs without blocking, the system will decay its priority. The system will never decay the priority below the value set by this call. In the absence of system originated priority boosts, threads will be scheduled in a round-robin fashion at each priority level from THREAD_PRIORITY_TIME_CRITICAL to THREAD_PRIORITY_IDLE. Only when there are no runnable threads at a higher level, will scheduling of threads at a lower level take place. All threads initially start at THREAD_PRIORITY_NORMAL. If for some reason the thread needs more priority, it can be switched to THREAD_PRIORITY_ABOVE_NORMAL or THREAD_PRIORITY_HIGHEST. Switching to THREAD_PRIORITY_TIME_CRITICAL should only be done in extreme situations. Since these threads are given the highes priority, they should only run in short bursts. Running for long durations will soak up the systems processing bandwidth starving threads at lower levels. If a thread needs to do low priority work, or should only run there is nothing else to do, its priority should be set to THREAD_PRIORITY_BELOW_NORMAL or THREAD_PRIORITY_LOWEST. For extreme cases, THREAD_PRIORITY_IDLE can be used. Care must be taken when manipulating priorites. If priorities are used carelessly (every thread is set to THREAD_PRIORITY_TIME_CRITICAL), the effects of priority modifications can produce undesireable effects (e.g. starvation, no effect...). Arguments: hThread - Supplies a handle to the thread whose priority is to be set. The handle must have been created with THREAD_SET_INFORMATION access. nPriority - Supplies the priority value for the thread. The following five priority values (ordered from lowest priority to highest priority) are allowed. nPriority Values: THREAD_PRIORITY_IDLE - The thread's priority should be set to the lowest possible settable priority. THREAD_PRIORITY_LOWEST - The thread's priority should be set to the next lowest possible settable priority. THREAD_PRIORITY_BELOW_NORMAL - The thread's priority should be set to just below normal. THREAD_PRIORITY_NORMAL - The thread's priority should be set to the normal priority value. This is the value that all threads begin execution at. THREAD_PRIORITY_ABOVE_NORMAL - The thread's priority should be set to just above normal priority. THREAD_PRIORITY_HIGHEST - The thread's priority should be set to the next highest possible settable priority. THREAD_PRIORITY_TIME_CRITICAL - The thread's priority should be set to the highest possible settable priority. This priority is very likely to interfere with normal operation of the system. Return Value: TRUE - The operation was successful FALSE/NULL - The operation failed. Extended error status is available using WmipGetLastError. --*/ { NTSTATUS Status; LONG BasePriority; BasePriority = (LONG)nPriority; // // saturation is indicated by calling with a value of 16 or -16 // if ( BasePriority == THREAD_PRIORITY_TIME_CRITICAL ) { BasePriority = ((HIGH_PRIORITY + 1) / 2); } else if ( BasePriority == THREAD_PRIORITY_IDLE ) { BasePriority = -((HIGH_PRIORITY + 1) / 2); } Status = NtSetInformationThread( hThread, ThreadBasePriority, &BasePriority, sizeof(BasePriority) ); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); return FALSE; } return TRUE; } BOOL WmipDuplicateHandle( HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions ) /*++ Routine Description: A duplicate handle can be created with the DuplicateHandle function. This is a generic function and operates on the following object types: - Process Object - Thread Object - Mutex Object - Event Object - Semaphore Object - File Object Please note that Module Objects are not in this list. This function requires PROCESS_DUP_ACCESS to both the SourceProcessHandle and the TargetProcessHandle. This function is used to pass an object handle from one process to another. Once this call is complete, the target process needs to be informed of the value of the target handle. The target process can then operate on the object using this handle value. Arguments: hSourceProcessHandle - An open handle to the process that contains the handle to be duplicated. The handle must have been created with PROCESS_DUP_HANDLE access to the process. hSourceHandle - An open handle to any object that is valid in the context of the source process. hTargetProcessHandle - An open handle to the process that is to receive the duplicated handle. The handle must have been created with PROCESS_DUP_HANDLE access to the process. lpTargetHandle - A pointer to a variable which receives the new handle that points to the same object as SourceHandle does. This handle value is valid in the context of the target process. dwDesiredAccess - The access requested to for the new handle. This parameter is ignored if the DUPLICATE_SAME_ACCESS option is specified. bInheritHandle - Supplies a flag that if TRUE, marks the target handle as inheritable. If this is the case, then the target handle will be inherited to new processes each time the target process creates a new process using CreateProcess. dwOptions - Specifies optional behaviors for the caller. Options Flags: DUPLICATE_CLOSE_SOURCE - The SourceHandle will be closed by this service prior to returning to the caller. This occurs regardless of any error status returned. DUPLICATE_SAME_ACCESS - The DesiredAccess parameter is ignored and instead the GrantedAccess associated with SourceHandle is used as the DesiredAccess when creating the TargetHandle. Return Value: TRUE - The operation was successful. FALSE/NULL - The operation failed. Extended error status is available using WmipGetLastError. --*/ { NTSTATUS Status; PPEB Peb; Peb = NtCurrentPeb(); switch( HandleToUlong(hSourceHandle) ) { case STD_INPUT_HANDLE: hSourceHandle = Peb->ProcessParameters->StandardInput; break; case STD_OUTPUT_HANDLE: hSourceHandle = Peb->ProcessParameters->StandardOutput; break; case STD_ERROR_HANDLE: hSourceHandle = Peb->ProcessParameters->StandardError; break; } Status = NtDuplicateObject( hSourceProcessHandle, hSourceHandle, hTargetProcessHandle, lpTargetHandle, (ACCESS_MASK)dwDesiredAccess, bInheritHandle ? OBJ_INHERIT : 0, dwOptions ); if ( NT_SUCCESS(Status) ) { return TRUE; } else { WmipBaseSetLastNTError(Status); return FALSE; } return FALSE; } UINT WmipSetErrorMode( UINT uMode ) { UINT PreviousMode; UINT NewMode; PreviousMode = WmipGetErrorMode(); NewMode = uMode; if (NewMode & SEM_FAILCRITICALERRORS ) { NewMode &= ~SEM_FAILCRITICALERRORS; } else { NewMode |= SEM_FAILCRITICALERRORS; } // // Once SEM_NOALIGNMENTFAULTEXCEPT has been enabled for a given // process, it cannot be disabled via this API. // NewMode |= (PreviousMode & SEM_NOALIGNMENTFAULTEXCEPT); if ( NT_SUCCESS(NtSetInformationProcess( NtCurrentProcess(), ProcessDefaultHardErrorMode, (PVOID) &NewMode, sizeof(NewMode) ) ) ){ } return( PreviousMode ); } UINT WmipGetErrorMode() { UINT PreviousMode; NTSTATUS Status; Status = NtQueryInformationProcess( NtCurrentProcess(), ProcessDefaultHardErrorMode, (PVOID) &PreviousMode, sizeof(PreviousMode), NULL ); if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); return 0; } if (PreviousMode & 1) { PreviousMode &= ~SEM_FAILCRITICALERRORS; } else { PreviousMode |= SEM_FAILCRITICALERRORS; } return PreviousMode; } ULONG WmipBuildGuidObjectAttributes( IN LPGUID Guid, OUT POBJECT_ATTRIBUTES ObjectAttributes, OUT PUNICODE_STRING GuidString, OUT PWCHAR GuidObjectName ) { WCHAR GuidChar[37]; WmipAssert(Guid != NULL); // // Build up guid name into the ObjectAttributes // swprintf(GuidChar, L"%08lX-%04X-%04X-%02X%02X-%02X%02X%02X%02X%02X%02X", Guid->Data1, Guid->Data2, Guid->Data3, Guid->Data4[0], Guid->Data4[1], Guid->Data4[2], Guid->Data4[3], Guid->Data4[4], Guid->Data4[5], Guid->Data4[6], Guid->Data4[7]); WmipAssert(wcslen(GuidChar) == 36); wcscpy(GuidObjectName, WmiGuidObjectDirectory); wcscat(GuidObjectName, GuidChar); RtlInitUnicodeString(GuidString, GuidObjectName); memset(ObjectAttributes, 0, sizeof(OBJECT_ATTRIBUTES)); ObjectAttributes->Length = sizeof(OBJECT_ATTRIBUTES); ObjectAttributes->ObjectName = GuidString; return(ERROR_SUCCESS); } HANDLE APIENTRY WmipCreateThread( LPSECURITY_ATTRIBUTES lpThreadAttributes, DWORD dwStackSize, LPTHREAD_START_ROUTINE lpStartAddress, LPVOID lpParameter, DWORD dwCreationFlags, LPDWORD lpThreadId ) { HANDLE ThreadHandle; NTSTATUS st = RtlCreateUserThread( NtCurrentProcess(), // process handle lpThreadAttributes, // security descriptor TRUE, // Create suspended? 0L, // ZeroBits: default dwStackSize, // Max stack size: default 0L, // Committed stack size: default lpStartAddress, // Function to start in lpParameter, // Event the thread signals when ready &ThreadHandle, // Thread handle return (PCLIENT_ID)lpThreadId // Thread id ); if(NT_SUCCESS(st)){ st = NtResumeThread(ThreadHandle,NULL); } if(NT_SUCCESS(st)){ return ThreadHandle; } else { return NULL; } } ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// // TLS FUNCTIONS ///////////////////////////////////////////////////////// ///////////////////////////////////////////////////////// DWORD WmipTlsAlloc( VOID ) /*++ Routine Description: A TLS index may be allocated using TlsAllocHelper. Win32 garuntees a minimum number of TLS indexes are available in each process. The constant TLS_MINIMUM_AVAILABLE defines the minimum number of available indexes. This minimum is at least 64 for all Win32 systems. Arguments: None. Return Value: Not-0xffffffff - Returns a TLS index that may be used in a subsequent call to TlsFreeHelper, TlsSetValueHelper, or TlsGetValueHelper. The storage associated with the index is initialized to NULL. 0xffffffff - The operation failed. Extended error status is available using GetLastError. --*/ { PPEB Peb; PTEB Teb; DWORD Index; Peb = NtCurrentPeb(); Teb = NtCurrentTeb(); RtlAcquirePebLock(); try { Index = RtlFindClearBitsAndSet((PRTL_BITMAP)Peb->TlsBitmap,1,0); if ( Index == 0xffffffff ) { Index = RtlFindClearBitsAndSet((PRTL_BITMAP)Peb->TlsExpansionBitmap,1,0); if ( Index == 0xffffffff ) { //WmipSetLastError(RtlNtStatusToDosError(STATUS_NO_MEMORY)); } else { if ( !Teb->TlsExpansionSlots ) { Teb->TlsExpansionSlots = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( TMP_TAG ) | HEAP_ZERO_MEMORY, TLS_EXPANSION_SLOTS * sizeof(PVOID) ); if ( !Teb->TlsExpansionSlots ) { RtlClearBits((PRTL_BITMAP)Peb->TlsExpansionBitmap,Index,1); Index = 0xffffffff; //WmipSetLastError(RtlNtStatusToDosError(STATUS_NO_MEMORY)); return Index; } } Teb->TlsExpansionSlots[Index] = NULL; Index += TLS_MINIMUM_AVAILABLE; } } else { Teb->TlsSlots[Index] = NULL; } } finally { RtlReleasePebLock(); } #if DBG Index |= TLS_MASK; #endif return Index; } LPVOID WmipTlsGetValue( DWORD dwTlsIndex ) /*++ Routine Description: This function is used to retrive the value in the TLS storage associated with the specified index. If the index is valid this function clears the value returned by GetLastError(), and returns the value stored in the TLS slot associated with the specified index. Otherwise a value of NULL is returned with GetLastError updated appropriately. It is expected, that DLLs will use TlsAllocHelper and TlsGetValueHelper as follows: - Upon DLL initialization, a TLS index will be allocated using TlsAllocHelper. The DLL will then allocate some dynamic storage and store its address in the TLS slot using TlsSetValueHelper. This completes the per thread initialization for the initial thread of the process. The TLS index is stored in instance data for the DLL. - Each time a new thread attaches to the DLL, the DLL will allocate some dynamic storage and store its address in the TLS slot using TlsSetValueHelper. This completes the per thread initialization for the new thread. - Each time an initialized thread makes a DLL call requiring the TLS, the DLL will call TlsGetValueHelper to get the TLS data for the thread. Arguments: dwTlsIndex - Supplies a TLS index allocated using TlsAllocHelper. The index specifies which TLS slot is to be located. Translating a TlsIndex does not prevent a TlsFreeHelper call from proceding. Return Value: NON-NULL - The function was successful. The value is the data stored in the TLS slot associated with the specified index. NULL - The operation failed, or the value associated with the specified index was NULL. Extended error status is available using GetLastError. If this returns non-zero, the index was invalid. --*/ { PTEB Teb; LPVOID *Slot; #if DBG // See if the Index passed in is from TlsAllocHelper or random goo... ASSERTMSG( "BASEDLL: Invalid TlsIndex passed to TlsGetValueHelper\n", (dwTlsIndex & TLS_MASK)); dwTlsIndex &= ~TLS_MASK; #endif Teb = NtCurrentTeb(); if ( dwTlsIndex < TLS_MINIMUM_AVAILABLE ) { Slot = &Teb->TlsSlots[dwTlsIndex]; Teb->LastErrorValue = 0; return *Slot; } else { if ( dwTlsIndex >= TLS_MINIMUM_AVAILABLE+TLS_EXPANSION_SLOTS ) { WmipSetLastError(RtlNtStatusToDosError(STATUS_INVALID_PARAMETER)); return NULL; } else { Teb->LastErrorValue = 0; if ( Teb->TlsExpansionSlots ) { return Teb->TlsExpansionSlots[dwTlsIndex-TLS_MINIMUM_AVAILABLE]; } else { return NULL; } } } } BOOL WmipTlsSetValue( DWORD dwTlsIndex, LPVOID lpTlsValue ) /*++ Routine Description: This function is used to store a value in the TLS storage associated with the specified index. If the index is valid this function stores the value and returns TRUE. Otherwise a value of FALSE is returned. It is expected, that DLLs will use TlsAllocHelper and TlsSetValueHelper as follows: - Upon DLL initialization, a TLS index will be allocated using TlsAllocHelper. The DLL will then allocate some dynamic storage and store its address in the TLS slot using TlsSetValueHelper. This completes the per thread initialization for the initial thread of the process. The TLS index is stored in instance data for the DLL. - Each time a new thread attaches to the DLL, the DLL will allocate some dynamic storage and store its address in the TLS slot using TlsSetValueHelper. This completes the per thread initialization for the new thread. - Each time an initialized thread makes a DLL call requiring the TLS, the DLL will call TlsGetValueHelper to get the TLS data for the thread. Arguments: dwTlsIndex - Supplies a TLS index allocated using TlsAllocHelper. The index specifies which TLS slot is to be located. Translating a TlsIndex does not prevent a TlsFreeHelper call from proceding. lpTlsValue - Supplies the value to be stored in the TLS Slot. Return Value: TRUE - The function was successful. The value lpTlsValue was stored. FALSE - The operation failed. Extended error status is available using GetLastError. --*/ { PTEB Teb; #if DBG // See if the Index passed in is from TlsAllocHelper or random goo... ASSERTMSG( "BASEDLL: Invalid TlsIndex passed to TlsSetValueHelper\n", (dwTlsIndex & TLS_MASK)); dwTlsIndex &= ~TLS_MASK; #endif Teb = NtCurrentTeb(); if ( dwTlsIndex >= TLS_MINIMUM_AVAILABLE ) { dwTlsIndex -= TLS_MINIMUM_AVAILABLE; if ( dwTlsIndex < TLS_EXPANSION_SLOTS ) { if ( !Teb->TlsExpansionSlots ) { RtlAcquirePebLock(); if ( !Teb->TlsExpansionSlots ) { Teb->TlsExpansionSlots = RtlAllocateHeap( RtlProcessHeap(), MAKE_TAG( TMP_TAG ) | HEAP_ZERO_MEMORY, TLS_EXPANSION_SLOTS * sizeof(PVOID) ); if ( !Teb->TlsExpansionSlots ) { RtlReleasePebLock(); WmipSetLastError(RtlNtStatusToDosError(STATUS_NO_MEMORY)); return FALSE; } } RtlReleasePebLock(); } Teb->TlsExpansionSlots[dwTlsIndex] = lpTlsValue; } else { WmipSetLastError(RtlNtStatusToDosError(STATUS_INVALID_PARAMETER)); return FALSE; } } else { Teb->TlsSlots[dwTlsIndex] = lpTlsValue; } return TRUE; } BOOL WmipTlsFree( DWORD dwTlsIndex ) /*++ Routine Description: A valid TLS index may be free'd using TlsFreeHelper. Arguments: dwTlsIndex - Supplies a TLS index allocated using TlsAllocHelper. If the index is a valid index, it is released by this call and is made available for reuse. DLLs should be carefull to release any per-thread data pointed to by all of their threads TLS slots before calling this function. It is expected that DLLs will only call this function (if at ALL) during their process detach routine. Return Value: TRUE - The operation was successful. Calling TlsTranslateIndex with this index will fail. TlsAllocHelper is free to reallocate this index. FALSE - The operation failed. Extended error status is available using GetLastError. --*/ { PPEB Peb; BOOLEAN ValidIndex; PRTL_BITMAP TlsBitmap; NTSTATUS Status; DWORD Index2; #if DBG // See if the Index passed in is from TlsAllocHelper or random goo... ASSERTMSG( "BASEDLL: Invalid TlsIndex passed to TlsFreeHelper\n", (dwTlsIndex & TLS_MASK)); dwTlsIndex &= ~TLS_MASK; #endif Peb = NtCurrentPeb(); RtlAcquirePebLock(); try { if ( dwTlsIndex >= TLS_MINIMUM_AVAILABLE ) { Index2 = dwTlsIndex - TLS_MINIMUM_AVAILABLE; if ( Index2 >= TLS_EXPANSION_SLOTS ) { ValidIndex = FALSE; } else { TlsBitmap = (PRTL_BITMAP)Peb->TlsExpansionBitmap; ValidIndex = RtlAreBitsSet(TlsBitmap,Index2,1); } } else { TlsBitmap = (PRTL_BITMAP)Peb->TlsBitmap; Index2 = dwTlsIndex; ValidIndex = RtlAreBitsSet(TlsBitmap,Index2,1); } if ( ValidIndex ) { Status = NtSetInformationThread( NtCurrentThread(), ThreadZeroTlsCell, &dwTlsIndex, sizeof(dwTlsIndex) ); if ( !NT_SUCCESS(Status) ) { WmipSetLastError(RtlNtStatusToDosError(STATUS_INVALID_PARAMETER)); return FALSE; } RtlClearBits(TlsBitmap,Index2,1); } else { WmipSetLastError(RtlNtStatusToDosError(STATUS_INVALID_PARAMETER)); } } finally { RtlReleasePebLock(); } return ValidIndex; } BOOL WmipBasep8BitStringToDynamicUnicodeString( OUT PUNICODE_STRING UnicodeString, IN LPCSTR lpSourceString ) /*++ Routine Description: Captures and converts a 8-bit (OEM or ANSI) string into a heap-allocated UNICODE string Arguments: UnicodeString - location where UNICODE_STRING is stored lpSourceString - string in OEM or ANSI Return Value: TRUE if string is correctly stored, FALSE if an error occurred. In the error case, the last error is correctly set. --*/ { ANSI_STRING AnsiString; NTSTATUS Status; // // Convert input into dynamic unicode string // RtlInitString( &AnsiString, lpSourceString ); Status = RtlAnsiStringToUnicodeString( UnicodeString, &AnsiString, TRUE ); // // If we couldn't do this, fail // if (!NT_SUCCESS( Status )){ if ( Status == STATUS_BUFFER_OVERFLOW ) { WmipSetLastError( ERROR_FILENAME_EXCED_RANGE ); } else { WmipBaseSetLastNTError( Status ); } return FALSE; } return TRUE; } DWORD APIENTRY WmipGetFullPathNameA( LPCSTR lpFileName, DWORD nBufferLength, LPSTR lpBuffer, LPSTR *lpFilePart ) /*++ Routine Description: ANSI thunk to GetFullPathNameW --*/ { NTSTATUS Status; ULONG UnicodeLength; UNICODE_STRING UnicodeString; UNICODE_STRING UnicodeResult; ANSI_STRING AnsiResult; PWSTR Ubuff; PWSTR FilePart; PWSTR *FilePartPtr; INT PrefixLength = 0; if ( ARGUMENT_PRESENT(lpFilePart) ) { FilePartPtr = &FilePart; } else { FilePartPtr = NULL; } if (!WmipBasep8BitStringToDynamicUnicodeString( &UnicodeString, lpFileName )) { return 0; } Ubuff = RtlAllocateHeap(RtlProcessHeap(), MAKE_TAG( TMP_TAG ), (MAX_PATH<<1) + sizeof(UNICODE_NULL)); if ( !Ubuff ) { RtlFreeUnicodeString(&UnicodeString); WmipBaseSetLastNTError(STATUS_NO_MEMORY); return 0; } UnicodeLength = RtlGetFullPathName_U( UnicodeString.Buffer, (MAX_PATH<<1), Ubuff, FilePartPtr ); // // UnicodeLength contains the byte count of unicode string. // Original code does "UnicodeLength / sizeof(WCHAR)" to get // the size of corresponding ansi string. // This is correct in SBCS environment. However in DBCS environment, // it's definitely WRONG. // if ( UnicodeLength <= ((MAX_PATH * sizeof(WCHAR) + sizeof(UNICODE_NULL))) ) { Status = RtlUnicodeToMultiByteSize(&UnicodeLength, Ubuff, UnicodeLength); // // At this point, UnicodeLength variable contains // Ansi based byte length. // if ( NT_SUCCESS(Status) ) { if ( UnicodeLength && ARGUMENT_PRESENT(lpFilePart) && FilePart != NULL ) { INT UnicodePrefixLength; UnicodePrefixLength = (INT)(FilePart - Ubuff) * sizeof(WCHAR); Status = RtlUnicodeToMultiByteSize( &PrefixLength, Ubuff, UnicodePrefixLength ); // // At this point, PrefixLength variable contains // Ansi based byte length. // if ( !NT_SUCCESS(Status) ) { WmipBaseSetLastNTError(Status); UnicodeLength = 0; } } } else { WmipBaseSetLastNTError(Status); UnicodeLength = 0; } } else { // // we exceed the MAX_PATH limit. we should log the error and // return zero. however US code returns the byte count of // buffer required and doesn't log any error. // UnicodeLength = 0; } if ( UnicodeLength && UnicodeLength < nBufferLength ) { RtlInitUnicodeString(&UnicodeResult,Ubuff); Status = BasepUnicodeStringTo8BitString(&AnsiResult,&UnicodeResult,TRUE); if ( NT_SUCCESS(Status) ) { RtlMoveMemory(lpBuffer,AnsiResult.Buffer,UnicodeLength+1); RtlFreeAnsiString(&AnsiResult); if ( ARGUMENT_PRESENT(lpFilePart) ) { if ( FilePart == NULL ) { *lpFilePart = NULL; } else { *lpFilePart = lpBuffer + PrefixLength; } } } else { WmipBaseSetLastNTError(Status); UnicodeLength = 0; } } else { if ( UnicodeLength ) { UnicodeLength++; } } RtlFreeUnicodeString(&UnicodeString); RtlFreeHeap(RtlProcessHeap(), 0,Ubuff); return (DWORD)UnicodeLength; }