| 1 |
#include <stddef.h> |
| 2 |
#include <windows.h> |
| 3 |
#include <ntstatus.h> |
| 4 |
#include <winternl.h> |
| 5 |
|
| 6 |
#include "debug.h" |
| 7 |
#include "wine/compiler.h" |
| 8 |
#include "wine/debug.h" |
| 9 |
|
| 10 |
|
| 11 |
#define FILE_ATTRIBUTE_VALID_FLAGS 0x00007fb7 |
| 12 |
|
| 13 |
static UINT get_nt_file_options(DWORD attributes) |
| 14 |
{ |
| 15 |
UINT options = 0; |
| 16 |
|
| 17 |
if (attributes & FILE_FLAG_BACKUP_SEMANTICS) |
| 18 |
options |= FILE_OPEN_FOR_BACKUP_INTENT; |
| 19 |
else |
| 20 |
options |= FILE_NON_DIRECTORY_FILE; |
| 21 |
if (attributes & FILE_FLAG_DELETE_ON_CLOSE) |
| 22 |
options |= FILE_DELETE_ON_CLOSE; |
| 23 |
if (attributes & FILE_FLAG_NO_BUFFERING) |
| 24 |
options |= FILE_NO_INTERMEDIATE_BUFFERING; |
| 25 |
if (!(attributes & FILE_FLAG_OVERLAPPED)) |
| 26 |
options |= FILE_SYNCHRONOUS_IO_NONALERT; |
| 27 |
if (attributes & FILE_FLAG_RANDOM_ACCESS) |
| 28 |
options |= FILE_RANDOM_ACCESS; |
| 29 |
if (attributes & FILE_FLAG_SEQUENTIAL_SCAN) |
| 30 |
options |= FILE_SEQUENTIAL_ONLY; |
| 31 |
if (attributes & FILE_FLAG_WRITE_THROUGH) |
| 32 |
options |= FILE_WRITE_THROUGH; |
| 33 |
return options; |
| 34 |
} |
| 35 |
|
| 36 |
HANDLE WINAPI CreateFileW(LPCWSTR filename, DWORD access, DWORD sharing, LPSECURITY_ATTRIBUTES sa, DWORD creation, DWORD attributes, HANDLE template) |
| 37 |
{ |
| 38 |
UNICODE_STRING filenameU; |
| 39 |
OBJECT_ATTRIBUTES attr; |
| 40 |
IO_STATUS_BLOCK io; |
| 41 |
HANDLE ret; |
| 42 |
|
| 43 |
static const UINT nt_disposition[5] = { FILE_CREATE, FILE_OVERWRITE_IF, FILE_OPEN, FILE_OPEN_IF, FILE_OVERWRITE }; |
| 44 |
if (!RtlDosPathNameToNtPathName_U(filename, &filenameU, NULL, NULL)) { |
| 45 |
return INVALID_HANDLE_VALUE; |
| 46 |
} |
| 47 |
if (attributes & FILE_FLAG_DELETE_ON_CLOSE) access |= DELETE; |
| 48 |
InitializeObjectAttributes(&attr, &filenameU, OBJ_CASE_INSENSITIVE, 0, NULL); |
| 49 |
NTSTATUS status = NtCreateFile(&ret, access | GENERIC_READ | SYNCHRONIZE, &attr, &io, NULL, attributes & FILE_ATTRIBUTE_VALID_FLAGS, sharing, |
| 50 |
nt_disposition[creation - CREATE_NEW], get_nt_file_options(attributes), NULL, 0); |
| 51 |
RtlFreeUnicodeString(&filenameU); |
| 52 |
return status ? INVALID_HANDLE_VALUE : ret; |
| 53 |
} |
| 54 |
|
| 55 |
HANDLE WINAPI CreateFileA(LPCSTR name, DWORD access, DWORD sharing, LPSECURITY_ATTRIBUTES sa, DWORD creation, DWORD attributes, HANDLE template) |
| 56 |
{ |
| 57 |
UNICODE_STRING nameU; |
| 58 |
RtlCreateUnicodeStringFromAsciiz(&nameU, name); |
| 59 |
HANDLE handle = CreateFileW(nameU.Buffer, access, sharing, sa, creation, attributes, template); |
| 60 |
RtlFreeUnicodeString(&nameU); |
| 61 |
return handle; |
| 62 |
} |
| 63 |
|
| 64 |
|
| 65 |
BOOL WINAPI CloseHandle(HANDLE handle) |
| 66 |
{ |
| 67 |
return !NtClose(handle); |
| 68 |
} |
| 69 |
|
| 70 |
DWORD WINAPI GetEnvironmentVariableA(LPCSTR name, LPSTR value, DWORD size) |
| 71 |
{ |
| 72 |
UNICODE_STRING nameU, valueU; |
| 73 |
PWSTR valueW; |
| 74 |
NTSTATUS status; |
| 75 |
DWORD len, ret; |
| 76 |
|
| 77 |
if (!(valueW = RtlAllocateHeap(GetProcessHeap(), 0, size * sizeof(WCHAR)))) return 0; |
| 78 |
|
| 79 |
RtlCreateUnicodeStringFromAsciiz(&nameU, name); |
| 80 |
valueU.Length = 0; |
| 81 |
valueU.MaximumLength = (size ? size - 1 : 0) * sizeof(WCHAR); |
| 82 |
valueU.Buffer = valueW; |
| 83 |
|
| 84 |
status = RtlQueryEnvironmentVariable_U(NULL, &nameU, &valueU); |
| 85 |
len = valueU.Length / sizeof(WCHAR); |
| 86 |
if (status == STATUS_BUFFER_TOO_SMALL) |
| 87 |
ret = len + 1; |
| 88 |
else if (status) |
| 89 |
ret = 0; |
| 90 |
else if (!size) |
| 91 |
ret = len + 1; |
| 92 |
else { |
| 93 |
if (len) RtlUnicodeToMultiByteN(value, size, &ret, valueW, len * sizeof(WCHAR)); |
| 94 |
} |
| 95 |
|
| 96 |
RtlFreeUnicodeString(&nameU); |
| 97 |
RtlFreeHeap(GetProcessHeap(), 0, valueW); |
| 98 |
return ret; |
| 99 |
} |
| 100 |
|
| 101 |
DWORD WINAPI GetFileAttributesW(LPCWSTR name) |
| 102 |
{ |
| 103 |
FILE_BASIC_INFORMATION info; |
| 104 |
UNICODE_STRING nameU; |
| 105 |
OBJECT_ATTRIBUTES attr; |
| 106 |
NTSTATUS status; |
| 107 |
|
| 108 |
if (!RtlDosPathNameToNtPathName_U(name, &nameU, NULL, NULL)) { |
| 109 |
return INVALID_FILE_ATTRIBUTES; |
| 110 |
} |
| 111 |
|
| 112 |
InitializeObjectAttributes(&attr, &nameU, OBJ_CASE_INSENSITIVE, 0, NULL); |
| 113 |
status = NtQueryAttributesFile(&attr, &info); |
| 114 |
RtlFreeUnicodeString(&nameU); |
| 115 |
|
| 116 |
if (status == STATUS_SUCCESS) return info.FileAttributes; |
| 117 |
if (RtlIsDosDeviceName_U(name)) return FILE_ATTRIBUTE_ARCHIVE; |
| 118 |
return INVALID_FILE_ATTRIBUTES; |
| 119 |
} |
| 120 |
|
| 121 |
DWORD WINAPI GetFileAttributesA(LPCSTR name) |
| 122 |
{ |
| 123 |
UNICODE_STRING nameU; |
| 124 |
RtlCreateUnicodeStringFromAsciiz(&nameU, name); |
| 125 |
DWORD ret = GetFileAttributesW(nameU.Buffer); |
| 126 |
RtlFreeUnicodeString(&nameU); |
| 127 |
return ret; |
| 128 |
} |
| 129 |
|
| 130 |
HANDLE WINAPI GetProcessHeap(void) |
| 131 |
{ |
| 132 |
return ((HANDLE**)NtCurrentTeb())[12][6]; |
| 133 |
} |
| 134 |
|
| 135 |
|
| 136 |
DWORD WINAPI GetModuleFileNameW(HMODULE module, LPWSTR filename, DWORD size) |
| 137 |
{ |
| 138 |
ULONG len = 0; |
| 139 |
UNICODE_STRING filenameU; |
| 140 |
NTSTATUS status; |
| 141 |
|
| 142 |
filenameU.Buffer = filename; |
| 143 |
filenameU.MaximumLength = min(size, UNICODE_STRING_MAX_CHARS) * sizeof(WCHAR); |
| 144 |
status = LdrGetDllFullName(module, &filenameU); |
| 145 |
if (!status || status == STATUS_BUFFER_TOO_SMALL) len = filenameU.Length / sizeof(WCHAR); |
| 146 |
return len; |
| 147 |
} |
| 148 |
|
| 149 |
|
| 150 |
DWORD WINAPI GetModuleFileNameA(HMODULE module, LPSTR filename, DWORD size) |
| 151 |
{ |
| 152 |
LPWSTR filenameW = RtlAllocateHeap(GetProcessHeap(), 0, size * sizeof(WCHAR)); |
| 153 |
DWORD len, ret = 0; |
| 154 |
|
| 155 |
if (!filenameW) return 0; |
| 156 |
|
| 157 |
if ((len = GetModuleFileNameW(module, filenameW, size))) { |
| 158 |
RtlUnicodeToMultiByteN(filename, size, &ret, filenameW, len * sizeof(WCHAR)); |
| 159 |
if (ret < size) filename[ret] = 0; |
| 160 |
} |
| 161 |
RtlFreeHeap(GetProcessHeap(), 0, filenameW); |
| 162 |
return ret; |
| 163 |
} |
| 164 |
|
| 165 |
BOOL WINAPI ReadFile(HANDLE file, LPVOID buffer, DWORD count, LPDWORD result, LPOVERLAPPED overlapped) |
| 166 |
{ |
| 167 |
LARGE_INTEGER offset; |
| 168 |
PLARGE_INTEGER poffset = NULL; |
| 169 |
IO_STATUS_BLOCK iosb; |
| 170 |
PIO_STATUS_BLOCK io_status = &iosb; |
| 171 |
HANDLE event = 0; |
| 172 |
NTSTATUS status; |
| 173 |
LPVOID cvalue = NULL; |
| 174 |
|
| 175 |
if (result) *result = 0; |
| 176 |
|
| 177 |
if (overlapped) { |
| 178 |
printf_log(LOG_NONE, "unimplemented overlapped in ReadFile\n"); |
| 179 |
return FALSE; |
| 180 |
} else |
| 181 |
io_status->Information = 0; |
| 182 |
io_status->Status = STATUS_PENDING; |
| 183 |
|
| 184 |
status = NtReadFile(file, event, NULL, cvalue, io_status, buffer, count, poffset, NULL); |
| 185 |
|
| 186 |
if (status == STATUS_PENDING && !overlapped) { |
| 187 |
printf_log(LOG_NONE, "unimplemented pending in ReadFile\n"); |
| 188 |
} |
| 189 |
|
| 190 |
if (result) *result = overlapped && status ? 0 : io_status->Information; |
| 191 |
|
| 192 |
if (status == STATUS_END_OF_FILE) { |
| 193 |
if (overlapped != NULL) { |
| 194 |
return FALSE; |
| 195 |
} |
| 196 |
} else if (status && status != STATUS_TIMEOUT) { |
| 197 |
return FALSE; |
| 198 |
} |
| 199 |
return TRUE; |
| 200 |
} |
| 201 |
|
| 202 |
|
| 203 |
static void fillSystemInfo(SYSTEM_INFO* si, const SYSTEM_BASIC_INFORMATION__* basic_info, const SYSTEM_CPU_INFORMATION* cpu_info) |
| 204 |
{ |
| 205 |
si->wProcessorArchitecture = cpu_info->ProcessorArchitecture; |
| 206 |
si->wReserved = 0; |
| 207 |
si->dwPageSize = basic_info->PageSize; |
| 208 |
si->lpMinimumApplicationAddress = basic_info->LowestUserAddress; |
| 209 |
si->lpMaximumApplicationAddress = basic_info->HighestUserAddress; |
| 210 |
si->dwActiveProcessorMask = basic_info->ActiveProcessorsAffinityMask; |
| 211 |
si->dwNumberOfProcessors = basic_info->NumberOfProcessors; |
| 212 |
si->dwAllocationGranularity = basic_info->AllocationGranularity; |
| 213 |
si->wProcessorLevel = cpu_info->ProcessorLevel; |
| 214 |
si->wProcessorRevision = cpu_info->ProcessorRevision; |
| 215 |
|
| 216 |
switch (cpu_info->ProcessorArchitecture) { |
| 217 |
case PROCESSOR_ARCHITECTURE_ARM64: |
| 218 |
si->dwProcessorType = 0; |
| 219 |
break; |
| 220 |
default: |
| 221 |
printf_log(LOG_NONE, "Unknown processor architecture %x\n", cpu_info->ProcessorArchitecture); |
| 222 |
si->dwProcessorType = 0; |
| 223 |
break; |
| 224 |
} |
| 225 |
} |
| 226 |
|
| 227 |
void WINAPI GetSystemInfo(SYSTEM_INFO* si) |
| 228 |
{ |
| 229 |
SYSTEM_BASIC_INFORMATION__ basic_info; |
| 230 |
SYSTEM_CPU_INFORMATION cpu_info; |
| 231 |
|
| 232 |
if (NtQuerySystemInformation(0 /* SystemBasicInformation */, &basic_info, sizeof(basic_info), NULL) |
| 233 |
|| NtQuerySystemInformation(1 /* SystemCpuInformation */, &cpu_info, sizeof(cpu_info), NULL)) |
| 234 |
return; |
| 235 |
|
| 236 |
fillSystemInfo(si, &basic_info, &cpu_info); |
| 237 |
} |
| 238 |
|
| 239 |
BOOL WINAPI IsProcessorFeaturePresent(DWORD feature) |
| 240 |
{ |
| 241 |
return RtlIsProcessorFeaturePresent(feature); |
| 242 |
} |
| 243 |
|
| 244 |
LSTATUS WINAPI RegOpenKeyExA(HKEY hkey, LPCSTR name, DWORD options, REGSAM access, PHKEY retkey) |
| 245 |
{ |
| 246 |
if (hkey != HKEY_LOCAL_MACHINE) { |
| 247 |
printf_log(LOG_NONE, "Unsupported registry key %p\n", hkey); |
| 248 |
return ERROR_INVALID_HANDLE; |
| 249 |
} |
| 250 |
|
| 251 |
UNICODE_STRING rootkeyU; |
| 252 |
UNICODE_STRING nameU; |
| 253 |
OBJECT_ATTRIBUTES attr; |
| 254 |
NTSTATUS status; |
| 255 |
HANDLE handle; |
| 256 |
RtlInitUnicodeString(&rootkeyU, L"\\Registry\\Machine"); |
| 257 |
InitializeObjectAttributes(&attr, &rootkeyU, OBJ_CASE_INSENSITIVE, 0, NULL); |
| 258 |
if (NtOpenKey(&handle, access, &attr)) return RtlNtStatusToDosError(status); |
| 259 |
|
| 260 |
RtlCreateUnicodeStringFromAsciiz(&nameU, name); |
| 261 |
InitializeObjectAttributes(&attr, &nameU, OBJ_CASE_INSENSITIVE, handle, NULL); |
| 262 |
status = NtOpenKey((HANDLE*)retkey, access, &attr); |
| 263 |
RtlFreeUnicodeString(&nameU); |
| 264 |
NtClose(handle); |
| 265 |
return RtlNtStatusToDosError(status); |
| 266 |
} |
| 267 |
|
| 268 |
LSTATUS WINAPI RegQueryValueExA(HKEY hkey, LPCSTR name, LPDWORD reserved, LPDWORD type, LPBYTE data, LPDWORD count) |
| 269 |
{ |
| 270 |
NTSTATUS status; |
| 271 |
ANSI_STRING nameA; |
| 272 |
UNICODE_STRING nameW; |
| 273 |
DWORD total_size, datalen = 0; |
| 274 |
char buffer[256]; |
| 275 |
KEY_VALUE_PARTIAL_INFORMATION* info = (KEY_VALUE_PARTIAL_INFORMATION*)buffer; |
| 276 |
static const int info_size = offsetof(KEY_VALUE_PARTIAL_INFORMATION, Data); |
| 277 |
|
| 278 |
if ((data && !count) || reserved) return ERROR_INVALID_PARAMETER; |
| 279 |
|
| 280 |
if (count) datalen = *count; |
| 281 |
if (!data && count) *count = 0; |
| 282 |
|
| 283 |
RtlInitAnsiString(&nameA, name); |
| 284 |
if ((status = RtlAnsiStringToUnicodeString(&nameW, &nameA, TRUE))) |
| 285 |
return RtlNtStatusToDosError(status); |
| 286 |
|
| 287 |
status = NtQueryValueKey(hkey, &nameW, KeyValuePartialInformation, buffer, sizeof(buffer), &total_size); |
| 288 |
if (status) { |
| 289 |
RtlFreeUnicodeString(&nameW); |
| 290 |
return RtlNtStatusToDosError(status); |
| 291 |
} |
| 292 |
|
| 293 |
if (data) { |
| 294 |
if (total_size - info_size > datalen) |
| 295 |
status = STATUS_BUFFER_OVERFLOW; |
| 296 |
else |
| 297 |
memcpy(data, buffer + info_size, total_size - info_size); |
| 298 |
} else |
| 299 |
status = STATUS_SUCCESS; |
| 300 |
|
| 301 |
if (type) *type = info->Type; |
| 302 |
if (count) *count = total_size - info_size; |
| 303 |
|
| 304 |
RtlFreeUnicodeString(&nameW); |
| 305 |
return RtlNtStatusToDosError(status); |
| 306 |
} |
| 307 |
|
| 308 |
LSTATUS WINAPI RegCloseKey(HKEY hkey) |
| 309 |
{ |
| 310 |
if (!hkey) return ERROR_INVALID_HANDLE; |
| 311 |
return RtlNtStatusToDosError(NtClose(hkey)); |
| 312 |
} |