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
45 static NTSTATUS (WINAPI *pRtlFreeUnicodeString)( PUNICODE_STRING );
46 static VOID (WINAPI *pRtlInitUnicodeString)( PUNICODE_STRING, LPCWSTR );
47 static BOOL (WINAPI *pRtlDosPathNameToNtPathName_U)( LPCWSTR, PUNICODE_STRING, PWSTR*, CURDIR* );
48 static NTSTATUS (WINAPI *pNtCreateMailslotFile)( PHANDLE, ULONG, POBJECT_ATTRIBUTES, PIO_STATUS_BLOCK,
49 ULONG, ULONG, ULONG, PLARGE_INTEGER );
50 static NTSTATUS (WINAPI *pNtDeleteFile)(POBJECT_ATTRIBUTES ObjectAttributes);
51 static NTSTATUS (WINAPI *pNtReadFile)(HANDLE hFile, HANDLE hEvent,
52 PIO_APC_ROUTINE apc, void* apc_user,
53 PIO_STATUS_BLOCK io_status, void* buffer, ULONG length,
54 PLARGE_INTEGER offset, PULONG key);
55 static NTSTATUS (WINAPI *pNtWriteFile)(HANDLE hFile, HANDLE hEvent,
56 PIO_APC_ROUTINE apc, void* apc_user,
57 PIO_STATUS_BLOCK io_status,
58 const void* buffer, ULONG length,
59 PLARGE_INTEGER offset, PULONG key);
60 static NTSTATUS (WINAPI *pNtCancelIoFile)(HANDLE hFile, PIO_STATUS_BLOCK io_status);
61 static NTSTATUS (WINAPI *pNtCancelIoFileEx)(HANDLE hFile, PIO_STATUS_BLOCK iosb, PIO_STATUS_BLOCK io_status);
62 static NTSTATUS (WINAPI *pNtClose)( PHANDLE );
63
64 static NTSTATUS (WINAPI *pNtCreateIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES, ULONG);
65 static NTSTATUS (WINAPI *pNtOpenIoCompletion)(PHANDLE, ACCESS_MASK, POBJECT_ATTRIBUTES);
66 static NTSTATUS (WINAPI *pNtQueryIoCompletion)(HANDLE, IO_COMPLETION_INFORMATION_CLASS, PVOID, ULONG, PULONG);
67 static NTSTATUS (WINAPI *pNtRemoveIoCompletion)(HANDLE, PULONG_PTR, PULONG_PTR, PIO_STATUS_BLOCK, PLARGE_INTEGER);
68 static NTSTATUS (WINAPI *pNtSetIoCompletion)(HANDLE, ULONG_PTR, ULONG_PTR, NTSTATUS, ULONG);
69 static NTSTATUS (WINAPI *pNtSetInformationFile)(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS);
70 static NTSTATUS (WINAPI *pNtQueryInformationFile)(HANDLE, PIO_STATUS_BLOCK, PVOID, ULONG, FILE_INFORMATION_CLASS);
71
72 static inline BOOL is_signaled( HANDLE obj )
73 {
74 return WaitForSingleObject( obj, 0 ) == 0;
75 }
76
77 #define PIPENAME "\\\\.\\pipe\\ntdll_tests_file.c"
78 #define TEST_BUF_LEN 3
79
80 static BOOL create_pipe( HANDLE *read, HANDLE *write, ULONG flags, ULONG size )
81 {
82 *read = CreateNamedPipe(PIPENAME, PIPE_ACCESS_INBOUND | flags, PIPE_TYPE_BYTE | PIPE_WAIT,
83 1, size, size, NMPWAIT_USE_DEFAULT_WAIT, NULL);
84 ok(*read != INVALID_HANDLE_VALUE, "CreateNamedPipe failed\n");
85
86 *write = CreateFileA(PIPENAME, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0);
87 ok(*write != INVALID_HANDLE_VALUE, "CreateFile failed (%d)\n", GetLastError());
88
89 return TRUE;
90 }
91
92 static HANDLE create_temp_file( ULONG flags )
93 {
94 char buffer[MAX_PATH];
95 HANDLE handle;
96
97 GetTempFileNameA( ".", "foo", 0, buffer );
98 handle = CreateFileA(buffer, GENERIC_READ | GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
99 flags | FILE_FLAG_DELETE_ON_CLOSE, 0);
100 ok( handle != INVALID_HANDLE_VALUE, "failed to create temp file\n" );
101 return (handle == INVALID_HANDLE_VALUE) ? 0 : handle;
102 }
103
104 #define CVALUE_FIRST 0xfffabbcc
105 #define CKEY_FIRST 0x1030341
106 #define CKEY_SECOND 0x132E46
107
108 ULONG_PTR completionKey;
109 IO_STATUS_BLOCK ioSb;
110 ULONG_PTR completionValue;
111
112 static long get_pending_msgs(HANDLE h)
113 {
114 NTSTATUS res;
115 ULONG a, req;
116
117 res = pNtQueryIoCompletion( h, IoCompletionBasicInformation, &a, sizeof(a), &req );
118 ok( res == STATUS_SUCCESS, "NtQueryIoCompletion failed: %x\n", res );
119 if (res != STATUS_SUCCESS) return -1;
120 ok( req == sizeof(a), "Unexpected response size: %x\n", req );
121 return a;
122 }
123
124 static BOOL get_msg(HANDLE h)
125 {
126 LARGE_INTEGER timeout = {{-10000000*3}};
127 DWORD res = pNtRemoveIoCompletion( h, &completionKey, &completionValue, &ioSb, &timeout);
128 ok( res == STATUS_SUCCESS, "NtRemoveIoCompletion failed: %x\n", res );
129 if (res != STATUS_SUCCESS)
130 {
131 completionKey = completionValue = 0;
132 memset(&ioSb, 0, sizeof(ioSb));
133 return FALSE;
134 }
135 return TRUE;
136 }
137
138
139 static void WINAPI apc( void *arg, IO_STATUS_BLOCK *iosb, ULONG reserved )
140 {
141 int *count = arg;
142
143 trace( "apc called block %p iosb.status %x iosb.info %lu\n",
144 iosb, U(*iosb).Status, iosb->Information );
145 (*count)++;
146 ok( !reserved, "reserved is not 0: %x\n", reserved );
147 }
148
149 static void delete_file_test(void)
150 {
151 NTSTATUS ret;
152 OBJECT_ATTRIBUTES attr;
153 UNICODE_STRING nameW;
154 WCHAR pathW[MAX_PATH];
155 WCHAR pathsubW[MAX_PATH];
156 static const WCHAR testdirW[] = {'n','t','d','e','l','e','t','e','f','i','l','e',0};
157 static const WCHAR subdirW[] = {'\\','s','u','b',0};
158
159 ret = GetTempPathW(MAX_PATH, pathW);
160 if (!ret)
161 {
162 ok(0, "couldn't get temp dir\n");
163 return;
164 }
165 if (ret + sizeof(testdirW)/sizeof(WCHAR)-1 + sizeof(subdirW)/sizeof(WCHAR)-1 >= MAX_PATH)
166 {
167 ok(0, "MAX_PATH exceeded in constructing paths\n");
168 return;
169 }
170
171 lstrcatW(pathW, testdirW);
172 lstrcpyW(pathsubW, pathW);
173 lstrcatW(pathsubW, subdirW);
174
175 ret = CreateDirectoryW(pathW, NULL);
176 ok(ret == TRUE, "couldn't create directory ntdeletefile\n");
177 if (!pRtlDosPathNameToNtPathName_U(pathW, &nameW, NULL, NULL))
178 {
179 ok(0,"RtlDosPathNametoNtPathName_U failed\n");
180 return;
181 }
182
183 attr.Length = sizeof(attr);
184 attr.RootDirectory = 0;
185 attr.Attributes = OBJ_CASE_INSENSITIVE;
186 attr.ObjectName = &nameW;
187 attr.SecurityDescriptor = NULL;
188 attr.SecurityQualityOfService = NULL;
189
190 /* test NtDeleteFile on an empty directory */
191 ret = pNtDeleteFile(&attr);
192 ok(ret == STATUS_SUCCESS, "NtDeleteFile should succeed in removing an empty directory\n");
193 ret = RemoveDirectoryW(pathW);
194 ok(ret == FALSE, "expected to fail removing directory, NtDeleteFile should have removed it\n");
195
196 /* test NtDeleteFile on a non-empty directory */
197 ret = CreateDirectoryW(pathW, NULL);
198 ok(ret == TRUE, "couldn't create directory ntdeletefile ?!\n");
199 ret = CreateDirectoryW(pathsubW, NULL);
200 ok(ret == TRUE, "couldn't create directory subdir\n");
201 ret = pNtDeleteFile(&attr);
202 ok(ret == STATUS_SUCCESS, "expected NtDeleteFile to ret STATUS_SUCCESS\n");
203 ret = RemoveDirectoryW(pathsubW);
204 ok(ret == TRUE, "expected to remove directory ntdeletefile\\sub\n");
205 ret = RemoveDirectoryW(pathW);
206 ok(ret == TRUE, "expected to remove directory ntdeletefile, NtDeleteFile failed.\n");
207
208 pRtlFreeUnicodeString( &nameW );
209 }
210
211 static void read_file_test(void)
212 {
213 const char text[] = "foobar";
214 HANDLE handle, read, write;
215 NTSTATUS status;
216 IO_STATUS_BLOCK iosb, iosb2;
217 DWORD written;
218 int apc_count = 0;
219 char buffer[128];
220 LARGE_INTEGER offset;
221 HANDLE event = CreateEventA( NULL, TRUE, FALSE, NULL );
222
223 buffer[0] = 1;
224
225 if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
226
227 /* try read with no data */
228 U(iosb).Status = 0xdeadbabe;
229 iosb.Information = 0xdeadbeef;
230 ok( is_signaled( read ), "read handle is not signaled\n" );
231 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
232 ok( status == STATUS_PENDING, "wrong status %x\n", status );
233 ok( !is_signaled( read ), "read handle is signaled\n" );
234 ok( !is_signaled( event ), "event is signaled\n" );
235 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
236 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
237 ok( !apc_count, "apc was called\n" );
238 WriteFile( write, buffer, 1, &written, NULL );
239 /* iosb updated here by async i/o */
240 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
241 ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
242 ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
243 ok( !is_signaled( read ), "read handle is signaled\n" );
244 ok( is_signaled( event ), "event is not signaled\n" );
245 ok( !apc_count, "apc was called\n" );
246 apc_count = 0;
247 SleepEx( 1, FALSE ); /* non-alertable sleep */
248 ok( !apc_count, "apc was called\n" );
249 SleepEx( 1, TRUE ); /* alertable sleep */
250 ok( apc_count == 1, "apc not called\n" );
251
252 /* with no event, the pipe handle itself gets signaled */
253 apc_count = 0;
254 U(iosb).Status = 0xdeadbabe;
255 iosb.Information = 0xdeadbeef;
256 ok( !is_signaled( read ), "read handle is not signaled\n" );
257 status = pNtReadFile( read, 0, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
258 ok( status == STATUS_PENDING, "wrong status %x\n", status );
259 ok( !is_signaled( read ), "read handle is signaled\n" );
260 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
261 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
262 ok( !apc_count, "apc was called\n" );
263 WriteFile( write, buffer, 1, &written, NULL );
264 /* iosb updated here by async i/o */
265 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
266 ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
267 ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
268 ok( is_signaled( read ), "read handle is signaled\n" );
269 ok( !apc_count, "apc was called\n" );
270 apc_count = 0;
271 SleepEx( 1, FALSE ); /* non-alertable sleep */
272 ok( !apc_count, "apc was called\n" );
273 SleepEx( 1, TRUE ); /* alertable sleep */
274 ok( apc_count == 1, "apc not called\n" );
275
276 /* now read with data ready */
277 apc_count = 0;
278 U(iosb).Status = 0xdeadbabe;
279 iosb.Information = 0xdeadbeef;
280 ResetEvent( event );
281 WriteFile( write, buffer, 1, &written, NULL );
282 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
283 ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
284 ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
285 ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
286 ok( is_signaled( event ), "event is not signaled\n" );
287 ok( !apc_count, "apc was called\n" );
288 SleepEx( 1, FALSE ); /* non-alertable sleep */
289 ok( !apc_count, "apc was called\n" );
290 SleepEx( 1, TRUE ); /* alertable sleep */
291 ok( apc_count == 1, "apc not called\n" );
292
293 /* try read with no data */
294 apc_count = 0;
295 U(iosb).Status = 0xdeadbabe;
296 iosb.Information = 0xdeadbeef;
297 ok( is_signaled( event ), "event is not signaled\n" ); /* check that read resets the event */
298 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
299 ok( status == STATUS_PENDING, "wrong status %x\n", status );
300 ok( !is_signaled( event ), "event is signaled\n" );
301 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
302 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
303 ok( !apc_count, "apc was called\n" );
304 WriteFile( write, buffer, 1, &written, NULL );
305 /* partial read is good enough */
306 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
307 ok( is_signaled( event ), "event is signaled\n" );
308 ok( U(iosb).Status == 0, "wrong status %x\n", U(iosb).Status );
309 ok( iosb.Information == 1, "wrong info %lu\n", iosb.Information );
310 ok( !apc_count, "apc was called\n" );
311 SleepEx( 1, TRUE ); /* alertable sleep */
312 ok( apc_count == 1, "apc was not called\n" );
313
314 /* read from disconnected pipe */
315 apc_count = 0;
316 U(iosb).Status = 0xdeadbabe;
317 iosb.Information = 0xdeadbeef;
318 CloseHandle( write );
319 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
320 ok( status == STATUS_PIPE_BROKEN, "wrong status %x\n", status );
321 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
322 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
323 ok( !is_signaled( event ), "event is signaled\n" );
324 ok( !apc_count, "apc was called\n" );
325 SleepEx( 1, TRUE ); /* alertable sleep */
326 ok( !apc_count, "apc was called\n" );
327 CloseHandle( read );
328
329 /* read from closed handle */
330 apc_count = 0;
331 U(iosb).Status = 0xdeadbabe;
332 iosb.Information = 0xdeadbeef;
333 SetEvent( event );
334 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 1, NULL, NULL );
335 ok( status == STATUS_INVALID_HANDLE, "wrong status %x\n", status );
336 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
337 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
338 ok( is_signaled( event ), "event is signaled\n" ); /* not reset on invalid handle */
339 ok( !apc_count, "apc was called\n" );
340 SleepEx( 1, TRUE ); /* alertable sleep */
341 ok( !apc_count, "apc was called\n" );
342
343 /* disconnect while async read is in progress */
344 if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
345 apc_count = 0;
346 U(iosb).Status = 0xdeadbabe;
347 iosb.Information = 0xdeadbeef;
348 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
349 ok( status == STATUS_PENDING, "wrong status %x\n", status );
350 ok( !is_signaled( event ), "event is signaled\n" );
351 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
352 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
353 ok( !apc_count, "apc was called\n" );
354 CloseHandle( write );
355 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
356 ok( U(iosb).Status == STATUS_PIPE_BROKEN, "wrong status %x\n", U(iosb).Status );
357 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
358 ok( is_signaled( event ), "event is signaled\n" );
359 ok( !apc_count, "apc was called\n" );
360 SleepEx( 1, TRUE ); /* alertable sleep */
361 ok( apc_count == 1, "apc was not called\n" );
362 CloseHandle( read );
363
364 if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
365 ok(DuplicateHandle(GetCurrentProcess(), read, GetCurrentProcess(), &handle, 0, TRUE, DUPLICATE_SAME_ACCESS),
366 "Failed to duplicate handle: %d\n", GetLastError());
367
368 apc_count = 0;
369 U(iosb).Status = 0xdeadbabe;
370 iosb.Information = 0xdeadbeef;
371 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
372 ok( status == STATUS_PENDING, "wrong status %x\n", status );
373 ok( !is_signaled( event ), "event is signaled\n" );
374 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
375 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
376 ok( !apc_count, "apc was called\n" );
377 /* Cancel by other handle */
378 status = pNtCancelIoFile( read, &iosb2 );
379 ok(status == STATUS_SUCCESS, "failed to cancel by different handle: %x\n", status);
380 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
381 ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
382 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
383 ok( is_signaled( event ), "event is signaled\n" );
384 todo_wine ok( !apc_count, "apc was called\n" );
385 SleepEx( 1, TRUE ); /* alertable sleep */
386 ok( apc_count == 1, "apc was not called\n" );
387
388 apc_count = 0;
389 U(iosb).Status = 0xdeadbabe;
390 iosb.Information = 0xdeadbeef;
391 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
392 ok( status == STATUS_PENDING, "wrong status %x\n", status );
393 ok( !is_signaled( event ), "event is signaled\n" );
394 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
395 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
396 ok( !apc_count, "apc was called\n" );
397 /* Close queued handle */
398 CloseHandle( read );
399 SleepEx( 1, TRUE ); /* alertable sleep */
400 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
401 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
402 status = pNtCancelIoFile( read, &iosb2 );
403 ok(status == STATUS_INVALID_HANDLE, "cancelled by closed handle?\n");
404 status = pNtCancelIoFile( handle, &iosb2 );
405 ok(status == STATUS_SUCCESS, "failed to cancel: %x\n", status);
406 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
407 ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
408 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
409 ok( is_signaled( event ), "event is signaled\n" );
410 todo_wine ok( !apc_count, "apc was called\n" );
411 SleepEx( 1, TRUE ); /* alertable sleep */
412 ok( apc_count == 1, "apc was not called\n" );
413 CloseHandle( handle );
414 CloseHandle( write );
415
416 if (pNtCancelIoFileEx)
417 {
418 /* Basic Cancel Ex */
419 if (!create_pipe( &read, &write, FILE_FLAG_OVERLAPPED, 4096 )) return;
420
421 apc_count = 0;
422 U(iosb).Status = 0xdeadbabe;
423 iosb.Information = 0xdeadbeef;
424 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
425 ok( status == STATUS_PENDING, "wrong status %x\n", status );
426 ok( !is_signaled( event ), "event is signaled\n" );
427 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
428 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
429 ok( !apc_count, "apc was called\n" );
430 status = pNtCancelIoFileEx( read, &iosb, &iosb2 );
431 ok(status == STATUS_SUCCESS, "Failed to cancel I/O\n");
432 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
433 ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
434 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
435 ok( is_signaled( event ), "event is signaled\n" );
436 todo_wine ok( !apc_count, "apc was called\n" );
437 SleepEx( 1, TRUE ); /* alertable sleep */
438 ok( apc_count == 1, "apc was not called\n" );
439
440 /* Duplicate iosb */
441 apc_count = 0;
442 U(iosb).Status = 0xdeadbabe;
443 iosb.Information = 0xdeadbeef;
444 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
445 ok( status == STATUS_PENDING, "wrong status %x\n", status );
446 ok( !is_signaled( event ), "event is signaled\n" );
447 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
448 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
449 ok( !apc_count, "apc was called\n" );
450 status = pNtReadFile( read, event, apc, &apc_count, &iosb, buffer, 2, NULL, NULL );
451 ok( status == STATUS_PENDING, "wrong status %x\n", status );
452 ok( !is_signaled( event ), "event is signaled\n" );
453 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
454 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
455 ok( !apc_count, "apc was called\n" );
456 status = pNtCancelIoFileEx( read, &iosb, &iosb2 );
457 ok(status == STATUS_SUCCESS, "Failed to cancel I/O\n");
458 Sleep(1); /* FIXME: needed for wine to run the i/o apc */
459 ok( U(iosb).Status == STATUS_CANCELLED, "wrong status %x\n", U(iosb).Status );
460 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
461 ok( is_signaled( event ), "event is signaled\n" );
462 todo_wine ok( !apc_count, "apc was called\n" );
463 SleepEx( 1, TRUE ); /* alertable sleep */
464 ok( apc_count == 2, "apc was not called\n" );
465
466 CloseHandle( read );
467 CloseHandle( write );
468 }
469
470 /* now try a real file */
471 if (!(handle = create_temp_file( FILE_FLAG_OVERLAPPED ))) return;
472 apc_count = 0;
473 U(iosb).Status = 0xdeadbabe;
474 iosb.Information = 0xdeadbeef;
475 offset.QuadPart = 0;
476 ResetEvent( event );
477 status = pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
478 ok( status == STATUS_SUCCESS || status == STATUS_PENDING, "wrong status %x\n", status );
479 ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
480 ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
481 ok( is_signaled( event ), "event is signaled\n" );
482 ok( !apc_count, "apc was called\n" );
483 SleepEx( 1, TRUE ); /* alertable sleep */
484 ok( apc_count == 1, "apc was not called\n" );
485
486 apc_count = 0;
487 U(iosb).Status = 0xdeadbabe;
488 iosb.Information = 0xdeadbeef;
489 offset.QuadPart = 0;
490 ResetEvent( event );
491 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
492 ok( status == STATUS_SUCCESS ||
493 status == STATUS_PENDING, /* vista */
494 "wrong status %x\n", status );
495 ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
496 ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
497 ok( is_signaled( event ), "event is signaled\n" );
498 ok( !apc_count, "apc was called\n" );
499 SleepEx( 1, TRUE ); /* alertable sleep */
500 ok( apc_count == 1, "apc was not called\n" );
501
502 /* read beyond eof */
503 apc_count = 0;
504 U(iosb).Status = 0xdeadbabe;
505 iosb.Information = 0xdeadbeef;
506 offset.QuadPart = strlen(text) + 2;
507 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
508 if (status == STATUS_PENDING) /* vista */
509 {
510 ok( U(iosb).Status == STATUS_END_OF_FILE, "wrong status %x\n", U(iosb).Status );
511 ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
512 ok( is_signaled( event ), "event is signaled\n" );
513 ok( !apc_count, "apc was called\n" );
514 SleepEx( 1, TRUE ); /* alertable sleep */
515 ok( apc_count == 1, "apc was not called\n" );
516 }
517 else
518 {
519 ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
520 ok( U(iosb).Status == 0xdeadbabe, "wrong status %x\n", U(iosb).Status );
521 ok( iosb.Information == 0xdeadbeef, "wrong info %lu\n", iosb.Information );
522 ok( !is_signaled( event ), "event is signaled\n" );
523 ok( !apc_count, "apc was called\n" );
524 SleepEx( 1, TRUE ); /* alertable sleep */
525 ok( !apc_count, "apc was called\n" );
526 }
527 CloseHandle( handle );
528
529 /* now a non-overlapped file */
530 if (!(handle = create_temp_file(0))) return;
531 apc_count = 0;
532 U(iosb).Status = 0xdeadbabe;
533 iosb.Information = 0xdeadbeef;
534 offset.QuadPart = 0;
535 status = pNtWriteFile( handle, event, apc, &apc_count, &iosb, text, strlen(text), &offset, NULL );
536 ok( status == STATUS_END_OF_FILE ||
537 status == STATUS_SUCCESS ||
538 status == STATUS_PENDING, /* vista */
539 "wrong status %x\n", status );
540 ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
541 ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
542 ok( is_signaled( event ), "event is signaled\n" );
543 ok( !apc_count, "apc was called\n" );
544 SleepEx( 1, TRUE ); /* alertable sleep */
545 ok( apc_count == 1, "apc was not called\n" );
546
547 apc_count = 0;
548 U(iosb).Status = 0xdeadbabe;
549 iosb.Information = 0xdeadbeef;
550 offset.QuadPart = 0;
551 ResetEvent( event );
552 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, strlen(text) + 10, &offset, NULL );
553 ok( status == STATUS_SUCCESS, "wrong status %x\n", status );
554 ok( U(iosb).Status == STATUS_SUCCESS, "wrong status %x\n", U(iosb).Status );
555 ok( iosb.Information == strlen(text), "wrong info %lu\n", iosb.Information );
556 ok( is_signaled( event ), "event is signaled\n" );
557 ok( !apc_count, "apc was called\n" );
558 SleepEx( 1, TRUE ); /* alertable sleep */
559 todo_wine ok( !apc_count, "apc was called\n" );
560
561 /* read beyond eof */
562 apc_count = 0;
563 U(iosb).Status = 0xdeadbabe;
564 iosb.Information = 0xdeadbeef;
565 offset.QuadPart = strlen(text) + 2;
566 ResetEvent( event );
567 status = pNtReadFile( handle, event, apc, &apc_count, &iosb, buffer, 2, &offset, NULL );
568 ok( status == STATUS_END_OF_FILE, "wrong status %x\n", status );
569 todo_wine ok( U(iosb).Status == STATUS_END_OF_FILE, "wrong status %x\n", U(iosb).Status );
570 todo_wine ok( iosb.Information == 0, "wrong info %lu\n", iosb.Information );
571 todo_wine ok( is_signaled( event ), "event is not signaled\n" );
572 ok( !apc_count, "apc was called\n" );
573 SleepEx( 1, TRUE ); /* alertable sleep */
574 ok( !apc_count, "apc was called\n" );
575
576 CloseHandle( handle );
577
578 CloseHandle( event );
579 }
580
581 static void nt_mailslot_test(void)
582 {
583 HANDLE hslot;
584 ACCESS_MASK DesiredAccess;
585 OBJECT_ATTRIBUTES attr;
586
587 ULONG CreateOptions;
588 ULONG MailslotQuota;
589 ULONG MaxMessageSize;
590 LARGE_INTEGER TimeOut;
591 IO_STATUS_BLOCK IoStatusBlock;
592 NTSTATUS rc;
593 UNICODE_STRING str;
594 WCHAR buffer1[] = { '\\','?','?','\\','M','A','I','L','S','L','O','T','\\',
595 'R',':','\\','F','R','E','D','\0' };
596
597 TimeOut.QuadPart = -1;
598
599 pRtlInitUnicodeString(&str, buffer1);
600 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
601 CreateOptions = MailslotQuota = MaxMessageSize = 0;
602 DesiredAccess = GENERIC_READ;
603
604 /*
605 * Check for NULL pointer handling
606 */
607 rc = pNtCreateMailslotFile(NULL, DesiredAccess,
608 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
609 &TimeOut);
610 ok( rc == STATUS_ACCESS_VIOLATION ||
611 rc == STATUS_INVALID_PARAMETER, /* win2k3 */
612 "rc = %x not STATUS_ACCESS_VIOLATION or STATUS_INVALID_PARAMETER\n", rc);
613
614 /*
615 * Test to see if the Timeout can be NULL
616 */
617 hslot = (HANDLE)0xdeadbeef;
618 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
619 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
620 NULL);
621 ok( rc == STATUS_SUCCESS ||
622 rc == STATUS_INVALID_PARAMETER, /* win2k3 */
623 "rc = %x not STATUS_SUCCESS or STATUS_INVALID_PARAMETER\n", rc);
624 ok( hslot != 0, "Handle is invalid\n");
625
626 if ( rc == STATUS_SUCCESS ) rc = pNtClose(hslot);
627
628 /*
629 * Test that the length field is checked properly
630 */
631 attr.Length = 0;
632 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
633 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
634 &TimeOut);
635 todo_wine ok( rc == STATUS_INVALID_PARAMETER, "rc = %x not c000000d STATUS_INVALID_PARAMETER\n", rc);
636
637 if (rc == STATUS_SUCCESS) pNtClose(hslot);
638
639 attr.Length = sizeof(OBJECT_ATTRIBUTES)+1;
640 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
641 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
642 &TimeOut);
643 todo_wine ok( rc == STATUS_INVALID_PARAMETER, "rc = %x not c000000d STATUS_INVALID_PARAMETER\n", rc);
644
645 if (rc == STATUS_SUCCESS) pNtClose(hslot);
646
647 /*
648 * Test handling of a NULL unicode string in ObjectName
649 */
650 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
651 attr.ObjectName = NULL;
652 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
653 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
654 &TimeOut);
655 ok( rc == STATUS_OBJECT_PATH_SYNTAX_BAD ||
656 rc == STATUS_INVALID_PARAMETER,
657 "rc = %x not STATUS_OBJECT_PATH_SYNTAX_BAD or STATUS_INVALID_PARAMETER\n", rc);
658
659 if (rc == STATUS_SUCCESS) pNtClose(hslot);
660
661 /*
662 * Test a valid call
663 */
664 InitializeObjectAttributes(&attr, &str, OBJ_CASE_INSENSITIVE, 0, NULL);
665 rc = pNtCreateMailslotFile(&hslot, DesiredAccess,
666 &attr, &IoStatusBlock, CreateOptions, MailslotQuota, MaxMessageSize,
667 &TimeOut);
668 ok( rc == STATUS_SUCCESS, "Create MailslotFile failed rc = %x\n", rc);
669 ok( hslot != 0, "Handle is invalid\n");
670
671 rc = pNtClose(hslot);
672 ok( rc == STATUS_SUCCESS, "NtClose failed\n");
673 }
674
675 static void test_iocp_setcompletion(HANDLE h)
676 {
677 NTSTATUS res;
678 long count;
679
680 res = pNtSetIoCompletion( h, CKEY_FIRST, CVALUE_FIRST, STATUS_INVALID_DEVICE_REQUEST, 3 );
681 ok( res == STATUS_SUCCESS, "NtSetIoCompletion failed: %x\n", res );
682
683 count = get_pending_msgs(h);
684 ok( count == 1, "Unexpected msg count: %ld\n", count );
685
686 if (get_msg(h))
687 {
688 ok( completionKey == CKEY_FIRST, "Invalid completion key: %lx\n", completionKey );
689 ok( ioSb.Information == 3, "Invalid ioSb.Information: %ld\n", ioSb.Information );
690 ok( U(ioSb).Status == STATUS_INVALID_DEVICE_REQUEST, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
691 ok( completionValue == CVALUE_FIRST, "Invalid completion value: %lx\n", completionValue );
692 }
693
694 count = get_pending_msgs(h);
695 ok( !count, "Unexpected msg count: %ld\n", count );
696 }
697
698 static void test_iocp_fileio(HANDLE h)
699 {
700 static const char pipe_name[] = "\\\\.\\pipe\\iocompletiontestnamedpipe";
701
702 IO_STATUS_BLOCK iosb;
703 FILE_COMPLETION_INFORMATION fci = {h, CKEY_SECOND};
704 HANDLE hPipeSrv, hPipeClt;
705 NTSTATUS res;
706
707 hPipeSrv = CreateNamedPipeA( pipe_name, PIPE_ACCESS_INBOUND, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024, 1000, NULL );
708 ok( hPipeSrv != INVALID_HANDLE_VALUE, "Cannot create named pipe\n" );
709 if (hPipeSrv != INVALID_HANDLE_VALUE )
710 {
711 hPipeClt = CreateFileA( pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL );
712 ok( hPipeClt != INVALID_HANDLE_VALUE, "Cannot connect to pipe\n" );
713 if (hPipeClt != INVALID_HANDLE_VALUE)
714 {
715 res = pNtSetInformationFile( hPipeSrv, &iosb, &fci, sizeof(fci), FileCompletionInformation );
716 ok( res == STATUS_INVALID_PARAMETER, "Unexpected NtSetInformationFile on non-overlapped handle: %x\n", res );
717 CloseHandle(hPipeClt);
718 }
719 CloseHandle( hPipeSrv );
720 }
721
722 hPipeSrv = CreateNamedPipeA( pipe_name, PIPE_ACCESS_INBOUND | FILE_FLAG_OVERLAPPED, PIPE_TYPE_MESSAGE | PIPE_READMODE_MESSAGE | PIPE_WAIT, 4, 1024, 1024, 1000, NULL );
723 ok( hPipeSrv != INVALID_HANDLE_VALUE, "Cannot create named pipe\n" );
724 if (hPipeSrv == INVALID_HANDLE_VALUE )
725 return;
726
727 hPipeClt = CreateFileA( pipe_name, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, FILE_FLAG_NO_BUFFERING | FILE_FLAG_OVERLAPPED, NULL );
728 ok( hPipeClt != INVALID_HANDLE_VALUE, "Cannot connect to pipe\n" );
729 if (hPipeClt != INVALID_HANDLE_VALUE)
730 {
731 OVERLAPPED o = {0,};
732 BYTE send_buf[TEST_BUF_LEN], recv_buf[TEST_BUF_LEN];
733 DWORD read;
734 long count;
735
736 NTSTATUS res = pNtSetInformationFile( hPipeSrv, &iosb, &fci, sizeof(fci), FileCompletionInformation );
737 ok( res == STATUS_SUCCESS, "NtSetInformationFile failed: %x\n", res );
738 ok( U(iosb).Status == STATUS_SUCCESS, "iosb.Status invalid: %x\n", U(iosb).Status );
739
740 memset( send_buf, 0, TEST_BUF_LEN );
741 memset( recv_buf, 0xde, TEST_BUF_LEN );
742 count = get_pending_msgs(h);
743 ok( !count, "Unexpected msg count: %ld\n", count );
744 ReadFile( hPipeSrv, recv_buf, TEST_BUF_LEN, &read, &o);
745 count = get_pending_msgs(h);
746 ok( !count, "Unexpected msg count: %ld\n", count );
747 WriteFile( hPipeClt, send_buf, TEST_BUF_LEN, &read, NULL );
748
749 if (get_msg(h))
750 {
751 ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
752 ok( ioSb.Information == 3, "Invalid ioSb.Information: %ld\n", ioSb.Information );
753 ok( U(ioSb).Status == STATUS_SUCCESS, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
754 ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
755 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] );
756 }
757 count = get_pending_msgs(h);
758 ok( !count, "Unexpected msg count: %ld\n", count );
759
760 memset( send_buf, 0, TEST_BUF_LEN );
761 memset( recv_buf, 0xde, TEST_BUF_LEN );
762 WriteFile( hPipeClt, send_buf, 2, &read, NULL );
763 count = get_pending_msgs(h);
764 ok( !count, "Unexpected msg count: %ld\n", count );
765 ReadFile( hPipeSrv, recv_buf, 2, &read, &o);
766 count = get_pending_msgs(h);
767 ok( count == 1, "Unexpected msg count: %ld\n", count );
768 if (get_msg(h))
769 {
770 ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
771 ok( ioSb.Information == 2, "Invalid ioSb.Information: %ld\n", ioSb.Information );
772 ok( U(ioSb).Status == STATUS_SUCCESS, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
773 ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
774 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] );
775 }
776
777 ReadFile( hPipeSrv, recv_buf, TEST_BUF_LEN, &read, &o);
778 CloseHandle( hPipeSrv );
779 count = get_pending_msgs(h);
780 ok( count == 1, "Unexpected msg count: %ld\n", count );
781 if (get_msg(h))
782 {
783 ok( completionKey == CKEY_SECOND, "Invalid completion key: %lx\n", completionKey );
784 ok( ioSb.Information == 0, "Invalid ioSb.Information: %ld\n", ioSb.Information );
785 /* wine sends wrong status here */
786 todo_wine ok( U(ioSb).Status == STATUS_PIPE_BROKEN, "Invalid ioSb.Status: %x\n", U(ioSb).Status);
787 ok( completionValue == (ULONG_PTR)&o, "Invalid completion value: %lx\n", completionValue );
788 }
789 }
790
791 CloseHandle( hPipeClt );
792 }
793
794 static void test_file_basic_information(void)
795 {
796 IO_STATUS_BLOCK io;
797 FILE_BASIC_INFORMATION fbi;
798 HANDLE h;
799 int res;
800 int attrib_mask = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_NORMAL;
801
802 if (!(h = create_temp_file(0))) return;
803
804 /* Check default first */
805 memset(&fbi, 0, sizeof(fbi));
806 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
807 ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
808 ok ( (fbi.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) == FILE_ATTRIBUTE_ARCHIVE,
809 "attribute %x not expected\n", fbi.FileAttributes );
810
811 /* Then SYSTEM */
812 /* Clear fbi to avoid setting times */
813 memset(&fbi, 0, sizeof(fbi));
814 fbi.FileAttributes = FILE_ATTRIBUTE_SYSTEM;
815 res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
816 ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
817
818 memset(&fbi, 0, sizeof(fbi));
819 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
820 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
821 todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_SYSTEM, "attribute %x not FILE_ATTRIBUTE_SYSTEM\n", fbi.FileAttributes );
822
823 /* Then HIDDEN */
824 memset(&fbi, 0, sizeof(fbi));
825 fbi.FileAttributes = FILE_ATTRIBUTE_HIDDEN;
826 res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
827 ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
828
829 memset(&fbi, 0, sizeof(fbi));
830 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
831 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
832 todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_HIDDEN, "attribute %x not FILE_ATTRIBUTE_HIDDEN\n", fbi.FileAttributes );
833
834 /* Check NORMAL last of all (to make sure we can clear attributes) */
835 memset(&fbi, 0, sizeof(fbi));
836 fbi.FileAttributes = FILE_ATTRIBUTE_NORMAL;
837 res = pNtSetInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
838 ok ( res == STATUS_SUCCESS, "can't set normal attribute\n");
839
840 memset(&fbi, 0, sizeof(fbi));
841 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBasicInformation);
842 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
843 todo_wine ok ( (fbi.FileAttributes & attrib_mask) == FILE_ATTRIBUTE_NORMAL, "attribute %x not 0\n", fbi.FileAttributes );
844
845 CloseHandle( h );
846 }
847
848 static void test_file_all_information(void)
849 {
850 IO_STATUS_BLOCK io;
851 /* FileAllInformation, like FileNameInformation, has a variable-length pathname
852 * buffer at the end. Vista objects with STATUS_BUFFER_OVERFLOW if you
853 * don't leave enough room there.
854 */
855 struct {
856 FILE_ALL_INFORMATION fai;
857 WCHAR buf[256];
858 } fai_buf;
859 HANDLE h;
860 int res;
861 int attrib_mask = FILE_ATTRIBUTE_SYSTEM | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_NORMAL;
862
863 if (!(h = create_temp_file(0))) return;
864
865 /* Check default first */
866 res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
867 ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
868 ok ( (fai_buf.fai.BasicInformation.FileAttributes & FILE_ATTRIBUTE_ARCHIVE) == FILE_ATTRIBUTE_ARCHIVE,
869 "attribute %x not expected\n", fai_buf.fai.BasicInformation.FileAttributes );
870
871 /* Then SYSTEM */
872 /* Clear fbi to avoid setting times */
873 memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
874 fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_SYSTEM;
875 res = pNtSetInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
876 ok ( res == STATUS_INVALID_INFO_CLASS || res == STATUS_NOT_IMPLEMENTED, "shouldn't be able to set FileAllInformation, res %x\n", res);
877 res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
878 ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
879
880 memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
881 res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
882 ok ( res == STATUS_SUCCESS, "can't get attributes, res %x\n", res);
883 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 );
884
885 /* Then HIDDEN */
886 memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
887 fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_HIDDEN;
888 res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
889 ok ( res == STATUS_SUCCESS, "can't set system attribute\n");
890
891 memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
892 res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
893 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
894 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 );
895
896 /* Check NORMAL last of all (to make sure we can clear attributes) */
897 memset(&fai_buf.fai.BasicInformation, 0, sizeof(fai_buf.fai.BasicInformation));
898 fai_buf.fai.BasicInformation.FileAttributes = FILE_ATTRIBUTE_NORMAL;
899 res = pNtSetInformationFile(h, &io, &fai_buf.fai.BasicInformation, sizeof fai_buf.fai.BasicInformation, FileBasicInformation);
900 ok ( res == STATUS_SUCCESS, "can't set normal attribute\n");
901
902 memset(&fai_buf.fai, 0, sizeof(fai_buf.fai));
903 res = pNtQueryInformationFile(h, &io, &fai_buf.fai, sizeof fai_buf, FileAllInformation);
904 ok ( res == STATUS_SUCCESS, "can't get attributes\n");
905 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 );
906
907 CloseHandle( h );
908 }
909
910 static void test_file_both_information(void)
911 {
912 IO_STATUS_BLOCK io;
913 FILE_BOTH_DIR_INFORMATION fbi;
914 HANDLE h;
915 int res;
916
917 if (!(h = create_temp_file(0))) return;
918
919 memset(&fbi, 0, sizeof(fbi));
920 res = pNtQueryInformationFile(h, &io, &fbi, sizeof fbi, FileBothDirectoryInformation);
921 ok ( res == STATUS_INVALID_INFO_CLASS || res == STATUS_NOT_IMPLEMENTED, "shouldn't be able to query FileBothDirectoryInformation, res %x\n", res);
922
923 CloseHandle( h );
924 }
925
926 static void test_iocompletion(void)
927 {
928 HANDLE h = INVALID_HANDLE_VALUE;
929 NTSTATUS res;
930
931 res = pNtCreateIoCompletion( &h, IO_COMPLETION_ALL_ACCESS, NULL, 0);
932
933 ok( res == 0, "NtCreateIoCompletion anonymous failed: %x\n", res );
934 ok( h && h != INVALID_HANDLE_VALUE, "Invalid handle returned\n" );
935
936 if ( h && h != INVALID_HANDLE_VALUE)
937 {
938 test_iocp_setcompletion(h);
939 test_iocp_fileio(h);
940 pNtClose(h);
941 }
942 }
943
944 static void test_file_name_information(void)
945 {
946 WCHAR *file_name, *volume_prefix, *expected;
947 FILE_NAME_INFORMATION *info;
948 UINT file_name_size;
949 IO_STATUS_BLOCK io;
950 UINT info_size;
951 HRESULT hr;
952 HANDLE h;
953 UINT len;
954
955 /* GetVolumePathName is not present before w2k */
956 if (!pGetVolumePathNameW) {
957 win_skip("GetVolumePathNameW not found\n");
958 return;
959 }
960
961 file_name_size = GetSystemDirectoryW( NULL, 0 );
962 file_name = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*file_name) );
963 volume_prefix = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
964 expected = HeapAlloc( GetProcessHeap(), 0, file_name_size * sizeof(*volume_prefix) );
965
966 len = GetSystemDirectoryW( file_name, file_name_size );
967 ok(len == file_name_size - 1,
968 "GetSystemDirectoryW returned %u, expected %u.\n",
969 len, file_name_size - 1);
970
971 len = pGetVolumePathNameW( file_name, volume_prefix, file_name_size );
972 ok(len, "GetVolumePathNameW failed.\n");
973
974 len = lstrlenW( volume_prefix );
975 if (len && volume_prefix[len - 1] == '\\') --len;
976 memcpy( expected, file_name + len, (file_name_size - len - 1) * sizeof(WCHAR) );
977 expected[file_name_size - len - 1] = '\0';
978
979 /* A bit more than we actually need, but it keeps the calculation simple. */
980 info_size = sizeof(*info) + (file_name_size * sizeof(WCHAR));
981 info = HeapAlloc( GetProcessHeap(), 0, info_size );
982
983 h = CreateFileW( file_name, GENERIC_READ,
984 FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
985 NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, 0 );
986 ok(h != INVALID_HANDLE_VALUE, "Failed to open file.\n");
987
988 hr = pNtQueryInformationFile( h, &io, info, sizeof(*info) - 1, FileNameInformation );
989 ok(hr == STATUS_INFO_LENGTH_MISMATCH, "NtQueryInformationFile returned %#x.\n", hr);
990
991 memset( info, 0xcc, info_size );
992 hr = pNtQueryInformationFile( h, &io, info, sizeof(*info), FileNameInformation );
993 ok(hr == STATUS_BUFFER_OVERFLOW, "NtQueryInformationFile returned %#x, expected %#x.\n",
994 hr, STATUS_BUFFER_OVERFLOW);
995 ok(U(io).Status == STATUS_BUFFER_OVERFLOW, "io.Status is %#x, expected %#x.\n",
996 U(io).Status, STATUS_BUFFER_OVERFLOW);
997 ok(info->FileNameLength == lstrlenW( expected ) * sizeof(WCHAR), "info->FileNameLength is %u, expected %u.\n",
998 info->FileNameLength, lstrlenW( expected ) * sizeof(WCHAR));
999 ok(info->FileName[2] == 0xcccc, "info->FileName[2] is %#x, expected 0xcccc.\n", info->FileName[2]);
1000 ok(CharLowerW((LPWSTR)(UINT_PTR)info->FileName[1]) == CharLowerW((LPWSTR)(UINT_PTR)expected[1]),
1001 "info->FileName[1] is %p, expected %p.\n",
1002 CharLowerW((LPWSTR)(UINT_PTR)info->FileName[1]), CharLowerW((LPWSTR)(UINT_PTR)expected[1]));
1003 ok(io.Information == sizeof(*info), "io.Information is %lu, expected %u.\n", io.Information, sizeof(*info));
1004
1005 memset( info, 0xcc, info_size );
1006 hr = pNtQueryInformationFile( h, &io, info, info_size, FileNameInformation );
1007 ok(hr == STATUS_SUCCESS, "NtQueryInformationFile returned %#x, expected %#x.\n", hr, STATUS_SUCCESS);
1008 ok(U(io).Status == STATUS_SUCCESS, "io.Status is %#x, expected %#x.\n", U(io).Status, STATUS_SUCCESS);
1009 ok(info->FileNameLength == lstrlenW( expected ) * sizeof(WCHAR), "info->FileNameLength is %u, expected %u.\n",
1010 info->FileNameLength, lstrlenW( expected ) * sizeof(WCHAR));
1011 ok(info->FileName[info->FileNameLength / sizeof(WCHAR)] == 0xcccc, "info->FileName[%u] is %#x, expected 0xcccc.\n",
1012 info->FileNameLength / sizeof(WCHAR), info->FileName[info->FileNameLength / sizeof(WCHAR)]);
1013 info->FileName[info->FileNameLength / sizeof(WCHAR)] = '\0';
1014 ok(!lstrcmpiW( info->FileName, expected ), "info->FileName is %s, expected %s.\n",
1015 wine_dbgstr_w( info->FileName ), wine_dbgstr_w( expected ));
1016 ok(io.Information == FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) + info->FileNameLength,
1017 "io.Information is %lu, expected %u.\n",
1018 io.Information, FIELD_OFFSET(FILE_NAME_INFORMATION, FileName) + info->FileNameLength);
1019
1020 CloseHandle( h );
1021 HeapFree( GetProcessHeap(), 0, info );
1022 HeapFree( GetProcessHeap(), 0, expected );
1023 HeapFree( GetProcessHeap(), 0, volume_prefix );
1024 HeapFree( GetProcessHeap(), 0, file_name );
1025 }
1026
1027 START_TEST(file)
1028 {
1029 HMODULE hkernel32 = GetModuleHandleA("kernel32.dll");
1030 HMODULE hntdll = GetModuleHandleA("ntdll.dll");
1031 if (!hntdll)
1032 {
1033 skip("not running on NT, skipping test\n");
1034 return;
1035 }
1036
1037 pGetVolumePathNameW = (void *)GetProcAddress(hkernel32, "GetVolumePathNameW");
1038
1039 pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
1040 pRtlInitUnicodeString = (void *)GetProcAddress(hntdll, "RtlInitUnicodeString");
1041 pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
1042 pNtCreateMailslotFile = (void *)GetProcAddress(hntdll, "NtCreateMailslotFile");
1043 pNtDeleteFile = (void *)GetProcAddress(hntdll, "NtDeleteFile");
1044 pNtReadFile = (void *)GetProcAddress(hntdll, "NtReadFile");
1045 pNtWriteFile = (void *)GetProcAddress(hntdll, "NtWriteFile");
1046 pNtCancelIoFile = (void *)GetProcAddress(hntdll, "NtCancelIoFile");
1047 pNtCancelIoFileEx = (void *)GetProcAddress(hntdll, "NtCancelIoFileEx");
1048 pNtClose = (void *)GetProcAddress(hntdll, "NtClose");
1049 pNtCreateIoCompletion = (void *)GetProcAddress(hntdll, "NtCreateIoCompletion");
1050 pNtOpenIoCompletion = (void *)GetProcAddress(hntdll, "NtOpenIoCompletion");
1051 pNtQueryIoCompletion = (void *)GetProcAddress(hntdll, "NtQueryIoCompletion");
1052 pNtRemoveIoCompletion = (void *)GetProcAddress(hntdll, "NtRemoveIoCompletion");
1053 pNtSetIoCompletion = (void *)GetProcAddress(hntdll, "NtSetIoCompletion");
1054 pNtSetInformationFile = (void *)GetProcAddress(hntdll, "NtSetInformationFile");
1055 pNtQueryInformationFile = (void *)GetProcAddress(hntdll, "NtQueryInformationFile");
1056
1057 delete_file_test();
1058 read_file_test();
1059 nt_mailslot_test();
1060 test_iocompletion();
1061 test_file_basic_information();
1062 test_file_all_information();
1063 test_file_both_information();
1064 test_file_name_information();
1065 }
1066
This page was automatically generated by the
LXR engine.
Visit the LXR main site for more
information.