Debian Codegraph @

wine/common/wrt.c

raw
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 }