?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
wined3d: Add an ARB_sync implementation of event queries.
[wine.git] / dlls / ntdll / tests / file.c
blob3672b514401761aa63e30cb17027c3a3362cf5b0
1 /* Unit test suite for Ntdll file functions
2 *
3 * Copyright 2007 Jeff Latimer
4 * Copyright 2007 Andrey Turkin
5 * Copyright 2008 Jeff Zaroyko
6 *
7 * This library is free software; you can redistribute it and/or
8 * modify it under the terms of the GNU Lesser General Public
9 * License as published by the Free Software Foundation; either
10 * version 2.1 of the License, or (at your option) any later version.
11 *
12 * This library is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 * Lesser General Public License for more details.
16 *
17 * You should have received a copy of the GNU Lesser General Public
18 * License along with this library; if not, write to the Free Software
19 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
20 *
21 * NOTES
22 * We use function pointers here as there is no import library for NTDLL on
23 * windows.
24 */
25
26 #include <stdio.h>
27 #include <stdarg.h>
28
29 #include "ntstatus.h"
30 /* Define WIN32_NO_STATUS so MSVC does not give us duplicate macro
31 * definition errors when we get to winnt.h
32 */
33 #define WIN32_NO_STATUS
34
35 #include "wine/test.h"
36 #include "winternl.h"
37 #include "winuser.h"
38
39 #ifndef IO_COMPLETION_ALL_ACCESS
40 #define IO_COMPLETION_ALL_ACCESS 0x001F0003
41 #endif
42
43 static BOOL (WINAPI * pGetVolumePathNameW)(LPCWSTR, LPWSTR, DWORD);
44 static UINT (WINAPI *pGetSystemWow64DirectoryW)( LPWSTR, UINT );
45
46 static VOID (WINAPI *pRtlFreeUnicodeString)( PUNICODE_STRING );
47 static VOID (WINAPI *pRtlInitUnicodeString)( PUNICODE_STRING, LPCWSTR );
48 static BOOL (WINAPI *pRtlDosPathNameToNtPathName_U)( LPCWSTR, PUNICODE_STRING, PWSTR*, CURDIR* );
49 static NTSTATUS (WINAPI *pRtlWow64EnableFsRedirectionEx)( ULONG, ULONG * );
50
51 static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
52 ULONG, ULONG, ULONG, PLARGE_INTEGER );
53 static NTSTATUS (WINAPI *pNtCreateFile)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,PLARGE_INTEGER,ULONG,ULONG,ULONG,ULONG,PVOID,ULONG);
54 static NTSTATUS (WINAPI *pNtOpenFile)(PHANDLE,ACCESS_MASK,POBJECT_ATTRIBUTES,PIO_STATUS_BLOCK,ULONG,ULONG);
55 static NTSTATUS (WINAPI *pNtDeleteFile)(POBJECT_ATTRIBUTES ObjectAttributes);
56 static NTSTATUS (WINAPI *pNtReadFile)(HANDLE hFile, HANDLE hEvent,
57 PIO_APC_ROUTINE apc, void* apc_user,
58 PIO_STATUS_BLOCK io_status, void* buffer, ULONG length,
59 PLARGE_INTEGER offset, PULONG key);
60 static NTSTATUS (WINAPI *pNtWriteFile)(HANDLE hFile, HANDLE hEvent,
61 PIO_APC_ROUTINE apc, void* apc_user,
62 PIO_STATUS_BLOCK io_status,
63 const void* buffer, ULONG length,
64 PLARGE_INTEGER offset, PULONG key);
65 static NTSTATUS (WINAPI *pNtCancelIoFile)(HANDLE hFile, PIO_STATUS_BLOCK io_status);
66 static NTSTATUS (WINAPI *pNtCancelIoFileEx)(HANDLE hFile, PIO_STATUS_BLOCK iosb, PIO_STATUS_BLOCK io_status);
67 static NTSTATUS (WINAPI *pNtClose)( PHANDLE );
68
69 static NTSTATUS (WINAPI *pNtCreateIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG);
70 static NTSTATUS (WINAPI *pNtOpenIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
71 static NTSTATUS (WINAPI *pNtQueryIoCompletion)(HANDLE, IO_COMPLETION_INFORMATION_CLASS, PVOID, ULONG, PULONG);
72 static NTSTATUS (WINAPI *pNtRemoveIoCompletion)(HANDLE, PULONG_PTR, PULONG_PTR, PIO_STATUS_BLOCK, PLARGE_INTEGER);
73 static NTSTATUS (WINAPI *pNtSetIoCompletion)(HANDLE, ULONG_PTR, ULONG_PTR, NTSTATUS, ULONG);
74 static NTSTATUS (WINAPI *pNtSetInformationFile)(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS);
75 static NTSTATUS (WINAPI *pNtQueryInformationFile)(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS);
76 static NTSTATUS (WINAPI *pNtQueryDirectoryFile)(HANDLE,HANDLE,PIO_APC_ROUTINE,PVOID,PIO_STATUS_BLOCK,
77 PVOID,ULONG,FILE_INFORMATION_CLASS,BOOLEAN,PUNICODE_STRING,BOOLEAN);
78
79 static inline BOOL is_signaled( HANDLE obj )
80 {
81 return WaitForSingleObject( obj, 0 ) == 0;
82 }
83
84 #define PIPENAME "\\\\.\\pipe\\ntdll_tests_file.c"
85 #define TEST_BUF_LEN 3
86
87 static BOOL create_pipe( HANDLE *read, HANDLE *write, ULONG flags, ULONG size )
88 {
89 *read = CreateNamedPipe(PIPENAME, PIPE_ACCESS_INBOUND | flags, PIPE_TYPE_BYTE | PIPE_WAIT,
90 1, size, size, NMPWAIT_USE_DEFAULT_WAIT, NULL);
91 ok(*read != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
92
93 *write = CreateFileA(PIPENAME, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
94 ok(*write != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError());
95
96 return TRUE;
97 }
98
99 static HANDLE create_temp_file( ULONG flags )
100 {
101 char buffer[MAX_PATH];
102 HANDLE handle;
103
104 GetTempFileNameA( ".", "foo", 0, buffer );
105 handle = CreateFileA(buffer, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
106 flags | FILE_FLAG_DELETE_ON_CLOSE, 0);
107 ok( handle != INVALID_HANDLE_VALUE, "failed to create temp file\n" );
108 return (handle == INVALID_HANDLE_VALUE) ? 0 : handle;
109 }
110
111 #define CVALUE_FIRST 0xfffabbcc
112 #define CKEY_FIRST 0x1030341
113 #define CKEY_SECOND 0x132E46
114
115 ULONG_PTR completionKey;
116 IO_STATUS_BLOCK ioSb;
117 ULONG_PTR completionValue;
118
119 static long get_pending_msgs(HANDLE h)
120 {
121 NTSTATUS res;
122 ULONG a, req;
123
124 res = pNtQueryIoCompletion( h, IoCompletionBasicInformation, &a, sizeof(a), &req );
125 ok( res == STATUS_SUCCESS, "NtQueryIoCompletion failed: %x\n", res );
126 if (res != STATUS_SUCCESS) return -1;
127 ok( req == sizeof(a), "Unexpected response size: %x\n", req );
128 return a;
129 }
130
131 static BOOL get_msg(HANDLE h)
132 {
133 LARGE_INTEGER timeout = {{-10000000*3}};
134 DWORD res = pNtRemoveIoCompletion( h, &completionKey, &completionValue, &ioSb, &timeout);
135 ok( res == STATUS_SUCCESS, "NtRemoveIoCompletion failed: %x\n", res );
136 if (res != STATUS_SUCCESS)
137 {
138 completionKey = completionValue = 0;
139 memset(&ioSb, 0, sizeof(ioSb));
140 return FALSE;
141 }
142 return TRUE;
143 }
144
145
146 static void WINAPI apc( void *arg, IO_STATUS_BLOCK *iosb, ULONG reserved )
147 {
148 int *count = arg;
149
150 trace( "apc called block %p iosb.status %x iosb.info %lu\n",
151 iosb, U(*iosb).Status, iosb->Information );
152 (*count)++;
153 ok( !reserved, "reserved is not 0: %x\n", reserved );
154 }
155
156 static void create_file_test(void)
157 {
158 NTSTATUS status;
159 HANDLE dir;
160 WCHAR path[MAX_PATH];
161 OBJECT_ATTRIBUTES attr;
162 IO_STATUS_BLOCK io;
163 UNICODE_STRING nameW;
164 UINT len;
165
166 len = GetCurrentDirectoryW( MAX_PATH, path );
167 pRtlDosPathNameToNtPathName_U( path, &nameW, NULL, NULL );
168 attr.Length = sizeof(attr);
169 attr.RootDirectory = 0;
170 attr.ObjectName = &nameW;
171 attr.Attributes = OBJ_CASE_INSENSITIVE;
172 attr.SecurityDescriptor = NULL;
173 attr.SecurityQualityOfService = NULL;
174
175 /* try various open modes and options on directories */
176 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
177 FILE_OPEN, FILE_DIRECTORY_FILE, NULL, 0 );
178 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
179 CloseHandle( dir );
180
181 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
182 FILE_CREATE, FILE_DIRECTORY_FILE, NULL, 0 );
183 ok( status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_ACCESS_DENIED,
184 "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
185
186 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
187 FILE_OPEN_IF, FILE_DIRECTORY_FILE, NULL, 0 );
188 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
189 CloseHandle( dir );
190
191 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
192 FILE_SUPERSEDE, FILE_DIRECTORY_FILE, NULL, 0 );
193 ok( status == STATUS_INVALID_PARAMETER, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
194
195 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
196 FILE_OVERWRITE, FILE_DIRECTORY_FILE, NULL, 0 );
197 ok( status == STATUS_INVALID_PARAMETER, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
198
199 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
200 FILE_OVERWRITE_IF, FILE_DIRECTORY_FILE, NULL, 0 );
201 ok( status == STATUS_INVALID_PARAMETER, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
202
203 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
204 FILE_OPEN, 0, NULL, 0 );
205 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
206 CloseHandle( dir );
207
208 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
209 FILE_CREATE, 0, NULL, 0 );
210 ok( status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_ACCESS_DENIED,
211 "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
212
213 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
214 FILE_OPEN_IF, 0, NULL, 0 );
215 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
216 CloseHandle( dir );
217
218 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
219 FILE_SUPERSEDE, 0, NULL, 0 );
220 ok( status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_ACCESS_DENIED,
221 "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
222
223 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
224 FILE_OVERWRITE, 0, NULL, 0 );
225 ok( status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_ACCESS_DENIED,
226 "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
227
228 status = pNtCreateFile( &dir, GENERIC_READ, &attr, &io, NULL, 0, FILE_SHARE_READ|FILE_SHARE_WRITE,
229 FILE_OVERWRITE_IF, 0, NULL, 0 );
230 ok( status == STATUS_OBJECT_NAME_COLLISION || status == STATUS_ACCESS_DENIED,
231 "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
232
233 pRtlFreeUnicodeString( &nameW );
234 }
235
236 static void open_file_test(void)
237 {
238 NTSTATUS status;
239 HANDLE dir, root, handle;
240 WCHAR path[MAX_PATH];
241 BYTE data[8192];
242 OBJECT_ATTRIBUTES attr;
243 IO_STATUS_BLOCK io;
244 UNICODE_STRING nameW;
245 UINT i, len;
246 BOOL restart = TRUE;
247
248 len = GetWindowsDirectoryW( path, MAX_PATH );
249 pRtlDosPathNameToNtPathName_U( path, &nameW, NULL, NULL );
250 attr.Length = sizeof(attr);
251 attr.RootDirectory = 0;
252 attr.ObjectName = &nameW;
253 attr.Attributes = OBJ_CASE_INSENSITIVE;
254 attr.SecurityDescriptor = NULL;
255 attr.SecurityQualityOfService = NULL;
256 status = pNtOpenFile( &dir, GENERIC_READ, &attr, &io,
257 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
258 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
259 pRtlFreeUnicodeString( &nameW );
260
261 path[3] = 0; /* root of the drive */
262 pRtlDosPathNameToNtPathName_U( path, &nameW, NULL, NULL );
263 status = pNtOpenFile( &root, GENERIC_READ, &attr, &io,
264 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
265 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
266 pRtlFreeUnicodeString( &nameW );
267
268 /* test opening system dir with RootDirectory set to windows dir */
269 GetSystemDirectoryW( path, MAX_PATH );
270 while (path[len] == '\\') len++;
271 nameW.Buffer = path + len;
272 nameW.Length = lstrlenW(path + len) * sizeof(WCHAR);
273 attr.RootDirectory = dir;
274 status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
275 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
276 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
277 CloseHandle( handle );
278
279 /* try uppercase name */
280 for (i = len; path[i]; i++) if (path[i] >= 'a' && path[i] <= 'z') path[i] -= 'a' - 'A';
281 status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
282 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
283 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
284 CloseHandle( handle );
285
286 /* try with leading backslash */
287 nameW.Buffer--;
288 nameW.Length += sizeof(WCHAR);
289 status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
290 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
291 ok( status == STATUS_INVALID_PARAMETER ||
292 status == STATUS_OBJECT_NAME_INVALID ||
293 status == STATUS_OBJECT_PATH_SYNTAX_BAD,
294 "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
295 if (!status) CloseHandle( handle );
296
297 /* try with empty name */
298 nameW.Length = 0;
299 status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
300 FILE_SHARE_READ|FILE_SHARE_WRITE, FILE_DIRECTORY_FILE );
301 ok( !status, "open %s failed %x\n", wine_dbgstr_w(nameW.Buffer), status );
302 CloseHandle( handle );
303
304 /* try open by file id */
305
306 while (!pNtQueryDirectoryFile( dir, NULL, NULL, NULL, &io, data, sizeof(data),
307 FileIdBothDirectoryInformation, FALSE, NULL, restart ))
308 {
309 FILE_ID_BOTH_DIRECTORY_INFORMATION *info = (FILE_ID_BOTH_DIRECTORY_INFORMATION *)data;
310
311 restart = FALSE;
312 for (;;)
313 {
314 if (!info->FileId.QuadPart) goto next;
315 nameW.Buffer = (WCHAR *)&info->FileId;
316 nameW.Length = sizeof(info->FileId);
317 info->FileName[info->FileNameLength/sizeof(WCHAR)] = 0;
318 attr.RootDirectory = dir;
319 status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
320 FILE_SHARE_READ|FILE_SHARE_WRITE,
321 FILE_OPEN_BY_FILE_ID |
322 ((info->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? FILE_DIRECTORY_FILE : 0) );
323 ok( status == STATUS_SUCCESS || status == STATUS_ACCESS_DENIED || status == STATUS_NOT_IMPLEMENTED,
324 "open %s failed %x\n", wine_dbgstr_w(info->FileName), status );
325 if (status == STATUS_NOT_IMPLEMENTED)
326 {
327 win_skip( "FILE_OPEN_BY_FILE_ID not supported\n" );
328 break;
329 }
330 if (!status)
331 {
332 FILE_ALL_INFORMATION all_info;
333
334 if (!pNtQueryInformationFile( handle, &io, &all_info, sizeof(all_info), FileAllInformation ))
335 {
336 /* check that it's the same file */
337 ok( info->EndOfFile.QuadPart == all_info.StandardInformation.EndOfFile.QuadPart,
338 "mismatched file size for %s\n", wine_dbgstr_w(info->FileName));
339 ok( info->LastWriteTime.QuadPart == all_info.BasicInformation.LastWriteTime.QuadPart,
340 "mismatched write time for %s\n", wine_dbgstr_w(info->FileName));
341 }
342 CloseHandle( handle );
343
344 /* try same thing from drive root */
345 attr.RootDirectory = root;
346 status = pNtOpenFile( &handle, GENERIC_READ, &attr, &io,
347 FILE_SHARE_READ|FILE_SHARE_WRITE,
348 FILE_OPEN_BY_FILE_ID |
349 ((info->FileAttributes & FILE_ATTRIBUTE_DIRECTORY) ? FILE_DIRECTORY_FILE : 0) );
350 ok( status == STATUS_SUCCESS || status == STATUS_NOT_IMPLEMENTED,
351 "open %s failed %x\n", wine_dbgstr_w(info->FileName), status );
352 if (!status) CloseHandle( handle );
353 }
354 next:
355 if (!info->NextEntryOffset) break;
356 info = (FILE_ID_BOTH_DIRECTORY_INFORMATION *)((char *)info + info->NextEntryOffset);
357 }
358 }
359
360 CloseHandle( dir );
361 CloseHandle( root );
362 }
363
364 static void delete_file_test(void)
365 {
366 NTSTATUS ret;
367 OBJECT_ATTRIBUTES attr;
368 UNICODE_STRING nameW;
369 WCHAR pathW[MAX_PATH];
370 WCHAR pathsubW[MAX_PATH];
371 static const WCHAR testdirW[] = {'n','t','d','e','l','e','t','e','f','i','l','e',0};
372 static const WCHAR subdirW[] = {'\\','s','u','b',0};
373
374 ret = GetTempPathW(MAX_PATH, pathW);
375 if (!ret)
376 {
377 ok(0, "couldn't get temp dir\n");
378 return;
379 }
380 if (ret + sizeof(testdirW)/sizeof(WCHAR)-1 + sizeof(subdirW)/sizeof(WCHAR)-1 >= MAX_PATH)
381 {
382 ok(0, "MAX_PATH exceeded in constructing paths\n");
383 return;
384 }
385
386 lstrcatW(pathW, testdirW);
387 lstrcpyW(pathsubW, pathW);
388 lstrcatW(pathsubW, subdirW);
389
390 ret = CreateDirectoryW(pathW, NULL);
391 ok(ret == TRUE, "couldn't create directory ntdeletefile\n");
392 if (!pRtlDosPathNameToNtPathName_U(pathW, &nameW, NULL, NULL))
393 {
394 ok(0,"RtlDosPathNametoNtPathName_U failed\n");
395 return;
396 }
397
398 attr.Length = sizeof(attr);
399 attr.RootDirectory = 0;
400 attr.Attributes = OBJ_CASE_INSENSITIVE;
401 attr.ObjectName = &nameW;
402 attr.SecurityDescriptor = NULL;
403 attr.SecurityQualityOfService = NULL;
404
405 /* test NtDeleteFile on an empty directory */
406 ret = pNtDeleteFile(&attr);
407 ok(ret == STATUS_SUCCESS, "NtDeleteFile should succeed in removing an empty directory\n");
408 ret = RemoveDirectoryW(pathW);
409 ok(ret == FALSE, "expected to fail removing directory, NtDeleteFile should have removed it\n");
410
411 /* test NtDeleteFile on a non-empty directory */
412 ret = CreateDirectoryW(pathW, NULL);
413 ok(ret == TRUE, "couldn't create directory ntdeletefile ?!\n");
414 ret = CreateDirectoryW(pathsubW, NULL);
415 ok(ret == TRUE, "couldn't create directory subdir\n");
416 ret = pNtDeleteFile(&attr);
417 ok(ret == STATUS_SUCCESS, "expected NtDeleteFile to ret STATUS_SUCCESS\n");
418 ret = RemoveDirectoryW(pathsubW);
419 ok(ret == TRUE, "expected to remove directory ntdeletefile\\sub\n");
420 ret = RemoveDirectoryW(pathW);
421 ok(ret == TRUE, "expected to remove directory ntdeletefile, NtDeleteFile failed.\n");
422
423 pRtlFreeUnicodeString( &nameW );
424 }
425
426 static void read_file_test(void)
427 {
428 const char text[] = "foobar";
429 HANDLE handle, read, write;
430 NTSTATUS status;
431 IO_STATUS_BLOCK iosb, iosb2;
432 DWORD written;
433 int apc_count = 0;
434 char buffer[128];
435 LARGE_INTEGER offset;
436 HANDLE event = CreateEventA( NULL, TRUE, FALSE, NULL );
437
438 buffer[0] = 1;
439
440 if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
441
442 /* try read with no data */
443 U(iosb).Status = 0xdeadbabe;
444 iosb.Information = 0xdeadbeef;
445 ok( is_signaled( read ), "read handle is not signaled\n" );
446 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
447 ok( status == STATUS_PENDING, "wrong status %x\n", status );
448 ok( !is_signaled( read ), "read handle is signaled\n" );
449 ok( !is_signaled( event ), "event is signaled\n" );
450 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
451 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
452 ok( !apc_count, "apc was called\n" );
453 WriteFile( write, buffer, 1, &written, NULL );
454 /* iosb updated here by async i/o */
455 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
456 ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
457 ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
458 ok( !is_signaled( read ), "read handle is signaled\n" );
459 ok( is_signaled( event ), "event is not signaled\n" );
460 ok( !apc_count, "apc was called\n" );
461 apc_count = 0;
462 SleepEx( 1, FALSE ); /* non-alertable sleep */
463 ok( !apc_count, "apc was called\n" );
464 SleepEx( 1, TRUE ); /* alertable sleep */
465 ok( apc_count == 1, "apc not called\n" );
466
467 /* with no event, the pipe handle itself gets signaled */
468 apc_count = 0;
469 U(iosb).Status = 0xdeadbabe;
470 iosb.Information = 0xdeadbeef;
471 ok( !is_signaled( read ), "read handle is not signaled\n" );
472 status = pNtReadFile( read, 0, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
473 ok( status == STATUS_PENDING, "wrong status %x\n", status );
474 ok( !is_signaled( read ), "read handle is signaled\n" );
475 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
476 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
477 ok( !apc_count, "apc was called\n" );
478 WriteFile( write, buffer, 1, &written, NULL );
479 /* iosb updated here by async i/o */
480 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
481 ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
482 ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
483 ok( is_signaled( read ), "read handle is signaled\n" );
484 ok( !apc_count, "apc was called\n" );
485 apc_count = 0;
486 SleepEx( 1, FALSE ); /* non-alertable sleep */
487 ok( !apc_count, "apc was called\n" );
488 SleepEx( 1, TRUE ); /* alertable sleep */
489 ok( apc_count == 1, "apc not called\n" );
490
491 /* now read with data ready */
492 apc_count = 0;
493 U(iosb).Status = 0xdeadbabe;
494 iosb.Information = 0xdeadbeef;
495 ResetEvent( event );
496 WriteFile( write, buffer, 1, &written, NULL );
497 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
498 ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
499 ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
500 ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
501 ok( is_signaled( event ), "event is not signaled\n" );
502 ok( !apc_count, "apc was called\n" );
503 SleepEx( 1, FALSE ); /* non-alertable sleep */
504 ok( !apc_count, "apc was called\n" );
505 SleepEx( 1, TRUE ); /* alertable sleep */
506 ok( apc_count == 1, "apc not called\n" );
507
508 /* try read with no data */
509 apc_count = 0;
510 U(iosb).Status = 0xdeadbabe;
511 iosb.Information = 0xdeadbeef;
512 ok( is_signaled( event ), "event is not signaled\n" ); /* check that read resets the event */
513 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
514 ok( status == STATUS_PENDING, "wrong status %x\n", status );
515 ok( !is_signaled( event ), "event is signaled\n" );
516 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
517 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
518 ok( !apc_count, "apc was called\n" );
519 WriteFile( write, buffer, 1, &written, NULL );
520 /* partial read is good enough */
521 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
522 ok( is_signaled( event ), "event is signaled\n" );
523 ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
524 ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
525 ok( !apc_count, "apc was called\n" );
526 SleepEx( 1, TRUE ); /* alertable sleep */
527 ok( apc_count == 1, "apc was not called\n" );
528
529 /* read from disconnected pipe */
530 apc_count = 0;
531 U(iosb).Status = 0xdeadbabe;
532 iosb.Information = 0xdeadbeef;
533 CloseHandle( write );
534 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
535 ok( status == STATUS_PIPE_BROKEN, "wrong status %x\n", status );
536 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
537 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
538 ok( !is_signaled( event ), "event is signaled\n" );
539 ok( !apc_count, "apc was called\n" );
540 SleepEx( 1, TRUE ); /* alertable sleep */
541 ok( !apc_count, "apc was called\n" );
542 CloseHandle( read );
543
544 /* read from closed handle */
545 apc_count = 0;
546 U(iosb).Status = 0xdeadbabe;
547 iosb.Information = 0xdeadbeef;
548 SetEvent( event );
549 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
550 ok( status == STATUS_INVALID_HANDLE, "wrong status %x\n", status );
551 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
552 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
553 ok( is_signaled( event ), "event is signaled\n" ); /* not reset on invalid handle */
554 ok( !apc_count, "apc was called\n" );
555 SleepEx( 1, TRUE ); /* alertable sleep */
556 ok( !apc_count, "apc was called\n" );
557
558 /* disconnect while async read is in progress */
559 if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
560 apc_count = 0;
561 U(iosb).Status = 0xdeadbabe;
562 iosb.Information = 0xdeadbeef;
563 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
564 ok( status == STATUS_PENDING, "wrong status %x\n", status );
565 ok( !is_signaled( event ), "event is signaled\n" );
566 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
567 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
568 ok( !apc_count, "apc was called\n" );
569 CloseHandle( write );
570 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
571 ok( U(iosb).Status == STATUS_PIPE_BROKEN, "wrong status %x\n", U(iosb).Status );
572 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
573 ok( is_signaled( event ), "event is signaled\n" );
574 ok( !apc_count, "apc was called\n" );
575 SleepEx( 1, TRUE ); /* alertable sleep */
576 ok( apc_count == 1, "apc was not called\n" );
577 CloseHandle( read );
578
579 if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
580 ok(DuplicateHandle(GetCurrentProcess(), read, GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS),
581 "Failed to duplicate handle: %d\n", GetLastError());
582
583 apc_count = 0;
584 U(iosb).Status = 0xdeadbabe;
585 iosb.Information = 0xdeadbeef;
586 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
587 ok( status == STATUS_PENDING, "wrong status %x\n", status );
588 ok( !is_signaled( event ), "event is signaled\n" );
589 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
590 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
591 ok( !apc_count, "apc was called\n" );
592 /* Cancel by other handle */
593 status = pNtCancelIoFile( read, &iosb2 );
594 ok(status == STATUS_SUCCESS, "failed to cancel by different handle: %x\n", status);
595 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
596 ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
597 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
598 ok( is_signaled( event ), "event is signaled\n" );
599 todo_wine ok( !apc_count, "apc was called\n" );
600 SleepEx( 1, TRUE ); /* alertable sleep */
601 ok( apc_count == 1, "apc was not called\n" );
602
603 apc_count = 0;
604 U(iosb).Status = 0xdeadbabe;
605 iosb.Information = 0xdeadbeef;
606 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
607 ok( status == STATUS_PENDING, "wrong status %x\n", status );
608 ok( !is_signaled( event ), "event is signaled\n" );
609 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
610 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
611 ok( !apc_count, "apc was called\n" );
612 /* Close queued handle */
613 CloseHandle( read );
614 SleepEx( 1, TRUE ); /* alertable sleep */
615 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
616 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
617 status = pNtCancelIoFile( read, &iosb2 );
618 ok(status == STATUS_INVALID_HANDLE, "cancelled by closed handle?\n");
619 status = pNtCancelIoFile( handle, &iosb2 );
620 ok(status == STATUS_SUCCESS, "failed to cancel: %x\n", status);
621 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
622 ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
623 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
624 ok( is_signaled( event ), "event is signaled\n" );
625 todo_wine ok( !apc_count, "apc was called\n" );
626 SleepEx( 1, TRUE ); /* alertable sleep */
627 ok( apc_count == 1, "apc was not called\n" );
628 CloseHandle( handle );
629 CloseHandle( write );
630
631 if (pNtCancelIoFileEx)
632 {
633 /* Basic Cancel Ex */
634 if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
635
636 apc_count = 0;
637 U(iosb).Status = 0xdeadbabe;
638 iosb.Information = 0xdeadbeef;
639 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
640 ok( status == STATUS_PENDING, "wrong status %x\n", status );
641 ok( !is_signaled( event ), "event is signaled\n" );
642 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
643 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
644 ok( !apc_count, "apc was called\n" );
645 status = pNtCancelIoFileEx( read, &iosb, &iosb2 );
646 ok(status == STATUS_SUCCESS, "Failed to cancel I/O\n");
647 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
648 ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
649 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
650 ok( is_signaled( event ), "event is signaled\n" );
651 todo_wine ok( !apc_count, "apc was called\n" );
652 SleepEx( 1, TRUE ); /* alertable sleep */
653 ok( apc_count == 1, "apc was not called\n" );
654
655 /* Duplicate iosb */
656 apc_count = 0;
657 U(iosb).Status = 0xdeadbabe;
658 iosb.Information = 0xdeadbeef;
659 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
660 ok( status == STATUS_PENDING, "wrong status %x\n", status );
661 ok( !is_signaled( event ), "event is signaled\n" );
662 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
663 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
664 ok( !apc_count, "apc was called\n" );
665 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
666 ok( status == STATUS_PENDING, "wrong status %x\n", status );
667 ok( !is_signaled( event ), "event is signaled\n" );
668 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
669 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
670 ok( !apc_count, "apc was called\n" );
671 status = pNtCancelIoFileEx( read, &iosb, &iosb2 );
672 ok(status == STATUS_SUCCESS, "Failed to cancel I/O\n");
673 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
674 ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
675 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
676 ok( is_signaled( event ), "event is signaled\n" );
677 todo_wine ok( !apc_count, "apc was called\n" );
678 SleepEx( 1, TRUE ); /* alertable sleep */
679 ok( apc_count == 2, "apc was not called\n" );
680
681 CloseHandle( read );
682 CloseHandle( write );
683 }
684
685 /* now try a real file */
686 if (!(handle = create_temp_file( FILE_FLAG_OVERLAPPED ))) return;
687 apc_count = 0;
688 U(iosb).Status = 0xdeadbabe;
689 iosb.Information = 0xdeadbeef;
690 offset.QuadPart = 0;
691 ResetEvent( event );
692 status = pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
693 ok( status == STATUS_SUCCESS || status == STATUS_PENDING, "wrong status %x\n", status );
694 ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
695 ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
696 ok( is_signaled( event ), "event is signaled\n" );
697 ok( !apc_count, "apc was called\n" );
698 SleepEx( 1, TRUE ); /* alertable sleep */
699 ok( apc_count == 1, "apc was not called\n" );
700
701 apc_count = 0;
702 U(iosb).Status = 0xdeadbabe;
703 iosb.Information = 0xdeadbeef;
704 offset.QuadPart = 0;
705 ResetEvent( event );
706 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
707 ok( status == STATUS_SUCCESS ||
708 status == STATUS_PENDING, /* vista */
709 "wrong status %x\n", status );
710 ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
711 ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
712 ok( is_signaled( event ), "event is signaled\n" );
713 ok( !apc_count, "apc was called\n" );
714 SleepEx( 1, TRUE ); /* alertable sleep */
715 ok( apc_count == 1, "apc was not called\n" );
716
717 /* read beyond eof */
718 apc_count = 0;
719 U(iosb).Status = 0xdeadbabe;
720 iosb.Information = 0xdeadbeef;
721 offset.QuadPart = strlen(text) + 2;
722 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
723 if (status == STATUS_PENDING) /* vista */
724 {
725 ok( U(iosb).Status == STATUS_END_OF_FILE, "wrong status %x\n", U(iosb).Status );
726 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
727 ok( is_signaled( event ), "event is signaled\n" );
728 ok( !apc_count, "apc was called\n" );
729 SleepEx( 1, TRUE ); /* alertable sleep */
730 ok( apc_count == 1, "apc was not called\n" );
731 }
732 else
733 {
734 ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
735 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
736 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
737 ok( !is_signaled( event ), "event is signaled\n" );
738 ok( !apc_count, "apc was called\n" );
739 SleepEx( 1, TRUE ); /* alertable sleep */
740 ok( !apc_count, "apc was called\n" );
741 }
742 CloseHandle( handle );
743
744 /* now a non-overlapped file */
745 if (!(handle = create_temp_file(0))) return;
746 apc_count = 0;
747 U(iosb).Status = 0xdeadbabe;
748 iosb.Information = 0xdeadbeef;
749 offset.QuadPart = 0;
750 status = pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
751 ok( status == STATUS_END_OF_FILE ||
752 status == STATUS_SUCCESS ||
753 status == STATUS_PENDING, /* vista */
754 "wrong status %x\n", status );
755 ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
756 ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
757 ok( is_signaled( event ), "event is signaled\n" );
758 ok( !apc_count, "apc was called\n" );
759 SleepEx( 1, TRUE ); /* alertable sleep */
760 ok( apc_count == 1, "apc was not called\n" );
761
762 apc_count = 0;
763 U(iosb).Status = 0xdeadbabe;
764 iosb.Information = 0xdeadbeef;
765 offset.QuadPart = 0;
766 ResetEvent( event );
767 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
768 ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
769 ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
770 ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
771 ok( is_signaled( event ), "event is signaled\n" );
772 ok( !apc_count, "apc was called\n" );
773 SleepEx( 1, TRUE ); /* alertable sleep */
774 todo_wine ok( !apc_count, "apc was called\n" );
775
776 /* read beyond eof */
777 apc_count = 0;
778 U(iosb).Status = 0xdeadbabe;
779 iosb.Information = 0xdeadbeef;
780 offset.QuadPart = strlen(text) + 2;
781 ResetEvent( event );
782 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
783 ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
784 todo_wine ok( U(iosb).Status == STATUS_END_OF_FILE, "wrong status %x\n", U(iosb).Status );
785 todo_wine ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
786 todo_wine ok( is_signaled( event ), "event is not signaled\n" );
787 ok( !apc_count, "apc was called\n" );
788 SleepEx( 1, TRUE ); /* alertable sleep */
789 ok( !apc_count, "apc was called\n" );
790
791 CloseHandle( handle );
792
793 CloseHandle( event );
794 }
795
796 static void nt_mailslot_test(void)
797 {
798 HANDLE hslot;
799 ACCESS_MASK DesiredAccess;
800 OBJECT_ATTRIBUTES attr;
801
802 ULONG CreateOptions;
803 ULONG MailslotQuota;
804 ULONG MaxMessageSize;
805 LARGE_INTEGER TimeOut;
806 IO_STATUS_BLOCK IoStatusBlock;
807 NTSTATUS rc;
808 UNICODE_STRING str;
809 WCHAR buffer1[] = { '\\','?','?','\\','M','A','I','L','S','L','O','T','\\',
810 'R',':','\\','F','R','E','D','\0' };
811
812 TimeOut.QuadPart = -1;
813
814 pRtlInitUnicodeString(&str, buffer1);
815 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
816 CreateOptions = MailslotQuota = MaxMessageSize = 0;
817 DesiredAccess = GENERIC_READ;
818
819 /*
820 * Check for NULL pointer handling
821 */
822 rc = pNtCreateMailslotFile(NULL, DesiredAccess,
823 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
824 &TimeOut);
825 ok( rc == STATUS_ACCESS_VIOLATION ||
826 rc == STATUS_INVALID_PARAMETER, /* win2k3 */
827 "rc = %x not STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER\n", rc);
828
829 /*
830 * Test to see if the Timeout can be NULL
831 */
832 hslot = (HANDLE)0xdeadbeef;
833 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
834 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
835 NULL);
836 ok( rc == STATUS_SUCCESS ||
837 rc == STATUS_INVALID_PARAMETER, /* win2k3 */
838 "rc = %x not STATUS_SUCCESS or STATUS_INVALID_PARAMETER\n", rc);
839 ok( hslot != 0, "Handle is invalid\n");
840
841 if ( rc == STATUS_SUCCESS ) rc = pNtClose(hslot);
842
843 /*
844 * Test that the length field is checked properly
845 */
846 attr.Length = 0;
847 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
848 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
849 &TimeOut);
850 todo_wine ok( rc == STATUS_INVALID_PARAMETER, "rc = %x not c000000d STATUS_INVALID_PARAMETER\n", rc);
851
852 if (rc == STATUS_SUCCESS) pNtClose(hslot);
853
854 attr.Length = sizeof(OBJECT_ATTRIBUTES)+1;
855 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
856 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
857 &TimeOut);
858 todo_wine ok( rc == STATUS_INVALID_PARAMETER, "rc = %x not c000000d STATUS_INVALID_PARAMETER\n", rc);
859
860 if (rc == STATUS_SUCCESS) pNtClose(hslot);
861
862 /*
863 * Test handling of a NULL unicode string in ObjectName
864 */
865 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
866 attr.ObjectName = NULL;
867 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
868 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
869 &TimeOut);
870 ok( rc == STATUS_OBJECT_PATH_SYNTAX_BAD ||
871 rc == STATUS_INVALID_PARAMETER,
872 "rc = %x not STATUS_OBJECT_PATH_SYNTAX_BAD or STATUS_INVALID_PARAMETER\n", rc);
873
874 if (rc == STATUS_SUCCESS) pNtClose(hslot);
875
876 /*
877 * Test a valid call
878 */
879 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
880 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
881 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
882 &TimeOut);
883 ok( rc == STATUS_SUCCESS, "Create MailslotFile failed rc = %x\n", rc);
884 ok( hslot != 0, "Handle is invalid\n");
885
886 rc = pNtClose(hslot);
887 ok( rc == STATUS_SUCCESS, "NtClose failed\n");
888 }
889
890 static void test_iocp_setcompletion(HANDLE h)
891 {
892 NTSTATUS res;
893 long count;
894
895 res = pNtSetIoCompletion( h, CKEY_FIRST, CVALUE_FIRST, STATUS_INVALID_DEVICE_REQUEST, 3 );
896 ok( res == STATUS_SUCCESS, "NtSetIoCompletion failed: %x\n", res );
897
898 count = get_pending_msgs(h);
899 ok( count == 1, "Unexpected msg count: %ld\n", count );
900
901 if (get_msg(h))
902 {
903 ok( completionKey == CKEY_FIRST, "Invalid completion key: %lx\n", completionKey );
904 ok( ioSb.Information == 3, "Invalid ioSb.Information: %ld\n", ioSb.Information );
905 ok( U(ioSb).Status == STATUS_INVALID_DEVICE_REQUEST, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
906 ok( completionValue == CVALUE_FIRST, "Invalid completion value: %lx\n", completionValue );
907 }
908
909 count = get_pending_msgs(h);
910 ok( !count, "Unexpected msg count: %ld\n", count );
911 }
912
913 static void test_iocp_fileio(HANDLE h)
914 {
915 static const char pipe_name[] = "\\\\.\\pipe\\iocompletiontestnamedpipe";
916
917 IO_STATUS_BLOCK iosb;
918 FILE_COMPLETION_INFORMATION fci = {h, CKEY_SECOND};
919 HANDLE hPipeSrv, hPipeClt;
920 NTSTATUS res;
921
922 hPipeSrv = CreateNamedPipeA( pipe_name, PIPE_ACCESS_INBOUND, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024, 1000, NULL );
923 ok( hPipeSrv != INVALID_HANDLE_VALUE, "Cannot create named pipe\n" );
924 if (hPipeSrv != INVALID_HANDLE_VALUE )
925 {
926 hPipeClt = CreateFileA( pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL );
927 ok( hPipeClt != INVALID_HANDLE_VALUE, "Cannot connect to pipe\n" );
928 if (hPipeClt != INVALID_HANDLE_VALUE)
929 {
930 res = pNtSetInformationFile( hPipeSrv, &iosb, &fci, sizeof(fci), FileCompletionInformation );
931 ok( res == STATUS_INVALID_PARAMETER, "Unexpected NtSetInformationFile on non-overlapped handle: %x\n", res );
932 CloseHandle(hPipeClt);
933 }
934 CloseHandle( hPipeSrv );
935 }
936
937 hPipeSrv = CreateNamedPipeA( pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024, 1000, NULL );
938 ok( hPipeSrv != INVALID_HANDLE_VALUE, "Cannot create named pipe\n" );
939 if (hPipeSrv == INVALID_HANDLE_VALUE )
940 return;
941
942 hPipeClt = CreateFileA( pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL );
943 ok( hPipeClt != INVALID_HANDLE_VALUE, "Cannot connect to pipe\n" );
944 if (hPipeClt != INVALID_HANDLE_VALUE)
945 {
946 OVERLAPPED o = {0,};
947 BYTE send_buf[TEST_BUF_LEN], recv_buf[TEST_BUF_LEN];
948 DWORD read;
949 long count;
950
951 NTSTATUS res = pNtSetInformationFile( hPipeSrv, &iosb, &fci, sizeof(fci), FileCompletionInformation );
952 ok( res == STATUS_SUCCESS, "NtSetInformationFile failed: %x\n", res );
953 ok( U(iosb).Status == STATUS_SUCCESS, "iosb.Status invalid: %x\n", U(iosb).Status );
954
955 memset( send_buf, 0, TEST_BUF_LEN );
956 memset( recv_buf, 0xde, TEST_BUF_LEN );
957 count = get_pending_msgs(h);
958 ok( !count, "Unexpected msg count: %ld\n", count );
959 ReadFile( hPipeSrv, recv_buf, TEST_BUF_LEN, &read, &o);
960 count = get_pending_msgs(h);
961 ok( !count, "Unexpected msg count: %ld\n", count );
962 WriteFile( hPipeClt, send_buf, TEST_BUF_LEN, &read, NULL );
963
964 if (get_msg(h))
965 {
966 ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
967 ok( ioSb.Information == 3, "Invalid ioSb.Information: %ld\n", ioSb.Information );
968 ok( U(ioSb).Status == STATUS_SUCCESS, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
969 ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
970 ok( !memcmp( send_buf, recv_buf, TEST_BUF_LEN ), "Receive buffer (%x %x %x) did not match send buffer (%x %x %x)\n", recv_buf[0], recv_buf[1], recv_buf[2], send_buf[0], send_buf[1], send_buf[2] );
971 }
972 count = get_pending_msgs(h);
973 ok( !count, "Unexpected msg count: %ld\n", count );
974
975 memset( send_buf, 0, TEST_BUF_LEN );
976 memset( recv_buf, 0xde, TEST_BUF_LEN );
977 WriteFile( hPipeClt, send_buf, 2, &read, NULL );
978 count = get_pending_msgs(h);
979 ok( !count, "Unexpected msg count: %ld\n", count );
980 ReadFile( hPipeSrv, recv_buf, 2, &read, &o);
981 count = get_pending_msgs(h);
982 ok( count == 1, "Unexpected msg count: %ld\n", count );
983 if (get_msg(h))
984 {
985 ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
986 ok( ioSb.Information == 2, "Invalid ioSb.Information: %ld\n", ioSb.Information );
987 ok( U(ioSb).Status == STATUS_SUCCESS, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
988 ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
989 ok( !memcmp( send_buf, recv_buf, 2 ), "Receive buffer (%x %x) did not match send buffer (%x %x)\n", recv_buf[0], recv_buf[1], send_buf[0], send_buf[1] );
990 }
991
992 ReadFile( hPipeSrv, recv_buf, TEST_BUF_LEN, &read, &o);
993 CloseHandle( hPipeSrv );
994 count = get_pending_msgs(h);
995 ok( count == 1, "Unexpected msg count: %ld\n", count );
996 if (get_msg(h))
997 {
998 ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
999 ok( ioSb.Information == 0, "Invalid ioSb.Information: %ld\n", ioSb.Information );
1000 /* wine sends wrong status here */
1001 todo_wine ok( U(ioSb).Status == STATUS_PIPE_BROKEN, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
1002 ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
1003 }
1004 }
1005
1006 CloseHandle( hPipeClt );
1007 }
1008
1009 static void test_file_basic_information(void)
1010 {
1011 IO_STATUS_BLOCK io;
1012 FILE_BASIC_INFORMATION fbi;
1013 HANDLE h;
1014 int res;
1015 int attrib_mask = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_NORMAL;
1016
1017 if (!(h = create_temp_file(0))) return;
1018
1019 /* Check default first */
1020 memset(&fbi, 0, sizeof(fbi));
1021 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
1022 ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
1023 ok ( (fbi.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) == FILE_ATTRIBUTE_ARCHIVE,
1024 "attribute %x not expected\n", fbi.FileAttributes );
1025
1026 /* Then SYSTEM */
1027 /* Clear fbi to avoid setting times */
1028 memset(&fbi, 0, sizeof(fbi));
1029 fbi.FileAttributes = FILE_ATTRIBUTE_SYSTEM;
1030 res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
1031 ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
1032
1033 memset(&fbi, 0, sizeof(fbi));
1034 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
1035 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
1036 todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_SYSTEM, "attribute %x not FILE_ATTRIBUTE_SYSTEM\n", fbi.FileAttributes );
1037
1038 /* Then HIDDEN */
1039 memset(&fbi, 0, sizeof(fbi));
1040 fbi.FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1041 res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
1042 ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
1043
1044 memset(&fbi, 0, sizeof(fbi));
1045 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
1046 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
1047 todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_HIDDEN, "attribute %x not FILE_ATTRIBUTE_HIDDEN\n", fbi.FileAttributes );
1048
1049 /* Check NORMAL last of all (to make sure we can clear attributes) */
1050 memset(&fbi, 0, sizeof(fbi));
1051 fbi.FileAttributes = FILE_ATTRIBUTE_NORMAL;
1052 res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
1053 ok ( res == STATUS_SUCCESS, "can't set normal attribute\n");
1054
1055 memset(&fbi, 0, sizeof(fbi));
1056 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
1057 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
1058 todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_NORMAL, "attribute %x not 0\n", fbi.FileAttributes );
1059
1060 CloseHandle( h );
1061 }
1062
1063 static void test_file_all_information(void)
1064 {
1065 IO_STATUS_BLOCK io;
1066 /* FileAllInformation, like FileNameInformation, has a variable-length pathname
1067 * buffer at the end. Vista objects with STATUS_BUFFER_OVERFLOW if you
1068 * don't leave enough room there.
1069 */
1070 struct {
1071 FILE_ALL_INFORMATION fai;
1072 WCHAR buf[256];
1073 } fai_buf;
1074 HANDLE h;
1075 int res;
1076 int attrib_mask = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_NORMAL;
1077
1078 if (!(h = create_temp_file(0))) return;
1079
1080 /* Check default first */
1081 res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
1082 ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
1083 ok ( (fai_buf.fai.BasicInformation.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) == FILE_ATTRIBUTE_ARCHIVE,
1084 "attribute %x not expected\n", fai_buf.fai.BasicInformation.FileAttributes );
1085
1086 /* Then SYSTEM */
1087 /* Clear fbi to avoid setting times */
1088 memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
1089 fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_SYSTEM;
1090 res = pNtSetInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
1091 ok ( res == STATUS_INVALID_INFO_CLASS || res == STATUS_NOT_IMPLEMENTED, "shouldn't be able to set FileAllInformation, res %x\n", res);
1092 res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
1093 ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
1094
1095 memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
1096 res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
1097 ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
1098 todo_wine ok ( (fai_buf.fai.BasicInformation.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_SYSTEM, "attribute %x not FILE_ATTRIBUTE_SYSTEM\n", fai_buf.fai.BasicInformation.FileAttributes );
1099
1100 /* Then HIDDEN */
1101 memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
1102 fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_HIDDEN;
1103 res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
1104 ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
1105
1106 memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
1107 res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
1108 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
1109 todo_wine ok ( (fai_buf.fai.BasicInformation.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_HIDDEN, "attribute %x not FILE_ATTRIBUTE_HIDDEN\n", fai_buf.fai.BasicInformation.FileAttributes );
1110
1111 /* Check NORMAL last of all (to make sure we can clear attributes) */
1112 memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
1113 fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_NORMAL;
1114 res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
1115 ok ( res == STATUS_SUCCESS, "can't set normal attribute\n");
1116
1117 memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
1118 res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
1119 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
1120 todo_wine ok ( (fai_buf.fai.BasicInformation.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_NORMAL, "attribute %x not FILE_ATTRIBUTE_NORMAL\n", fai_buf.fai.BasicInformation.FileAttributes );
1121
1122 CloseHandle( h );
1123 }
1124
1125 static void test_file_both_information(void)
1126 {
1127 IO_STATUS_BLOCK io;
1128 FILE_BOTH_DIR_INFORMATION fbi;
1129 HANDLE h;
1130 int res;
1131
1132 if (!(h = create_temp_file(0))) return;
1133
1134 memset(&fbi, 0, sizeof(fbi));
1135 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBothDirectoryInformation);
1136 ok ( res == STATUS_INVALID_INFO_CLASS || res == STATUS_NOT_IMPLEMENTED, "shouldn't be able to query FileBothDirectoryInformation, res %x\n", res);
1137
1138 CloseHandle( h );
1139 }
1140
1141 static void test_iocompletion(void)
1142 {
1143 HANDLE h = INVALID_HANDLE_VALUE;
1144 NTSTATUS res;
1145
1146 res = pNtCreateIoCompletion( &h, IO_COMPLETION_ALL_ACCESS, NULL, 0);
1147
1148 ok( res == 0, "NtCreateIoCompletion anonymous failed: %x\n", res );
1149 ok( h && h != INVALID_HANDLE_VALUE, "Invalid handle returned\n" );
1150
1151 if ( h && h != INVALID_HANDLE_VALUE)
1152 {
1153 test_iocp_setcompletion(h);
1154 test_iocp_fileio(h);
1155 pNtClose(h);
1156 }
1157 }
1158
1159 static void test_file_name_information(void)
1160 {
1161 WCHAR *file_name, *volume_prefix, *expected;
1162 FILE_NAME_INFORMATION *info;
1163 ULONG old_redir = 1, tmp;
1164 UINT file_name_size;
1165 IO_STATUS_BLOCK io;
1166 UINT info_size;
1167 HRESULT hr;
1168 HANDLE h;
1169 UINT len;
1170
1171 /* GetVolumePathName is not present before w2k */
1172 if (!pGetVolumePathNameW) {
1173 win_skip("GetVolumePathNameW not found\n");
1174 return;
1175 }
1176
1177 file_name_size = GetSystemDirectoryW( NULL, 0 );
1178 file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
1179 volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1180 expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1181
1182 len = GetSystemDirectoryW( file_name, file_name_size );
1183 ok(len == file_name_size - 1,
1184 "GetSystemDirectoryW returned %u, expected %u.\n",
1185 len, file_name_size - 1);
1186
1187 len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
1188 ok(len, "GetVolumePathNameW failed.\n");
1189
1190 len = lstrlenW( volume_prefix );
1191 if (len && volume_prefix[len - 1] == '\\') --len;
1192 memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
1193 expected[file_name_size - len - 1] = '\0';
1194
1195 /* A bit more than we actually need, but it keeps the calculation simple. */
1196 info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
1197 info = HeapAlloc( GetProcessHeap(), 0, info_size );
1198
1199 if (pRtlWow64EnableFsRedirectionEx) pRtlWow64EnableFsRedirectionEx( TRUE, &old_redir );
1200 h = CreateFileW( file_name, GENERIC_READ,
1201 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1202 NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
1203 if (pRtlWow64EnableFsRedirectionEx) pRtlWow64EnableFsRedirectionEx( old_redir, &tmp );
1204 ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
1205
1206 hr = pNtQueryInformationFile( h, &io, info, sizeof(*info) - 1, FileNameInformation );
1207 ok(hr == STATUS_INFO_LENGTH_MISMATCH, "NtQueryInformationFile returned %#x.\n", hr);
1208
1209 memset( info, 0xcc, info_size );
1210 hr = pNtQueryInformationFile( h, &io, info, sizeof(*info), FileNameInformation );
1211 ok(hr == STATUS_BUFFER_OVERFLOW, "NtQueryInformationFile returned %#x, expected %#x.\n",
1212 hr, STATUS_BUFFER_OVERFLOW);
1213 ok(U(io).Status == STATUS_BUFFER_OVERFLOW, "io.Status is %#x, expected %#x.\n",
1214 U(io).Status, STATUS_BUFFER_OVERFLOW);
1215 ok(info->FileNameLength == lstrlenW( expected ) * sizeof(WCHAR), "info->FileNameLength is %u\n", info->FileNameLength);
1216 ok(info->FileName[2] == 0xcccc, "info->FileName[2] is %#x, expected 0xcccc.\n", info->FileName[2]);
1217 ok(CharLowerW((LPWSTR)(UINT_PTR)info->FileName[1]) == CharLowerW((LPWSTR)(UINT_PTR)expected[1]),
1218 "info->FileName[1] is %p, expected %p.\n",
1219 CharLowerW((LPWSTR)(UINT_PTR)info->FileName[1]), CharLowerW((LPWSTR)(UINT_PTR)expected[1]));
1220 ok(io.Information == sizeof(*info), "io.Information is %lu\n", io.Information);
1221
1222 memset( info, 0xcc, info_size );
1223 hr = pNtQueryInformationFile( h, &io, info, info_size, FileNameInformation );
1224 ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1225 ok(U(io).Status == STATUS_SUCCESS, "io.Status is %#x, expected %#x.\n", U(io).Status, STATUS_SUCCESS);
1226 ok(info->FileNameLength == lstrlenW( expected ) * sizeof(WCHAR), "info->FileNameLength is %u\n", info->FileNameLength);
1227 ok(info->FileName[info->FileNameLength / sizeof(WCHAR)] == 0xcccc, "info->FileName[len] is %#x, expected 0xcccc.\n",
1228 info->FileName[info->FileNameLength / sizeof(WCHAR)]);
1229 info->FileName[info->FileNameLength / sizeof(WCHAR)] = '\0';
1230 ok(!lstrcmpiW( info->FileName, expected ), "info->FileName is %s, expected %s.\n",
1231 wine_dbgstr_w( info->FileName ), wine_dbgstr_w( expected ));
1232 ok(io.Information == FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) + info->FileNameLength,
1233 "io.Information is %lu, expected %u.\n",
1234 io.Information, FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) + info->FileNameLength);
1235
1236 CloseHandle( h );
1237 HeapFree( GetProcessHeap(), 0, info );
1238 HeapFree( GetProcessHeap(), 0, expected );
1239 HeapFree( GetProcessHeap(), 0, volume_prefix );
1240
1241 if (old_redir || !pGetSystemWow64DirectoryW || !(file_name_size = pGetSystemWow64DirectoryW( NULL, 0 )))
1242 {
1243 skip("Not running on WoW64, skipping test.\n");
1244 HeapFree( GetProcessHeap(), 0, file_name );
1245 return;
1246 }
1247
1248 h = CreateFileW( file_name, GENERIC_READ,
1249 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1250 NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
1251 ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
1252 HeapFree( GetProcessHeap(), 0, file_name );
1253
1254 file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
1255 volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1256 expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*expected) );
1257
1258 len = pGetSystemWow64DirectoryW( file_name, file_name_size );
1259 ok(len == file_name_size - 1,
1260 "GetSystemWow64DirectoryW returned %u, expected %u.\n",
1261 len, file_name_size - 1);
1262
1263 len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
1264 ok(len, "GetVolumePathNameW failed.\n");
1265
1266 len = lstrlenW( volume_prefix );
1267 if (len && volume_prefix[len - 1] == '\\') --len;
1268 memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
1269 expected[file_name_size - len - 1] = '\0';
1270
1271 info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
1272 info = HeapAlloc( GetProcessHeap(), 0, info_size );
1273
1274 memset( info, 0xcc, info_size );
1275 hr = pNtQueryInformationFile( h, &io, info, info_size, FileNameInformation );
1276 ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1277 info->FileName[info->FileNameLength / sizeof(WCHAR)] = '\0';
1278 ok(!lstrcmpiW( info->FileName, expected ), "info->FileName is %s, expected %s.\n",
1279 wine_dbgstr_w( info->FileName ), wine_dbgstr_w( expected ));
1280
1281 CloseHandle( h );
1282 HeapFree( GetProcessHeap(), 0, info );
1283 HeapFree( GetProcessHeap(), 0, expected );
1284 HeapFree( GetProcessHeap(), 0, volume_prefix );
1285 HeapFree( GetProcessHeap(), 0, file_name );
1286 }
1287
1288 static void test_file_all_name_information(void)
1289 {
1290 WCHAR *file_name, *volume_prefix, *expected;
1291 FILE_ALL_INFORMATION *info;
1292 ULONG old_redir = 1, tmp;
1293 UINT file_name_size;
1294 IO_STATUS_BLOCK io;
1295 UINT info_size;
1296 HRESULT hr;
1297 HANDLE h;
1298 UINT len;
1299
1300 /* GetVolumePathName is not present before w2k */
1301 if (!pGetVolumePathNameW) {
1302 win_skip("GetVolumePathNameW not found\n");
1303 return;
1304 }
1305
1306 file_name_size = GetSystemDirectoryW( NULL, 0 );
1307 file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
1308 volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1309 expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1310
1311 len = GetSystemDirectoryW( file_name, file_name_size );
1312 ok(len == file_name_size - 1,
1313 "GetSystemDirectoryW returned %u, expected %u.\n",
1314 len, file_name_size - 1);
1315
1316 len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
1317 ok(len, "GetVolumePathNameW failed.\n");
1318
1319 len = lstrlenW( volume_prefix );
1320 if (len && volume_prefix[len - 1] == '\\') --len;
1321 memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
1322 expected[file_name_size - len - 1] = '\0';
1323
1324 /* A bit more than we actually need, but it keeps the calculation simple. */
1325 info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
1326 info = HeapAlloc( GetProcessHeap(), 0, info_size );
1327
1328 if (pRtlWow64EnableFsRedirectionEx) pRtlWow64EnableFsRedirectionEx( TRUE, &old_redir );
1329 h = CreateFileW( file_name, GENERIC_READ,
1330 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1331 NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
1332 if (pRtlWow64EnableFsRedirectionEx) pRtlWow64EnableFsRedirectionEx( old_redir, &tmp );
1333 ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
1334
1335 hr = pNtQueryInformationFile( h, &io, info, sizeof(*info) - 1, FileAllInformation );
1336 ok(hr == STATUS_INFO_LENGTH_MISMATCH, "NtQueryInformationFile returned %#x, expected %#x.\n",
1337 hr, STATUS_INFO_LENGTH_MISMATCH);
1338
1339 memset( info, 0xcc, info_size );
1340 hr = pNtQueryInformationFile( h, &io, info, sizeof(*info), FileAllInformation );
1341 ok(hr == STATUS_BUFFER_OVERFLOW, "NtQueryInformationFile returned %#x, expected %#x.\n",
1342 hr, STATUS_BUFFER_OVERFLOW);
1343 ok(U(io).Status == STATUS_BUFFER_OVERFLOW, "io.Status is %#x, expected %#x.\n",
1344 U(io).Status, STATUS_BUFFER_OVERFLOW);
1345 ok(info->NameInformation.FileNameLength == lstrlenW( expected ) * sizeof(WCHAR),
1346 "info->NameInformation.FileNameLength is %u\n", info->NameInformation.FileNameLength );
1347 ok(info->NameInformation.FileName[2] == 0xcccc,
1348 "info->NameInformation.FileName[2] is %#x, expected 0xcccc.\n", info->NameInformation.FileName[2]);
1349 ok(CharLowerW((LPWSTR)(UINT_PTR)info->NameInformation.FileName[1]) == CharLowerW((LPWSTR)(UINT_PTR)expected[1]),
1350 "info->NameInformation.FileName[1] is %p, expected %p.\n",
1351 CharLowerW((LPWSTR)(UINT_PTR)info->NameInformation.FileName[1]), CharLowerW((LPWSTR)(UINT_PTR)expected[1]));
1352 ok(io.Information == sizeof(*info), "io.Information is %lu\n", io.Information);
1353
1354 memset( info, 0xcc, info_size );
1355 hr = pNtQueryInformationFile( h, &io, info, info_size, FileAllInformation );
1356 ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1357 ok(U(io).Status == STATUS_SUCCESS, "io.Status is %#x, expected %#x.\n", U(io).Status, STATUS_SUCCESS);
1358 ok(info->NameInformation.FileNameLength == lstrlenW( expected ) * sizeof(WCHAR),
1359 "info->NameInformation.FileNameLength is %u\n", info->NameInformation.FileNameLength );
1360 ok(info->NameInformation.FileName[info->NameInformation.FileNameLength / sizeof(WCHAR)] == 0xcccc,
1361 "info->NameInformation.FileName[len] is %#x, expected 0xcccc.\n",
1362 info->NameInformation.FileName[info->NameInformation.FileNameLength / sizeof(WCHAR)]);
1363 info->NameInformation.FileName[info->NameInformation.FileNameLength / sizeof(WCHAR)] = '\0';
1364 ok(!lstrcmpiW( info->NameInformation.FileName, expected ),
1365 "info->NameInformation.FileName is %s, expected %s.\n",
1366 wine_dbgstr_w( info->NameInformation.FileName ), wine_dbgstr_w( expected ));
1367 ok(io.Information == FIELD_OFFSET(FILE_ALL_INFORMATION, NameInformation.FileName)
1368 + info->NameInformation.FileNameLength,
1369 "io.Information is %lu\n", io.Information );
1370
1371 CloseHandle( h );
1372 HeapFree( GetProcessHeap(), 0, info );
1373 HeapFree( GetProcessHeap(), 0, expected );
1374 HeapFree( GetProcessHeap(), 0, volume_prefix );
1375
1376 if (old_redir || !pGetSystemWow64DirectoryW || !(file_name_size = pGetSystemWow64DirectoryW( NULL, 0 )))
1377 {
1378 skip("Not running on WoW64, skipping test.\n");
1379 HeapFree( GetProcessHeap(), 0, file_name );
1380 return;
1381 }
1382
1383 h = CreateFileW( file_name, GENERIC_READ,
1384 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
1385 NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
1386 ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
1387 HeapFree( GetProcessHeap(), 0, file_name );
1388
1389 file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
1390 volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
1391 expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*expected) );
1392
1393 len = pGetSystemWow64DirectoryW( file_name, file_name_size );
1394 ok(len == file_name_size - 1,
1395 "GetSystemWow64DirectoryW returned %u, expected %u.\n",
1396 len, file_name_size - 1);
1397
1398 len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
1399 ok(len, "GetVolumePathNameW failed.\n");
1400
1401 len = lstrlenW( volume_prefix );
1402 if (len && volume_prefix[len - 1] == '\\') --len;
1403 memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
1404 expected[file_name_size - len - 1] = '\0';
1405
1406 info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
1407 info = HeapAlloc( GetProcessHeap(), 0, info_size );
1408
1409 memset( info, 0xcc, info_size );
1410 hr = pNtQueryInformationFile( h, &io, info, info_size, FileAllInformation );
1411 ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1412 info->NameInformation.FileName[info->NameInformation.FileNameLength / sizeof(WCHAR)] = '\0';
1413 ok(!lstrcmpiW( info->NameInformation.FileName, expected ), "info->NameInformation.FileName is %s, expected %s.\n",
1414 wine_dbgstr_w( info->NameInformation.FileName ), wine_dbgstr_w( expected ));
1415
1416 CloseHandle( h );
1417 HeapFree( GetProcessHeap(), 0, info );
1418 HeapFree( GetProcessHeap(), 0, expected );
1419 HeapFree( GetProcessHeap(), 0, volume_prefix );
1420 HeapFree( GetProcessHeap(), 0, file_name );
1421 }
1422
1423 START_TEST(file)
1424 {
1425 HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
1426 HMODULE hntdll = GetModuleHandleA("ntdll.dll");
1427 if (!hntdll)
1428 {
1429 skip("not running on NT, skipping test\n");
1430 return;
1431 }
1432
1433 pGetVolumePathNameW = (void *)GetProcAddress(hkernel32, "GetVolumePathNameW");
1434 pGetSystemWow64DirectoryW = (void *)GetProcAddress(hkernel32, "GetSystemWow64DirectoryW");
1435
1436 pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
1437 pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
1438 pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
1439 pRtlWow64EnableFsRedirectionEx = (void *)GetProcAddress(hntdll, "RtlWow64EnableFsRedirectionEx");
1440 pNtCreateMailslotFile = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
1441 pNtCreateFile = (void *)GetProcAddress(hntdll, "NtCreateFile");
1442 pNtOpenFile = (void *)GetProcAddress(hntdll, "NtOpenFile");
1443 pNtDeleteFile = (void *)GetProcAddress(hntdll, "NtDeleteFile");
1444 pNtReadFile = (void *)GetProcAddress(hntdll, "NtReadFile");
1445 pNtWriteFile = (void *)GetProcAddress(hntdll, "NtWriteFile");
1446 pNtCancelIoFile = (void *)GetProcAddress(hntdll, "NtCancelIoFile");
1447 pNtCancelIoFileEx = (void *)GetProcAddress(hntdll, "NtCancelIoFileEx");
1448 pNtClose = (void *)GetProcAddress(hntdll, "NtClose");
1449 pNtCreateIoCompletion = (void *)GetProcAddress(hntdll, "NtCreateIoCompletion");
1450 pNtOpenIoCompletion = (void *)GetProcAddress(hntdll, "NtOpenIoCompletion");
1451 pNtQueryIoCompletion = (void *)GetProcAddress(hntdll, "NtQueryIoCompletion");
1452 pNtRemoveIoCompletion = (void *)GetProcAddress(hntdll, "NtRemoveIoCompletion");
1453 pNtSetIoCompletion = (void *)GetProcAddress(hntdll, "NtSetIoCompletion");
1454 pNtSetInformationFile = (void *)GetProcAddress(hntdll, "NtSetInformationFile");
1455 pNtQueryInformationFile = (void *)GetProcAddress(hntdll, "NtQueryInformationFile");
1456 pNtQueryDirectoryFile = (void *)GetProcAddress(hntdll, "NtQueryDirectoryFile");
1457
1458 create_file_test();
1459 open_file_test();
1460 delete_file_test();
1461 read_file_test();
1462 nt_mailslot_test();
1463 test_iocompletion();
1464 test_file_basic_information();
1465 test_file_all_information();
1466 test_file_both_information();
1467 test_file_name_information();
1468 test_file_all_name_information();
1469 }
Windows API implementation