ReactOS 0.4.15-dev-7788-g1ad9096
file.c
Go to the documentation of this file.
1/*
2 * Unit tests for file functions in Wine
3 *
4 * Copyright (c) 2002, 2004 Jakob Eriksson
5 * Copyright (c) 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 */
22
23#include "precomp.h"
24
25#include <time.h>
26#include <fileapi.h>
27
28#undef DeleteFile /* needed for FILE_DISPOSITION_INFO */
29
31static BOOL (WINAPI *pReplaceFileA)(LPCSTR, LPCSTR, LPCSTR, DWORD, LPVOID, LPVOID);
32static BOOL (WINAPI *pReplaceFileW)(LPCWSTR, LPCWSTR, LPCWSTR, DWORD, LPVOID, LPVOID);
33static UINT (WINAPI *pGetSystemWindowsDirectoryA)(LPSTR, UINT);
34static BOOL (WINAPI *pGetVolumeNameForVolumeMountPointA)(LPCSTR, LPSTR, DWORD);
35static DWORD (WINAPI *pQueueUserAPC)(PAPCFUNC pfnAPC, HANDLE hThread, ULONG_PTR dwData);
36static BOOL (WINAPI *pGetFileInformationByHandleEx)(HANDLE, FILE_INFO_BY_HANDLE_CLASS, LPVOID, DWORD);
38static BOOL (WINAPI *pSetFileValidData)(HANDLE, LONGLONG);
39static HRESULT (WINAPI *pCopyFile2)(PCWSTR,PCWSTR,COPYFILE2_EXTENDED_PARAMETERS*);
41static DWORD (WINAPI *pGetFinalPathNameByHandleA)(HANDLE, LPSTR, DWORD, DWORD);
42static DWORD (WINAPI *pGetFinalPathNameByHandleW)(HANDLE, LPWSTR, DWORD, DWORD);
45static BOOL (WINAPI *pRtlDosPathNameToNtPathName_U)(LPCWSTR, PUNICODE_STRING, PWSTR*, CURDIR*);
46static NTSTATUS (WINAPI *pRtlAnsiStringToUnicodeString)(PUNICODE_STRING, PCANSI_STRING, BOOLEAN);
47static BOOL (WINAPI *pSetFileInformationByHandle)(HANDLE, FILE_INFO_BY_HANDLE_CLASS, void*, DWORD);
48static void (WINAPI *pRtlInitAnsiString)(PANSI_STRING,PCSZ);
49static void (WINAPI *pRtlFreeUnicodeString)(PUNICODE_STRING);
50
51static char filename[MAX_PATH];
52static const char sillytext[] =
53"en larvig liten text dx \033 gx hej 84 hej 4484 ! \001\033 bla bl\na.. bla bla."
54"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
55"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
56"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
57"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
58"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
59"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
60"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
61"1234 43 4kljf lf &%%%&&&&&& 34 4 34 3############# 33 3 3 3 # 3## 3"
62"sdlkfjasdlkfj a dslkj adsklf \n \nasdklf askldfa sdlkf \nsadklf asdklf asdf ";
63
64struct test_list {
65 const char *file; /* file string to test */
66 const DWORD err; /* Win NT and further error code */
67 const LONG err2; /* Win 9x & ME error code or -1 */
68 const DWORD options; /* option flag to use for open */
69 const BOOL todo_flag; /* todo_wine indicator */
70} ;
71
72static void InitFunctionPointers(void)
73{
76
77 pNtCreateFile = (void *)GetProcAddress(hntdll, "NtCreateFile");
78 pRtlDosPathNameToNtPathName_U = (void *)GetProcAddress(hntdll, "RtlDosPathNameToNtPathName_U");
79 pRtlAnsiStringToUnicodeString = (void *)GetProcAddress(hntdll, "RtlAnsiStringToUnicodeString");
80 pRtlInitAnsiString = (void *)GetProcAddress(hntdll, "RtlInitAnsiString");
81 pRtlFreeUnicodeString = (void *)GetProcAddress(hntdll, "RtlFreeUnicodeString");
82
83 pFindFirstFileExA=(void*)GetProcAddress(hkernel32, "FindFirstFileExA");
84 pReplaceFileA=(void*)GetProcAddress(hkernel32, "ReplaceFileA");
85 pReplaceFileW=(void*)GetProcAddress(hkernel32, "ReplaceFileW");
86 pGetSystemWindowsDirectoryA=(void*)GetProcAddress(hkernel32, "GetSystemWindowsDirectoryA");
87 pGetVolumeNameForVolumeMountPointA = (void *) GetProcAddress(hkernel32, "GetVolumeNameForVolumeMountPointA");
88 pQueueUserAPC = (void *) GetProcAddress(hkernel32, "QueueUserAPC");
89 pGetFileInformationByHandleEx = (void *) GetProcAddress(hkernel32, "GetFileInformationByHandleEx");
90 pOpenFileById = (void *) GetProcAddress(hkernel32, "OpenFileById");
91 pSetFileValidData = (void *) GetProcAddress(hkernel32, "SetFileValidData");
92 pCopyFile2 = (void *) GetProcAddress(hkernel32, "CopyFile2");
93 pCreateFile2 = (void *) GetProcAddress(hkernel32, "CreateFile2");
94 pGetFinalPathNameByHandleA = (void *) GetProcAddress(hkernel32, "GetFinalPathNameByHandleA");
95 pGetFinalPathNameByHandleW = (void *) GetProcAddress(hkernel32, "GetFinalPathNameByHandleW");
96 pSetFileInformationByHandle = (void *) GetProcAddress(hkernel32, "SetFileInformationByHandle");
97}
98
99static void test__hread( void )
100{
101 HFILE filehandle;
102 char buffer[10000];
103 LONG bytes_read;
104 LONG bytes_wanted;
105 LONG i;
106 BOOL ret;
107
108 SetFileAttributesA(filename,FILE_ATTRIBUTE_NORMAL); /* be sure to remove stale files */
110 filehandle = _lcreat( filename, 0 );
111 if (filehandle == HFILE_ERROR)
112 {
113 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
114 return;
115 }
116
117 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
118
119 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
120
121 filehandle = _lopen( filename, OF_READ );
122
123 ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError( ) );
124
125 bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
126
127 ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
128
129 for (bytes_wanted = 0; bytes_wanted < lstrlenA( sillytext ); bytes_wanted++)
130 {
131 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
132 ok( _hread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
133 for (i = 0; i < bytes_wanted; i++)
134 {
135 ok( buffer[i] == sillytext[i], "that's not what's written\n" );
136 }
137 }
138
139 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
140
142 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
143}
144
145
146static void test__hwrite( void )
147{
148 HFILE filehandle;
149 char buffer[10000];
150 LONG bytes_read;
151 LONG bytes_written;
153 LONG i;
154 char *contents;
155 HLOCAL memory_object;
156 char checksum[1];
157 BOOL ret;
158
159 filehandle = _lcreat( filename, 0 );
160 if (filehandle == HFILE_ERROR)
161 {
162 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
163 return;
164 }
165
166 ok( HFILE_ERROR != _hwrite( filehandle, "", 0 ), "_hwrite complains\n" );
167
168 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
169
170 filehandle = _lopen( filename, OF_READ );
171
172 bytes_read = _hread( filehandle, buffer, 1);
173
174 ok( 0 == bytes_read, "file read size error\n" );
175
176 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
177
178 filehandle = _lopen( filename, OF_READWRITE );
179
180 bytes_written = 0;
181 checksum[0] = '\0';
182 srand( (unsigned)time( NULL ) );
183 for (blocks = 0; blocks < 100; blocks++)
184 {
185 for (i = 0; i < (LONG)sizeof( buffer ); i++)
186 {
187 buffer[i] = rand( );
188 checksum[0] = checksum[0] + buffer[i];
189 }
190 ok( HFILE_ERROR != _hwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
191 bytes_written = bytes_written + sizeof( buffer );
192 }
193
194 ok( HFILE_ERROR != _hwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
195 bytes_written++;
196
197 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
198
199 memory_object = LocalAlloc( LPTR, bytes_written );
200
201 ok( 0 != memory_object, "LocalAlloc fails. (Could be out of memory.)\n" );
202
203 contents = LocalLock( memory_object );
204 ok( NULL != contents, "LocalLock whines\n" );
205
206 filehandle = _lopen( filename, OF_READ );
207
208 contents = LocalLock( memory_object );
209 ok( NULL != contents, "LocalLock whines\n" );
210
211 ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
212
213 checksum[0] = '\0';
214 i = 0;
215 do
216 {
217 checksum[0] = checksum[0] + contents[i];
218 i++;
219 }
220 while (i < bytes_written - 1);
221
222 ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
223
224 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
225
227 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
228
230}
231
232
233static void test__lclose( void )
234{
235 HFILE filehandle;
236 BOOL ret;
237
238 filehandle = _lcreat( filename, 0 );
239 if (filehandle == HFILE_ERROR)
240 {
241 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
242 return;
243 }
244
245 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
246
247 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
248
250 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError( ) );
251}
252
253/* helper function for test__lcreat */
254static void get_nt_pathW( const char *name, UNICODE_STRING *nameW )
255{
259 BOOLEAN ret;
260
261 pRtlInitAnsiString( &str, name );
262
263 status = pRtlAnsiStringToUnicodeString( &strW, &str, TRUE );
264 ok( !status, "RtlAnsiStringToUnicodeString failed with %08x\n", status );
265
266 ret = pRtlDosPathNameToNtPathName_U( strW.Buffer, nameW, NULL, NULL );
267 ok( ret, "RtlDosPathNameToNtPathName_U failed\n" );
268
269 pRtlFreeUnicodeString( &strW );
270}
271
272static void test__lcreat( void )
273{
277 HFILE filehandle;
278 char buffer[10000];
279 WIN32_FIND_DATAA search_results;
280 char slashname[] = "testfi/";
281 int err;
284 BOOL ret;
285
286 filehandle = _lcreat( filename, 0 );
287 if (filehandle == HFILE_ERROR)
288 {
289 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
290 return;
291 }
292
293 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
294
295 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
296
297 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
298
299 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
300
301 find = FindFirstFileA( filename, &search_results );
302 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
303 FindClose( find );
304
306 ok( ret != 0, "DeleteFile failed (%d)\n", GetLastError());
307
308 filehandle = _lcreat( filename, 1 ); /* readonly */
309 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
310
311 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write never the less\n" );
312
313 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
314
315 find = FindFirstFileA( filename, &search_results );
316 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
317 FindClose( find );
318
319 SetLastError( 0xdeadbeef );
320 ok( 0 == DeleteFileA( filename ), "shouldn't be able to delete a readonly file\n" );
321 ok( GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError() );
322
323 ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
324
325 ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file!\n" );
326
327 filehandle = _lcreat( filename, 1 ); /* readonly */
328 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError() );
329 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen(sillytext) ),
330 "_hwrite shouldn't be able to write never the less\n" );
331 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
332
333 find = FindFirstFileA( filename, &search_results );
334 ok( INVALID_HANDLE_VALUE != find, "should be able to find file\n" );
335 FindClose( find );
336
338 attr.Length = sizeof(attr);
339 attr.RootDirectory = 0;
340 attr.Attributes = OBJ_CASE_INSENSITIVE;
341 attr.ObjectName = &filenameW;
342 attr.SecurityDescriptor = NULL;
343 attr.SecurityQualityOfService = NULL;
344
345 status = pNtCreateFile( &file, GENERIC_READ | GENERIC_WRITE | DELETE, &attr, &io, NULL, 0,
348 ok( status == STATUS_ACCESS_DENIED, "expected STATUS_ACCESS_DENIED, got %08x\n", status );
349 ok( GetFileAttributesA( filename ) != INVALID_FILE_ATTRIBUTES, "file was deleted\n" );
350
351 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
354 ok( status == STATUS_CANNOT_DELETE, "expected STATUS_CANNOT_DELETE, got %08x\n", status );
355
356 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
359 ok( status == STATUS_NOT_A_DIRECTORY, "expected STATUS_NOT_A_DIRECTORY, got %08x\n", status );
360
361 status = pNtCreateFile( &file, DELETE, &attr, &io, NULL, 0,
365 ok( status == STATUS_CANNOT_DELETE, "expected STATUS_CANNOT_DELETE, got %08x\n", status );
366 if (!status) CloseHandle( file );
367
368 pRtlFreeUnicodeString( &filenameW );
369
371 ok( GetFileAttributesA( filename ) != INVALID_FILE_ATTRIBUTES, "file was deleted\n" );
373 ok( SetFileAttributesA(filename, FILE_ATTRIBUTE_NORMAL ) != 0, "couldn't change attributes on file\n" );
375 ok( DeleteFileA( filename ) != 0, "now it should be possible to delete the file\n" );
376
377 filehandle = _lcreat( filename, 2 );
378 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
379
380 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
381
382 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
383
384 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
385
386 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
387
388 find = FindFirstFileA( filename, &search_results );
389 ok( INVALID_HANDLE_VALUE != find, "should STILL be able to find file\n" );
390 FindClose( find );
391
393 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
394
395 filehandle = _lcreat( filename, 4 ); /* SYSTEM file */
396 ok( HFILE_ERROR != filehandle, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError( ) );
397
398 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
399
400 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
401
402 ok( _hread( filehandle, buffer, strlen( sillytext ) ) == lstrlenA( sillytext ), "erratic _hread return value\n" );
403
404 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
405
406 find = FindFirstFileA( filename, &search_results );
407 ok( INVALID_HANDLE_VALUE != find, "should STILL be able to find file\n" );
408 FindClose( find );
409
411 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
412
413 filehandle=_lcreat (slashname, 0); /* illegal name */
414 if (HFILE_ERROR==filehandle) {
415 err=GetLastError ();
417 "creating file \"%s\" failed with error %d\n", slashname, err);
418 } else { /* only NT succeeds */
419 _lclose(filehandle);
420 find=FindFirstFileA (slashname, &search_results);
422 {
423 ret = FindClose (find);
424 ok (0 != ret, "FindClose complains (%d)\n", GetLastError ());
425 slashname[strlen(slashname)-1]=0;
426 ok (!strcmp (slashname, search_results.cFileName),
427 "found unexpected name \"%s\"\n", search_results.cFileName);
428 ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
429 "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
430 search_results.dwFileAttributes);
431 }
432 ret = DeleteFileA( slashname );
433 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
434 }
435
436 filehandle=_lcreat (filename, 8); /* illegal attribute */
437 if (HFILE_ERROR==filehandle)
438 ok (0, "couldn't create volume label \"%s\"\n", filename);
439 else {
440 _lclose(filehandle);
441 find=FindFirstFileA (filename, &search_results);
443 ok (0, "file \"%s\" not found\n", filename);
444 else {
445 const char *name = strrchr(filename, '\\');
446
447 if (name) name++;
448 else name = filename;
449
450 ret = FindClose(find);
451 ok ( 0 != ret, "FindClose complains (%d)\n", GetLastError ());
452 ok (!strcmp (name, search_results.cFileName),
453 "expected \"%s\", got \"%s\"\n", name, search_results.cFileName);
454 search_results.dwFileAttributes &= ~FILE_ATTRIBUTE_NOT_CONTENT_INDEXED;
455 search_results.dwFileAttributes &= ~FILE_ATTRIBUTE_COMPRESSED;
456 ok (FILE_ATTRIBUTE_ARCHIVE==search_results.dwFileAttributes,
457 "attributes of file \"%s\" are 0x%04x\n", search_results.cFileName,
458 search_results.dwFileAttributes);
459 }
461 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
462 }
463}
464
465
466static void test__llseek( void )
467{
468 INT i;
469 HFILE filehandle;
470 char buffer[1];
471 LONG bytes_read;
472 BOOL ret;
473
474 filehandle = _lcreat( filename, 0 );
475 if (filehandle == HFILE_ERROR)
476 {
477 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
478 return;
479 }
480
481 for (i = 0; i < 400; i++)
482 {
483 ok( _hwrite( filehandle, sillytext, strlen( sillytext ) ) != -1, "_hwrite complains\n" );
484 }
485 ok( _llseek( filehandle, 400 * strlen( sillytext ), FILE_CURRENT ) != -1, "should be able to seek\n" );
486 ok( _llseek( filehandle, 27 + 35 * strlen( sillytext ), FILE_BEGIN ) != -1, "should be able to seek\n" );
487
488 bytes_read = _hread( filehandle, buffer, 1);
489 ok( 1 == bytes_read, "file read size error\n" );
490 ok( buffer[0] == sillytext[27], "_llseek error, it got lost seeking\n" );
491 ok( _llseek( filehandle, -400 * (LONG)strlen( sillytext ), FILE_END ) != -1, "should be able to seek\n" );
492
493 bytes_read = _hread( filehandle, buffer, 1);
494 ok( 1 == bytes_read, "file read size error\n" );
495 ok( buffer[0] == sillytext[0], "_llseek error, it got lost seeking\n" );
496 ok( _llseek( filehandle, 1000000, FILE_END ) != -1, "should be able to seek past file; poor, poor Windows programmers\n" );
497 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
498
500 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
501}
502
503
504static void test__llopen( void )
505{
506 HFILE filehandle;
507 UINT bytes_read;
508 char buffer[10000];
509 BOOL ret;
510
511 filehandle = _lcreat( filename, 0 );
512 if (filehandle == HFILE_ERROR)
513 {
514 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
515 return;
516 }
517
518 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
519 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
520
521 filehandle = _lopen( filename, OF_READ );
522 ok( HFILE_ERROR == _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite shouldn't be able to write!\n" );
523 bytes_read = _hread( filehandle, buffer, strlen( sillytext ) );
524 ok( strlen( sillytext ) == bytes_read, "file read size error\n" );
525 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
526
527 filehandle = _lopen( filename, OF_READWRITE );
528 bytes_read = _hread( filehandle, buffer, 2 * strlen( sillytext ) );
529 ok( strlen( sillytext ) == bytes_read, "file read size error\n" );
530 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
531 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
532
533 filehandle = _lopen( filename, OF_WRITE );
534 ok( HFILE_ERROR == _hread( filehandle, buffer, 1 ), "you should only be able to write this file\n" );
535 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite should write just fine\n" );
536 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
537
539 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
540 /* TODO - add tests for the SHARE modes - use two processes to pull this one off */
541}
542
543
544static void test__lread( void )
545{
546 HFILE filehandle;
547 char buffer[10000];
548 UINT bytes_read;
549 UINT bytes_wanted;
550 UINT i;
551 BOOL ret;
552
553 filehandle = _lcreat( filename, 0 );
554 if (filehandle == HFILE_ERROR)
555 {
556 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
557 return;
558 }
559
560 ok( HFILE_ERROR != _hwrite( filehandle, sillytext, strlen( sillytext ) ), "_hwrite complains\n" );
561
562 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
563
564 filehandle = _lopen( filename, OF_READ );
565
566 ok( HFILE_ERROR != filehandle, "couldn't open file \"%s\" again (err=%d)\n", filename, GetLastError());
567
568 bytes_read = _lread( filehandle, buffer, 2 * strlen( sillytext ) );
569
570 ok( lstrlenA( sillytext ) == bytes_read, "file read size error\n" );
571
572 for (bytes_wanted = 0; bytes_wanted < strlen( sillytext ); bytes_wanted++)
573 {
574 ok( 0 == _llseek( filehandle, 0, FILE_BEGIN ), "_llseek complains\n" );
575 ok( _lread( filehandle, buffer, bytes_wanted ) == bytes_wanted, "erratic _hread return value\n" );
576 for (i = 0; i < bytes_wanted; i++)
577 {
578 ok( buffer[i] == sillytext[i], "that's not what's written\n" );
579 }
580 }
581
582 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
583
585 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
586}
587
588
589static void test__lwrite( void )
590{
591 HFILE filehandle;
592 char buffer[10000];
593 UINT bytes_read;
594 UINT bytes_written;
595 UINT blocks;
596 INT i;
597 char *contents;
598 HLOCAL memory_object;
599 char checksum[1];
600 BOOL ret;
601
602 filehandle = _lcreat( filename, 0 );
603 if (filehandle == HFILE_ERROR)
604 {
605 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
606 return;
607 }
608
609 ok( HFILE_ERROR != _lwrite( filehandle, "", 0 ), "_hwrite complains\n" );
610
611 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
612
613 filehandle = _lopen( filename, OF_READ );
614
615 bytes_read = _hread( filehandle, buffer, 1);
616
617 ok( 0 == bytes_read, "file read size error\n" );
618
619 ok( HFILE_ERROR != _lclose(filehandle), "_lclose complains\n" );
620
621 filehandle = _lopen( filename, OF_READWRITE );
622
623 bytes_written = 0;
624 checksum[0] = '\0';
625 srand( (unsigned)time( NULL ) );
626 for (blocks = 0; blocks < 100; blocks++)
627 {
628 for (i = 0; i < (INT)sizeof( buffer ); i++)
629 {
630 buffer[i] = rand( );
631 checksum[0] = checksum[0] + buffer[i];
632 }
633 ok( HFILE_ERROR != _lwrite( filehandle, buffer, sizeof( buffer ) ), "_hwrite complains\n" );
634 bytes_written = bytes_written + sizeof( buffer );
635 }
636
637 ok( HFILE_ERROR != _lwrite( filehandle, checksum, 1 ), "_hwrite complains\n" );
638 bytes_written++;
639
640 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
641
642 memory_object = LocalAlloc( LPTR, bytes_written );
643
644 ok( 0 != memory_object, "LocalAlloc fails, could be out of memory\n" );
645
646 contents = LocalLock( memory_object );
647 ok( NULL != contents, "LocalLock whines\n" );
648
649 filehandle = _lopen( filename, OF_READ );
650
651 contents = LocalLock( memory_object );
652 ok( NULL != contents, "LocalLock whines\n" );
653
654 ok( bytes_written == _hread( filehandle, contents, bytes_written), "read length differ from write length\n" );
655
656 checksum[0] = '\0';
657 i = 0;
658 do
659 {
660 checksum[0] += contents[i];
661 i++;
662 }
663 while (i < bytes_written - 1);
664
665 ok( checksum[0] == contents[i], "stored checksum differ from computed checksum\n" );
666
667 ok( HFILE_ERROR != _lclose( filehandle ), "_lclose complains\n" );
668
670 ok( ret, "DeleteFile failed (%d)\n", GetLastError( ) );
671
673}
674
675static void test_CopyFileA(void)
676{
677 char temp_path[MAX_PATH];
679 static const char prefix[] = "pfx";
680 HANDLE hfile;
681 HANDLE hmapfile;
682 FILETIME ft1, ft2;
683 char buf[10];
684 DWORD ret;
685 BOOL retok;
686
688 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
689 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
690
691 ret = GetTempFileNameA(temp_path, prefix, 0, source);
692 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
693
694 /* copying a file to itself must fail */
695 retok = CopyFileA(source, source, FALSE);
696 ok( !retok && (GetLastError() == ERROR_SHARING_VIOLATION || broken(GetLastError() == ERROR_FILE_EXISTS) /* Win 9x */),
697 "copying a file to itself didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
698
699 /* make the source have not zero size */
700 hfile = CreateFileA(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
701 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
702 retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
703 ok( retok && ret == sizeof(prefix),
704 "WriteFile error %d\n", GetLastError());
705 ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
706 /* get the file time and change it to prove the difference */
707 ret = GetFileTime(hfile, NULL, NULL, &ft1);
708 ok( ret, "GetFileTime error %d\n", GetLastError());
709 ft1.dwLowDateTime -= 600000000; /* 60 second */
710 ret = SetFileTime(hfile, NULL, NULL, &ft1);
711 ok( ret, "SetFileTime error %d\n", GetLastError());
712 GetFileTime(hfile, NULL, NULL, &ft1); /* get the actual time back */
713 CloseHandle(hfile);
714
715 ret = GetTempFileNameA(temp_path, prefix, 0, dest);
716 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
717
718 SetLastError(0xdeadbeef);
721 "CopyFileA: unexpected error %d\n", GetLastError());
722
724 ok(ret, "CopyFileA: error %d\n", GetLastError());
725
726 /* copying from a read-locked source fails */
728 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
729 retok = CopyFileA(source, dest, FALSE);
731 "copying from a read-locked file succeeded when it shouldn't have\n");
732 /* in addition, the source is opened before the destination */
733 retok = CopyFileA("25f99d3b-4ba4-4f66-88f5-2906886993cc", dest, FALSE);
734 ok(!retok && GetLastError() == ERROR_FILE_NOT_FOUND,
735 "copying from a file that doesn't exist failed in an unexpected way (ret=%d, err=%d)\n", retok, GetLastError());
736 CloseHandle(hfile);
737
738 /* copying from a r+w opened, r shared source succeeds */
740 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
741 retok = CopyFileA(source, dest, FALSE);
742 ok(retok,
743 "copying from an r+w opened and r shared file failed (ret=%d, err=%d)\n", retok, GetLastError());
744 CloseHandle(hfile);
745
746 /* copying from a delete-locked source mostly succeeds */
748 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
749 retok = CopyFileA(source, dest, FALSE);
750 ok(retok || broken(!retok && GetLastError() == ERROR_SHARING_VIOLATION) /* NT, 2000, XP */,
751 "copying from a delete-locked file failed (ret=%d, err=%d)\n", retok, GetLastError());
752 CloseHandle(hfile);
753
754 /* copying to a write-locked destination fails */
756 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
757 retok = CopyFileA(source, dest, FALSE);
759 "copying to a write-locked file didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
760 CloseHandle(hfile);
761
762 /* copying to a r+w opened, w shared destination mostly succeeds */
764 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
765 retok = CopyFileA(source, dest, FALSE);
766 ok(retok || broken(!retok && GetLastError() == ERROR_SHARING_VIOLATION) /* Win 9x */,
767 "copying to a r+w opened and w shared file failed (ret=%d, err=%d)\n", retok, GetLastError());
768 CloseHandle(hfile);
769
770 /* copying to a delete-locked destination fails, even when the destination is delete-shared */
773 "failed to open destination file, error %d\n", GetLastError());
774 if (hfile != INVALID_HANDLE_VALUE)
775 {
776 retok = CopyFileA(source, dest, FALSE);
778 "copying to a delete-locked shared file didn't fail (ret=%d, err=%d)\n", retok, GetLastError());
779 CloseHandle(hfile);
780 }
781
782 /* copy to a file that's opened the way Wine opens the source */
784 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
785 retok = CopyFileA(source, dest, FALSE);
786 ok(retok || broken(GetLastError() == ERROR_SHARING_VIOLATION) /* Win 9x */,
787 "copying to a file opened the way Wine opens the source failed (ret=%d, err=%d)\n", retok, GetLastError());
788 CloseHandle(hfile);
789
790 /* make sure that destination has correct size */
792 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
793 ret = GetFileSize(hfile, NULL);
794 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
795
796 /* make sure that destination has the same filetime */
797 ret = GetFileTime(hfile, NULL, NULL, &ft2);
798 ok( ret, "GetFileTime error %d\n", GetLastError());
799 ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
800
801 SetLastError(0xdeadbeef);
804 "CopyFileA: ret = %d, unexpected error %d\n", ret, GetLastError());
805
806 /* make sure that destination still has correct size */
807 ret = GetFileSize(hfile, NULL);
808 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
809 retok = ReadFile(hfile, buf, sizeof(buf), &ret, NULL);
810 ok( retok && ret == sizeof(prefix),
811 "ReadFile: error %d\n", GetLastError());
812 ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
813
814 /* check error on copying over a mapped file that was opened with FILE_SHARE_READ */
815 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
816 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
817
820 "CopyFileA with mapped dest file: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
821
822 CloseHandle(hmapfile);
823 CloseHandle(hfile);
824
826 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
827
828 /* check error on copying over a mapped file that was opened with FILE_SHARE_WRITE */
829 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
830 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
831
833 ok(!ret, "CopyFileA: expected failure\n");
836 "CopyFileA with mapped dest file: expected ERROR_USER_MAPPED_FILE, got %d\n", GetLastError());
837
838 CloseHandle(hmapfile);
839 CloseHandle(hfile);
840
842 ok(ret, "DeleteFileA: error %d\n", GetLastError());
844 ok(ret, "DeleteFileA: error %d\n", GetLastError());
845}
846
847static void test_CopyFileW(void)
848{
851 static const WCHAR prefix[] = {'p','f','x',0};
852 DWORD ret;
853
856 {
857 win_skip("GetTempPathW is not available\n");
858 return;
859 }
860 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
861 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
862
863 ret = GetTempFileNameW(temp_path, prefix, 0, source);
864 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
865
866 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
867 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
868
871 "CopyFileW: unexpected error %d\n", GetLastError());
872
874 ok(ret, "CopyFileW: error %d\n", GetLastError());
875
877 ok(ret, "DeleteFileW: error %d\n", GetLastError());
879 ok(ret, "DeleteFileW: error %d\n", GetLastError());
880}
881
882static void test_CopyFile2(void)
883{
884 static const WCHAR doesntexistW[] = {'d','o','e','s','n','t','e','x','i','s','t',0};
885 static const WCHAR prefix[] = {'p','f','x',0};
887 COPYFILE2_EXTENDED_PARAMETERS params;
888 HANDLE hfile, hmapfile;
889 FILETIME ft1, ft2;
890 DWORD ret, len;
891 char buf[10];
892 HRESULT hr;
893
894 if (!pCopyFile2)
895 {
896 skip("CopyFile2 is not available\n");
897 return;
898 }
899
901 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
902 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
903
904 ret = GetTempFileNameW(temp_path, prefix, 0, source);
905 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
906
907 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
908 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
909
910 /* fail if exists */
911 memset(&params, 0, sizeof(params));
912 params.dwSize = sizeof(params);
913 params.dwCopyFlags = COPY_FILE_FAIL_IF_EXISTS;
914
915 SetLastError(0xdeadbeef);
916 hr = pCopyFile2(source, dest, &params);
917 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "CopyFile2: unexpected error 0x%08x\n", hr);
918 ok(GetLastError() == ERROR_FILE_EXISTS, "CopyFile2: last error %d\n", GetLastError());
919
920 /* don't fail if exists */
921 params.dwSize = sizeof(params);
922 params.dwCopyFlags = 0;
923
924 hr = pCopyFile2(source, dest, &params);
925 ok(hr == S_OK, "CopyFile2: error 0x%08x\n", hr);
926
927 /* copying a file to itself must fail */
928 params.dwSize = sizeof(params);
929 params.dwCopyFlags = 0;
930
931 SetLastError(0xdeadbeef);
932 hr = pCopyFile2(source, source, &params);
933 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: copying a file to itself didn't fail, 0x%08x\n", hr);
934 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
935
936 /* make the source have not zero size */
937 hfile = CreateFileW(source, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
938 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
939 ret = WriteFile(hfile, prefix, sizeof(prefix), &len, NULL );
940 ok(ret && len == sizeof(prefix), "WriteFile error %d\n", GetLastError());
941 ok(GetFileSize(hfile, NULL) == sizeof(prefix), "source file has wrong size\n");
942
943 /* get the file time and change it to prove the difference */
944 ret = GetFileTime(hfile, NULL, NULL, &ft1);
945 ok(ret, "GetFileTime error %d\n", GetLastError());
946 ft1.dwLowDateTime -= 600000000; /* 60 second */
947 ret = SetFileTime(hfile, NULL, NULL, &ft1);
948 ok(ret, "SetFileTime error %d\n", GetLastError());
949 GetFileTime(hfile, NULL, NULL, &ft1); /* get the actual time back */
950 CloseHandle(hfile);
951
952 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
953 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
954
955 params.dwSize = sizeof(params);
956 params.dwCopyFlags = COPY_FILE_FAIL_IF_EXISTS;
957
958 SetLastError(0xdeadbeef);
959 hr = pCopyFile2(source, dest, &params);
960 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_EXISTS), "CopyFile2: unexpected error 0x%08x\n", hr);
961 ok(GetLastError() == ERROR_FILE_EXISTS, "CopyFile2: last error %d\n", GetLastError());
962
963 params.dwSize = sizeof(params);
964 params.dwCopyFlags = 0;
965 hr = pCopyFile2(source, dest, &params);
966 ok(ret, "CopyFile2: error 0x%08x\n", hr);
967
968 /* copying from a read-locked source fails */
970 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
971
972 params.dwSize = sizeof(params);
973 params.dwCopyFlags = 0;
974 SetLastError(0xdeadbeef);
975 hr = pCopyFile2(source, dest, &params);
976 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
977 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
978
979 /* in addition, the source is opened before the destination */
980 params.dwSize = sizeof(params);
981 params.dwCopyFlags = 0;
982 SetLastError(0xdeadbeef);
983 hr = pCopyFile2(doesntexistW, dest, &params);
984 ok(hr == HRESULT_FROM_WIN32(ERROR_FILE_NOT_FOUND), "got 0x%08x\n", hr);
985 ok(GetLastError() == ERROR_FILE_NOT_FOUND, "CopyFile2: last error %d\n", GetLastError());
986 CloseHandle(hfile);
987
988 /* copying from a r+w opened, r shared source succeeds */
990 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
991
992 params.dwSize = sizeof(params);
993 params.dwCopyFlags = 0;
994 hr = pCopyFile2(source, dest, &params);
995 ok(hr == S_OK, "failed 0x%08x\n", hr);
996 CloseHandle(hfile);
997
998 /* copying from a delete-locked source mostly succeeds */
1000 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file, error %d\n", GetLastError());
1001
1002 params.dwSize = sizeof(params);
1003 params.dwCopyFlags = 0;
1004 hr = pCopyFile2(source, dest, &params);
1005 ok(hr == S_OK, "failed 0x%08x\n", hr);
1006 CloseHandle(hfile);
1007
1008 /* copying to a write-locked destination fails */
1010 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1011
1012 params.dwSize = sizeof(params);
1013 params.dwCopyFlags = 0;
1014 SetLastError(0xdeadbeef);
1015 hr = pCopyFile2(source, dest, FALSE);
1016 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1017 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1018 CloseHandle(hfile);
1019
1020 /* copying to a r+w opened, w shared destination mostly succeeds */
1022 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1023
1024 params.dwSize = sizeof(params);
1025 params.dwCopyFlags = 0;
1026 hr = pCopyFile2(source, dest, FALSE);
1027 ok(hr == S_OK, "got 0x%08x\n", hr);
1028 CloseHandle(hfile);
1029
1030 /* copying to a delete-locked destination fails, even when the destination is delete-shared */
1032 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1033
1034 params.dwSize = sizeof(params);
1035 params.dwCopyFlags = 0;
1036 SetLastError(0xdeadbeef);
1037 hr = pCopyFile2(source, dest, &params);
1038 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1039 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1040 CloseHandle(hfile);
1041
1042 /* copy to a file that's opened the way Wine opens the source */
1044 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1045
1046 params.dwSize = sizeof(params);
1047 params.dwCopyFlags = 0;
1048 hr = pCopyFile2(source, dest, &params);
1049 ok(hr == S_OK, "got 0x%08x\n", hr);
1050 CloseHandle(hfile);
1051
1052 /* make sure that destination has correct size */
1054 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
1055 ret = GetFileSize(hfile, NULL);
1056 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
1057
1058 /* make sure that destination has the same filetime */
1059 ret = GetFileTime(hfile, NULL, NULL, &ft2);
1060 ok(ret, "GetFileTime error %d\n", GetLastError());
1061 ok(CompareFileTime(&ft1, &ft2) == 0, "destination file has wrong filetime\n");
1062
1063 params.dwSize = sizeof(params);
1064 params.dwCopyFlags = 0;
1065 SetLastError(0xdeadbeef);
1066 hr = pCopyFile2(source, dest, &params);
1067 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1068 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1069
1070 /* make sure that destination still has correct size */
1071 ret = GetFileSize(hfile, NULL);
1072 ok(ret == sizeof(prefix), "destination file has wrong size %d\n", ret);
1073 ret = ReadFile(hfile, buf, sizeof(buf), &len, NULL);
1074 ok(ret && len == sizeof(prefix), "ReadFile: error %d\n", GetLastError());
1075 ok(!memcmp(prefix, buf, sizeof(prefix)), "buffer contents mismatch\n");
1076
1077 /* check error on copying over a mapped file that was opened with FILE_SHARE_READ */
1078 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1079 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1080
1081 params.dwSize = sizeof(params);
1082 params.dwCopyFlags = 0;
1083 SetLastError(0xdeadbeef);
1084 hr = pCopyFile2(source, dest, &params);
1085 ok(hr == HRESULT_FROM_WIN32(ERROR_SHARING_VIOLATION), "CopyFile2: unexpected error 0x%08x\n", hr);
1086 ok(GetLastError() == ERROR_SHARING_VIOLATION, "CopyFile2: last error %d\n", GetLastError());
1087
1088 CloseHandle(hmapfile);
1089 CloseHandle(hfile);
1090
1092 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file\n");
1093
1094 /* check error on copying over a mapped file that was opened with FILE_SHARE_WRITE */
1095 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1096 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1097
1098 params.dwSize = sizeof(params);
1099 params.dwCopyFlags = 0;
1100 hr = pCopyFile2(source, dest, &params);
1101 ok(hr == HRESULT_FROM_WIN32(ERROR_USER_MAPPED_FILE), "CopyFile2: unexpected error 0x%08x\n", hr);
1102 ok(GetLastError() == ERROR_USER_MAPPED_FILE, "CopyFile2: last error %d\n", GetLastError());
1103
1104 CloseHandle(hmapfile);
1105 CloseHandle(hfile);
1106
1109}
1110
1111static DWORD WINAPI copy_progress_cb(LARGE_INTEGER total_size, LARGE_INTEGER total_transferred,
1112 LARGE_INTEGER stream_size, LARGE_INTEGER stream_transferred,
1114{
1115 ok(reason == CALLBACK_STREAM_SWITCH, "expected CALLBACK_STREAM_SWITCH, got %u\n", reason);
1116 CloseHandle(userdata);
1117 return PROGRESS_CANCEL;
1118}
1119
1120static void test_CopyFileEx(void)
1121{
1122 char temp_path[MAX_PATH];
1123 char source[MAX_PATH], dest[MAX_PATH];
1124 static const char prefix[] = "pfx";
1125 HANDLE hfile;
1126 DWORD ret;
1127 BOOL retok;
1128
1130 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1131 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1132
1133 ret = GetTempFileNameA(temp_path, prefix, 0, source);
1134 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1135
1136 ret = GetTempFileNameA(temp_path, prefix, 0, dest);
1137 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1138
1140 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1141 SetLastError(0xdeadbeef);
1142 retok = CopyFileExA(source, dest, copy_progress_cb, hfile, NULL, 0);
1143 ok(!retok, "CopyFileExA unexpectedly succeeded\n");
1144 ok(GetLastError() == ERROR_REQUEST_ABORTED, "expected ERROR_REQUEST_ABORTED, got %d\n", GetLastError());
1145 ok(GetFileAttributesA(dest) != INVALID_FILE_ATTRIBUTES, "file was deleted\n");
1146
1148 NULL, OPEN_EXISTING, 0, 0);
1149 ok(hfile != INVALID_HANDLE_VALUE, "failed to open destination file, error %d\n", GetLastError());
1150 SetLastError(0xdeadbeef);
1151 retok = CopyFileExA(source, dest, copy_progress_cb, hfile, NULL, 0);
1152 ok(!retok, "CopyFileExA unexpectedly succeeded\n");
1153 ok(GetLastError() == ERROR_REQUEST_ABORTED, "expected ERROR_REQUEST_ABORTED, got %d\n", GetLastError());
1154 ok(GetFileAttributesA(dest) == INVALID_FILE_ATTRIBUTES, "file was not deleted\n");
1155
1157 ok(ret, "DeleteFileA failed with error %d\n", GetLastError());
1158 ret = DeleteFileA(dest);
1159 ok(!ret, "DeleteFileA unexpectedly succeeded\n");
1160}
1161
1162/*
1163 * Debugging routine to dump a buffer in a hexdump-like fashion.
1164 */
1165static void dumpmem(unsigned char *mem, int len)
1166{
1167 int x = 0;
1168 char hex[49], *p;
1169 char txt[17], *c;
1170
1171 while (x < len)
1172 {
1173 p = hex;
1174 c = txt;
1175 do {
1176 p += sprintf(p, "%02x ", mem[x]);
1177 *c++ = (mem[x] >= 32 && mem[x] <= 127) ? mem[x] : '.';
1178 } while (++x % 16 && x < len);
1179 *c = '\0';
1180 trace("%04x: %-48s- %s\n", x, hex, txt);
1181 }
1182}
1183
1184static void test_CreateFileA(void)
1185{
1186 HANDLE hFile;
1188 char filename[MAX_PATH];
1189 static const char prefix[] = "pfx";
1190 char windowsdir[MAX_PATH];
1191 char Volume_1[MAX_PATH];
1192 unsigned char buffer[512];
1193 char directory[] = "removeme";
1194 static const char nt_drive[] = "\\\\?\\A:";
1195 DWORD i, ret, len;
1196 static const struct test_list p[] =
1197 {
1198 {"", ERROR_PATH_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* dir as file w \ */
1200 {"a", ERROR_FILE_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, FALSE }, /* non-exist file */
1202 {"removeme", ERROR_ACCESS_DENIED, -1, FILE_ATTRIBUTE_NORMAL, FALSE }, /* exist dir w/o \ */
1203 {"removeme\\", ERROR_PATH_NOT_FOUND, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* exst dir w \ */
1204 {"c:", ERROR_ACCESS_DENIED, ERROR_PATH_NOT_FOUND, FILE_ATTRIBUTE_NORMAL, FALSE }, /* device in file namespace */
1205 {"c:", ERROR_SUCCESS, ERROR_PATH_NOT_FOUND, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* device in file namespace as dir */
1206 {"c:\\", ERROR_PATH_NOT_FOUND, ERROR_ACCESS_DENIED, FILE_ATTRIBUTE_NORMAL, TRUE }, /* root dir w \ */
1207 {"c:\\", ERROR_SUCCESS, ERROR_ACCESS_DENIED, FILE_FLAG_BACKUP_SEMANTICS, FALSE }, /* root dir w \ as dir */
1208 {"c:c:\\windows", ERROR_INVALID_NAME, -1, FILE_ATTRIBUTE_NORMAL, TRUE }, /* invalid path */
1209 {"\\\\?\\c:", ERROR_SUCCESS, ERROR_BAD_NETPATH, FILE_ATTRIBUTE_NORMAL,FALSE }, /* dev namespace drive */
1210 {"\\\\?\\c:\\", ERROR_PATH_NOT_FOUND, ERROR_BAD_NETPATH, FILE_ATTRIBUTE_NORMAL, TRUE }, /* dev namespace drive w \ */
1211 {NULL, 0, -1, 0, FALSE}
1212 };
1214 WCHAR curdir[MAX_PATH];
1215
1217 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1218 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1219
1220 ret = GetTempFileNameA(temp_path, prefix, 0, filename);
1221 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1222
1223 SetLastError(0xdeadbeef);
1227 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1228
1229 SetLastError(0xdeadbeef);
1233 "hFile %p, last error %u\n", hFile, GetLastError());
1234
1236
1237 SetLastError(0xdeadbeef);
1241 "hFile %p, last error %u\n", hFile, GetLastError());
1242
1244
1246 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1247
1248 SetLastError(0xdeadbeef);
1252 "hFile %p, last error %u\n", hFile, GetLastError());
1253
1255
1257 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1258
1259 SetLastError(0xdeadbeef);
1261 ok(hFile == INVALID_HANDLE_VALUE, "hFile should have been INVALID_HANDLE_VALUE\n");
1263 broken(GetLastError() == ERROR_FILE_NOT_FOUND), /* Win98 */
1264 "LastError should have been ERROR_INVALID_NAME or ERROR_FILE_NOT_FOUND but got %u\n", GetLastError());
1265
1266 /* get windows drive letter */
1267 ret = GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
1268 ok(ret < sizeof(windowsdir), "windowsdir is abnormally long!\n");
1269 ok(ret != 0, "GetWindowsDirectory: error %d\n", GetLastError());
1270
1271 /* test error return codes from CreateFile for some cases */
1273 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1277 ok( ret, "Createdirectory failed, gle=%d\n", GetLastError() );
1278 /* set current drive & directory to known location */
1281 i = 0;
1282 while (p[i].file)
1283 {
1284 filename[0] = 0;
1285 /* update the drive id in the table entry with the current one */
1286 if (p[i].file[1] == ':')
1287 {
1288 strcpy(filename, p[i].file);
1289 filename[0] = windowsdir[0];
1290 }
1291 else if (p[i].file[0] == '\\' && p[i].file[5] == ':')
1292 {
1293 strcpy(filename, p[i].file);
1294 filename[4] = windowsdir[0];
1295 }
1296 else
1297 {
1298 /* prefix the table entry with the current temp directory */
1300 strcat(filename, p[i].file);
1301 }
1305 p[i].options, NULL );
1306 /* if we get ACCESS_DENIED when we do not expect it, assume
1307 * no access to the volume
1308 */
1309 if (hFile == INVALID_HANDLE_VALUE &&
1312 {
1313 if (p[i].todo_flag)
1314 skip("Either no authority to volume, or is todo_wine for %s err=%d should be %d\n", filename, GetLastError(), p[i].err);
1315 else
1316 skip("Do not have authority to access volumes. Test for %s skipped\n", filename);
1317 }
1318 /* otherwise validate results with expectations */
1319 else
1320 {
1323 (p[i].err == GetLastError() || p[i].err2 == GetLastError())) ||
1325 "CreateFileA failed on %s, hFile %p, err=%u, should be %u\n",
1327 }
1329 CloseHandle( hFile );
1330 i++;
1331 }
1333 ok(ret, "RemoveDirectoryA: error %d\n", GetLastError());
1334 SetCurrentDirectoryW(curdir);
1335
1336 /* test opening directory as a directory */
1339 NULL,
1343 {
1345 "CreateFileA did not work, last error %u on volume <%s>\n",
1347
1349 {
1351 if (ret)
1352 {
1354 "CreateFileA probably did not open temp directory %s correctly\n file information does not include FILE_ATTRIBUTE_DIRECTORY, actual=0x%08x\n",
1356 }
1357 CloseHandle( hFile );
1358 }
1359 }
1360 else
1361 skip("Probable Win9x, got ERROR_PATH_NOT_FOUND w/ FILE_FLAG_BACKUP_SEMANTICS or %s\n", temp_path);
1362
1363
1364 /* *** Test opening volumes/devices using drive letter *** */
1365
1366 /* test using drive letter in non-rewrite format without trailing \ */
1367 /* this should work */
1368 strcpy(filename, nt_drive);
1369 filename[4] = windowsdir[0];
1374 if (hFile != INVALID_HANDLE_VALUE ||
1376 {
1377 /* if we have adm rights to volume, then try rest of tests */
1378 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1381 {
1382 /* if we opened the volume/device, try to read it. Since it */
1383 /* opened, we should be able to read it. We don't care about*/
1384 /* what the data is at this time. */
1385 len = 512;
1386 ret = ReadFile( hFile, buffer, len, &len, NULL );
1387 todo_wine ok(ret, "Failed to read volume, last error %u, %u, for %s\n",
1389 if (ret)
1390 {
1391 trace("buffer is\n");
1392 dumpmem(buffer, 64);
1393 }
1394 CloseHandle( hFile );
1395 }
1396
1397 /* test using drive letter with trailing \ and in non-rewrite */
1398 /* this should not work */
1399 strcpy(filename, nt_drive);
1400 filename[4] = windowsdir[0];
1401 strcat( filename, "\\" );
1406 todo_wine
1408 "CreateFileA should have returned ERROR_PATH_NOT_FOUND on %s, but got %u\n",
1411 CloseHandle( hFile );
1412
1413 /* test using temp path with trailing \ and in non-rewrite as dir */
1414 /* this should work */
1415 strcpy(filename, nt_drive);
1416 filename[4] = 0;
1423 "CreateFileA should have worked on %s, but got %u\n",
1426 CloseHandle( hFile );
1427
1428 /* test using drive letter without trailing \ and in device ns */
1429 /* this should work */
1430 strcpy(filename, nt_drive);
1431 filename[4] = windowsdir[0];
1432 filename[2] = '.';
1437 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1440 CloseHandle( hFile );
1441 }
1442 /* If we see ERROR_BAD_NETPATH then on Win9x or WinME, so skip */
1443 else if (GetLastError() == ERROR_BAD_NETPATH)
1444 skip("Probable Win9x, got ERROR_BAD_NETPATH (53)\n");
1445 else
1446 skip("Do not have authority to access volumes. Tests skipped\n");
1447
1448
1449 /* *** Test opening volumes/devices using GUID *** */
1450
1451 if (pGetVolumeNameForVolumeMountPointA)
1452 {
1453 strcpy(filename, "c:\\");
1454 filename[0] = windowsdir[0];
1455 ret = pGetVolumeNameForVolumeMountPointA( filename, Volume_1, MAX_PATH );
1456 ok(ret, "GetVolumeNameForVolumeMountPointA failed, for %s, last error=%d\n", filename, GetLastError());
1457 if (ret)
1458 {
1459 ok(strlen(Volume_1) == 49, "GetVolumeNameForVolumeMountPointA returned wrong length name <%s>\n", Volume_1);
1460
1461 /* test the result of opening a unique volume name (GUID)
1462 * with the trailing \
1463 * this should error out
1464 */
1465 strcpy(filename, Volume_1);
1470 todo_wine
1472 "CreateFileA should not have opened %s, hFile %p\n",
1473 filename, hFile);
1474 todo_wine
1476 "CreateFileA should have returned ERROR_PATH_NOT_FOUND on %s, but got %u\n",
1479 CloseHandle( hFile );
1480
1481 /* test the result of opening a unique volume name (GUID)
1482 * with the temp path string as dir
1483 * this should work
1484 */
1485 strcpy(filename, Volume_1);
1491 todo_wine
1493 "CreateFileA should have opened %s, but got %u\n",
1496 CloseHandle( hFile );
1497
1498 /* test the result of opening a unique volume name (GUID)
1499 * without the trailing \ and in device namespace
1500 * this should work
1501 */
1502 strcpy(filename, Volume_1);
1503 filename[2] = '.';
1504 filename[48] = 0;
1510 {
1511 /* if we have adm rights to volume, then try rest of tests */
1512 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA did not open %s, last error=%u\n",
1515 {
1516 /* if we opened the volume/device, try to read it. Since it */
1517 /* opened, we should be able to read it. We don't care about*/
1518 /* what the data is at this time. */
1519 len = 512;
1520 ret = ReadFile( hFile, buffer, len, &len, NULL );
1521 todo_wine ok(ret, "Failed to read volume, last error %u, %u, for %s\n",
1523 if (ret)
1524 {
1525 trace("buffer is\n");
1526 dumpmem(buffer, 64);
1527 }
1528 CloseHandle( hFile );
1529 }
1530 }
1531 else
1532 skip("Do not have authority to access volumes. Tests skipped\n");
1533 }
1534 else
1535 win_skip("GetVolumeNameForVolumeMountPointA not functioning\n");
1536 }
1537 else
1538 win_skip("GetVolumeNameForVolumeMountPointA not found\n");
1539}
1540
1541static void test_CreateFileW(void)
1542{
1543 HANDLE hFile;
1546 static const WCHAR emptyW[]={'\0'};
1547 static const WCHAR prefix[] = {'p','f','x',0};
1548 static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
1549 DWORD ret;
1550
1553 {
1554 win_skip("GetTempPathW is not available\n");
1555 return;
1556 }
1557 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1558 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1559
1560 ret = GetTempFileNameW(temp_path, prefix, 0, filename);
1561 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1562
1563 SetLastError(0xdeadbeef);
1567 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1568
1569 SetLastError(0xdeadbeef);
1573 "hFile %p, last error %u\n", hFile, GetLastError());
1574
1576
1577 SetLastError(0xdeadbeef);
1581 "hFile %p, last error %u\n", hFile, GetLastError());
1582
1584
1586 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1587
1588 SetLastError(0xdeadbeef);
1592 "hFile %p, last error %u\n", hFile, GetLastError());
1593
1595
1597 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1598
1599 if (0)
1600 {
1601 /* this crashes on NT4.0 */
1605 "CreateFileW(NULL) returned ret=%p error=%u\n",hFile,GetLastError());
1606 }
1607
1611 "CreateFileW(\"\") returned ret=%p error=%d\n",hFile,GetLastError());
1612
1613 /* test the result of opening a nonexistent driver name */
1617 "CreateFileW on invalid VxD name returned ret=%p error=%d\n",hFile,GetLastError());
1618
1620 ok(ret == TRUE, "couldn't create temporary directory\n");
1624 "expected CreateFile to succeed on existing directory, error: %d\n", GetLastError());
1627 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1628}
1629
1630static void test_CreateFile2(void)
1631{
1632 HANDLE hFile;
1636 static const WCHAR emptyW[]={'\0'};
1637 static const WCHAR prefix[] = {'p','f','x',0};
1638 static const WCHAR bogus[] = { '\\', '\\', '.', '\\', 'B', 'O', 'G', 'U', 'S', 0 };
1639 DWORD ret;
1640
1641 if (!pCreateFile2)
1642 {
1643 win_skip("CreateFile2 is missing\n");
1644 return;
1645 }
1646
1648 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1649 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1650
1651 ret = GetTempFileNameW(temp_path, prefix, 0, filename);
1652 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1653
1654 SetLastError(0xdeadbeef);
1655 exparams.dwSize = sizeof(exparams);
1657 exparams.dwFileFlags = 0;
1658 exparams.dwSecurityQosFlags = 0;
1659 exparams.lpSecurityAttributes = NULL;
1660 exparams.hTemplateFile = 0;
1661 hFile = pCreateFile2(filename, GENERIC_READ, 0, CREATE_NEW, &exparams);
1663 "CREATE_NEW should fail if file exists and last error value should be ERROR_FILE_EXISTS\n");
1664
1665 SetLastError(0xdeadbeef);
1666 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, CREATE_ALWAYS, &exparams);
1668 "hFile %p, last error %u\n", hFile, GetLastError());
1670
1671 SetLastError(0xdeadbeef);
1672 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, OPEN_ALWAYS, &exparams);
1674 "hFile %p, last error %u\n", hFile, GetLastError());
1676
1678 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1679
1680 SetLastError(0xdeadbeef);
1681 hFile = pCreateFile2(filename, GENERIC_READ, FILE_SHARE_READ, OPEN_ALWAYS, &exparams);
1683 "hFile %p, last error %u\n", hFile, GetLastError());
1685
1687 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1688
1689 hFile = pCreateFile2(emptyW, GENERIC_READ, 0, CREATE_NEW, &exparams);
1691 "CreateFile2(\"\") returned ret=%p error=%d\n",hFile,GetLastError());
1692
1693 /* test the result of opening a nonexistent driver name */
1695 hFile = pCreateFile2(bogus, 0, FILE_SHARE_READ | FILE_SHARE_WRITE, OPEN_EXISTING, &exparams);
1697 "CreateFile2 on invalid VxD name returned ret=%p error=%d\n",hFile,GetLastError());
1698
1700 ok(ret == TRUE, "couldn't create temporary directory\n");
1702 hFile = pCreateFile2(filename, GENERIC_READ | GENERIC_WRITE, 0, OPEN_ALWAYS, &exparams);
1703 todo_wine
1705 "expected CreateFile2 to fail on existing directory, error: %d\n", GetLastError());
1708 ok(ret, "DeleteFileW: error %d\n", GetLastError());
1709}
1710
1711static void test_GetTempFileNameA(void)
1712{
1713 UINT result;
1714 char out[MAX_PATH];
1715 char expected[MAX_PATH + 10];
1716 char windowsdir[MAX_PATH + 10];
1717 char windowsdrive[3];
1718
1719 result = GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
1720 ok(result < sizeof(windowsdir), "windowsdir is abnormally long!\n");
1721 ok(result != 0, "GetWindowsDirectory: error %d\n", GetLastError());
1722
1723 /* If the Windows directory is the root directory, it ends in backslash, not else. */
1724 if (strlen(windowsdir) != 3) /* As in "C:\" or "F:\" */
1725 {
1726 strcat(windowsdir, "\\");
1727 }
1728
1729 windowsdrive[0] = windowsdir[0];
1730 windowsdrive[1] = windowsdir[1];
1731 windowsdrive[2] = '\0';
1732
1733 result = GetTempFileNameA(windowsdrive, "abc", 1, out);
1734 ok(result != 0, "GetTempFileNameA: error %d\n", GetLastError());
1735 ok(((out[0] == windowsdrive[0]) && (out[1] == ':')) && (out[2] == '\\'),
1736 "GetTempFileNameA: first three characters should be %c:\\, string was actually %s\n",
1737 windowsdrive[0], out);
1738
1739 result = GetTempFileNameA(windowsdir, "abc", 2, out);
1740 ok(result != 0, "GetTempFileNameA: error %d\n", GetLastError());
1741 expected[0] = '\0';
1742 strcat(expected, windowsdir);
1743 strcat(expected, "abc2.tmp");
1744 ok(lstrcmpiA(out, expected) == 0, "GetTempFileNameA: Unexpected output \"%s\" vs \"%s\"\n",
1745 out, expected);
1746}
1747
1748static void test_DeleteFileA( void )
1749{
1750 BOOL ret;
1752 HANDLE hfile;
1753
1754 ret = DeleteFileA(NULL);
1757 "DeleteFileA(NULL) returned ret=%d error=%d\n",ret,GetLastError());
1758
1759 ret = DeleteFileA("");
1762 "DeleteFileA(\"\") returned ret=%d error=%d\n",ret,GetLastError());
1763
1764 ret = DeleteFileA("nul");
1769 "DeleteFileA(\"nul\") returned ret=%d error=%d\n",ret,GetLastError());
1770
1771 ret = DeleteFileA("nonexist.txt");
1772 ok(!ret && GetLastError() == ERROR_FILE_NOT_FOUND, "DeleteFileA(\"nonexist.txt\") returned ret=%d error=%d\n",ret,GetLastError());
1773
1776
1777 SetLastError(0xdeadbeef);
1779 ok(hfile != INVALID_HANDLE_VALUE, "CreateFile error %d\n", GetLastError());
1780
1781 SetLastError(0xdeadbeef);
1783 ok(ret, "DeleteFile error %d\n", GetLastError());
1784
1785 SetLastError(0xdeadbeef);
1786 ret = CloseHandle(hfile);
1787 ok(ret, "CloseHandle error %d\n", GetLastError());
1789 ok(!ret, "DeleteFile should fail\n");
1790
1791 SetLastError(0xdeadbeef);
1792 ret = CreateDirectoryA("testdir", NULL);
1793 ok(ret, "CreateDirectory failed, got err %d\n", GetLastError());
1794 ret = DeleteFileA("testdir");
1796 "Expected ERROR_ACCESS_DENIED, got error %d\n", GetLastError());
1797 ret = RemoveDirectoryA("testdir");
1798 ok(ret, "Remove a directory failed, got error %d\n", GetLastError());
1799}
1800
1801static void test_DeleteFileW( void )
1802{
1803 BOOL ret;
1804 WCHAR pathW[MAX_PATH];
1805 WCHAR pathsubW[MAX_PATH];
1806 static const WCHAR dirW[] = {'d','e','l','e','t','e','f','i','l','e',0};
1807 static const WCHAR subdirW[] = {'\\','s','u','b',0};
1808 static const WCHAR emptyW[]={'\0'};
1809
1810 ret = DeleteFileW(NULL);
1812 {
1813 win_skip("DeleteFileW is not available\n");
1814 return;
1815 }
1817 "DeleteFileW(NULL) returned ret=%d error=%d\n",ret,GetLastError());
1818
1821 "DeleteFileW(\"\") returned ret=%d error=%d\n",ret,GetLastError());
1822
1823 /* test DeleteFile on empty directory */
1824 ret = GetTempPathW(MAX_PATH, pathW);
1825 if (ret + sizeof(dirW)/sizeof(WCHAR)-1 + sizeof(subdirW)/sizeof(WCHAR)-1 >= MAX_PATH)
1826 {
1827 ok(0, "MAX_PATH exceeded in constructing paths\n");
1828 return;
1829 }
1830 lstrcatW(pathW, dirW);
1831 lstrcpyW(pathsubW, pathW);
1832 lstrcatW(pathsubW, subdirW);
1833 ret = CreateDirectoryW(pathW, NULL);
1834 ok(ret == TRUE, "couldn't create directory deletefile\n");
1835 ret = DeleteFileW(pathW);
1836 ok(ret == FALSE, "DeleteFile should fail for empty directories\n");
1837 ret = RemoveDirectoryW(pathW);
1838 ok(ret == TRUE, "expected to remove directory deletefile\n");
1839
1840 /* test DeleteFile on non-empty directory */
1841 ret = CreateDirectoryW(pathW, NULL);
1842 ok(ret == TRUE, "couldn't create directory deletefile\n");
1843 ret = CreateDirectoryW(pathsubW, NULL);
1844 ok(ret == TRUE, "couldn't create directory deletefile\\sub\n");
1845 ret = DeleteFileW(pathW);
1846 ok(ret == FALSE, "DeleteFile should fail for non-empty directories\n");
1847 ret = RemoveDirectoryW(pathsubW);
1848 ok(ret == TRUE, "expected to remove directory deletefile\\sub\n");
1849 ret = RemoveDirectoryW(pathW);
1850 ok(ret == TRUE, "expected to remove directory deletefile\n");
1851}
1852
1853#define IsDotDir(x) ((x[0] == '.') && ((x[1] == 0) || ((x[1] == '.') && (x[2] == 0))))
1854
1855static void test_MoveFileA(void)
1856{
1857 char tempdir[MAX_PATH];
1858 char source[MAX_PATH], dest[MAX_PATH];
1859 static const char prefix[] = "pfx";
1860 HANDLE hfile;
1861 HANDLE hmapfile;
1862 DWORD ret;
1863 BOOL retok;
1864
1865 ret = GetTempPathA(MAX_PATH, tempdir);
1866 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
1867 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1868
1869 ret = GetTempFileNameA(tempdir, prefix, 0, source);
1870 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1871
1872 ret = GetTempFileNameA(tempdir, prefix, 0, dest);
1873 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
1874
1876 ok(ret, "MoveFileA: failed, error %d\n", GetLastError());
1877
1880 "MoveFileA: unexpected error %d\n", GetLastError());
1881
1882 ret = DeleteFileA(dest);
1883 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1884
1886 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
1887
1888 retok = WriteFile(hfile, prefix, sizeof(prefix), &ret, NULL );
1889 ok( retok && ret == sizeof(prefix),
1890 "WriteFile error %d\n", GetLastError());
1891
1892 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1893 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1894
1896 ok(!ret, "MoveFileA: expected failure\n");
1898 broken(GetLastError() == ERROR_ACCESS_DENIED), /* Win9x and WinMe */
1899 "MoveFileA: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
1900
1901 CloseHandle(hmapfile);
1902 CloseHandle(hfile);
1903
1904 /* if MoveFile succeeded, move back to dest */
1905 if (ret) MoveFileA(dest, source);
1906
1908 ok(hfile != INVALID_HANDLE_VALUE, "failed to open source file\n");
1909
1910 hmapfile = CreateFileMappingW(hfile, NULL, PAGE_READONLY | SEC_COMMIT, 0, 0, NULL);
1911 ok(hmapfile != NULL, "CreateFileMapping: error %d\n", GetLastError());
1912
1914 ok(!ret, "MoveFileA: expected failure\n");
1916 broken(GetLastError() == ERROR_ACCESS_DENIED), /* Win9x and WinMe */
1917 "MoveFileA: expected ERROR_SHARING_VIOLATION, got %d\n", GetLastError());
1918
1919 CloseHandle(hmapfile);
1920 CloseHandle(hfile);
1921
1922 /* if MoveFile succeeded, move back to dest */
1923 if (ret) MoveFileA(dest, source);
1924
1926 ok(ret, "MoveFileA: failed, error %d\n", GetLastError());
1927
1928 lstrcatA(tempdir, "Remove Me");
1929 ret = CreateDirectoryA(tempdir, NULL);
1930 ok(ret == TRUE, "CreateDirectoryA failed\n");
1931
1933 lstrcpyA(dest, tempdir);
1934 lstrcatA(dest, "\\wild?.*");
1935 /* FIXME: if we create a file with wildcards we can't delete it now that DeleteFile works correctly */
1937 ok(!ret, "MoveFileA: shouldn't move to wildcard file\n");
1938 ok(GetLastError() == ERROR_INVALID_NAME || /* NT */
1939 GetLastError() == ERROR_FILE_NOT_FOUND, /* Win9x */
1940 "MoveFileA: with wildcards, unexpected error %d\n", GetLastError());
1941 if (ret || (GetLastError() != ERROR_INVALID_NAME))
1942 {
1944 char temppath[MAX_PATH];
1945 HANDLE hFind;
1946
1947 lstrcpyA(temppath, tempdir);
1948 lstrcatA(temppath, "\\*.*");
1949 hFind = FindFirstFileA(temppath, &fd);
1950 if (INVALID_HANDLE_VALUE != hFind)
1951 {
1952 LPSTR lpName;
1953 do
1954 {
1955 lpName = fd.cAlternateFileName;
1956 if (!lpName[0])
1957 lpName = fd.cFileName;
1958 ok(IsDotDir(lpName), "MoveFileA: wildcards file created!\n");
1959 }
1960 while (FindNextFileA(hFind, &fd));
1961 FindClose(hFind);
1962 }
1963 }
1965 ok(ret, "DeleteFileA: error %d\n", GetLastError());
1966 ret = DeleteFileA(dest);
1967 ok(!ret, "DeleteFileA: error %d\n", GetLastError());
1968 ret = RemoveDirectoryA(tempdir);
1969 ok(ret, "DeleteDirectoryA: error %d\n", GetLastError());
1970}
1971
1972static void test_MoveFileW(void)
1973{
1976 static const WCHAR prefix[] = {'p','f','x',0};
1977 DWORD ret;
1978
1981 {
1982 win_skip("GetTempPathW is not available\n");
1983 return;
1984 }
1985 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
1986 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
1987
1988 ret = GetTempFileNameW(temp_path, prefix, 0, source);
1989 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1990
1991 ret = GetTempFileNameW(temp_path, prefix, 0, dest);
1992 ok(ret != 0, "GetTempFileNameW error %d\n", GetLastError());
1993
1996 "CopyFileW: unexpected error %d\n", GetLastError());
1997
1999 ok(ret, "DeleteFileW: error %d\n", GetLastError());
2000 ret = DeleteFileW(dest);
2001 ok(ret, "DeleteFileW: error %d\n", GetLastError());
2002}
2003
2004#define PATTERN_OFFSET 0x10
2005
2007{
2008 HANDLE hFile;
2009 OVERLAPPED ov;
2010 DWORD done, offset;
2011 BOOL rc;
2012 BYTE buf[256], pattern[] = "TeSt";
2013 UINT i;
2014 char temp_path[MAX_PATH], temp_fname[MAX_PATH];
2015 BOOL ret;
2016
2018 ok( ret, "GetTempPathA error %d\n", GetLastError());
2019 ret =GetTempFileNameA(temp_path, "pfx", 0, temp_fname);
2020 ok( ret, "GetTempFileNameA error %d\n", GetLastError());
2021
2022 /*** Write File *****************************************************/
2023
2025 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError());
2026
2027 for(i = 0; i < sizeof(buf); i++) buf[i] = i;
2028 ret = WriteFile(hFile, buf, sizeof(buf), &done, NULL);
2029 ok( ret, "WriteFile error %d\n", GetLastError());
2030 ok(done == sizeof(buf), "expected number of bytes written %u\n", done);
2031
2032 memset(&ov, 0, sizeof(ov));
2033 S(U(ov)).Offset = PATTERN_OFFSET;
2034 S(U(ov)).OffsetHigh = 0;
2035 rc=WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
2036 /* Win 9x does not support the overlapped I/O on files */
2038 ok(rc, "WriteFile error %d\n", GetLastError());
2039 ok(done == sizeof(pattern), "expected number of bytes written %u\n", done);
2041 ok(offset == PATTERN_OFFSET + sizeof(pattern), "wrong file offset %d\n", offset);
2042
2043 S(U(ov)).Offset = sizeof(buf) * 2;
2044 S(U(ov)).OffsetHigh = 0;
2045 ret = WriteFile(hFile, pattern, sizeof(pattern), &done, &ov);
2046 ok( ret, "WriteFile error %d\n", GetLastError());
2047 ok(done == sizeof(pattern), "expected number of bytes written %u\n", done);
2049 ok(offset == sizeof(buf) * 2 + sizeof(pattern), "wrong file offset %d\n", offset);
2050 }
2051
2053
2054 /*** Read File *****************************************************/
2055
2056 hFile = CreateFileA(temp_fname, GENERIC_READ, 0, NULL, OPEN_EXISTING, 0, 0);
2057 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError());
2058
2059 memset(buf, 0, sizeof(buf));
2060 memset(&ov, 0, sizeof(ov));
2061 S(U(ov)).Offset = PATTERN_OFFSET;
2062 S(U(ov)).OffsetHigh = 0;
2063 rc=ReadFile(hFile, buf, sizeof(pattern), &done, &ov);
2064 /* Win 9x does not support the overlapped I/O on files */
2066 ok(rc, "ReadFile error %d\n", GetLastError());
2067 ok(done == sizeof(pattern), "expected number of bytes read %u\n", done);
2069 ok(offset == PATTERN_OFFSET + sizeof(pattern), "wrong file offset %d\n", offset);
2070 ok(!memcmp(buf, pattern, sizeof(pattern)), "pattern match failed\n");
2071 }
2072
2074
2075 ret = DeleteFileA(temp_fname);
2076 ok( ret, "DeleteFileA error %d\n", GetLastError());
2077}
2078
2079static void test_LockFile(void)
2080{
2081 HANDLE handle, handle2;
2082 DWORD written;
2084 int limited_LockFile;
2085 int limited_UnLockFile;
2086 BOOL ret;
2087
2090 CREATE_ALWAYS, 0, 0 );
2092 {
2093 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
2094 return;
2095 }
2098 OPEN_EXISTING, 0, 0 );
2099 if (handle2 == INVALID_HANDLE_VALUE)
2100 {
2101 ok( 0, "couldn't open file \"%s\" (err=%d)\n", filename, GetLastError() );
2102 goto cleanup;
2103 }
2104 ok( WriteFile( handle, sillytext, strlen(sillytext), &written, NULL ), "write failed\n" );
2105
2106 ok( LockFile( handle, 0, 0, 0, 0 ), "LockFile failed\n" );
2107 ok( UnlockFile( handle, 0, 0, 0, 0 ), "UnlockFile failed\n" );
2108
2109 limited_UnLockFile = 0;
2110 if (UnlockFile( handle, 0, 0, 0, 0 ))
2111 {
2112 limited_UnLockFile = 1;
2113 }
2114
2115 ok( LockFile( handle, 10, 0, 20, 0 ), "LockFile 10,20 failed\n" );
2116 /* overlapping locks must fail */
2117 ok( !LockFile( handle, 12, 0, 10, 0 ), "LockFile 12,10 succeeded\n" );
2118 ok( !LockFile( handle, 5, 0, 6, 0 ), "LockFile 5,6 succeeded\n" );
2119 /* non-overlapping locks must succeed */
2120 ok( LockFile( handle, 5, 0, 5, 0 ), "LockFile 5,5 failed\n" );
2121
2122 ok( !UnlockFile( handle, 10, 0, 10, 0 ), "UnlockFile 10,10 succeeded\n" );
2123 ok( UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 failed\n" );
2124 ok( !UnlockFile( handle, 10, 0, 20, 0 ), "UnlockFile 10,20 again succeeded\n" );
2125 ok( UnlockFile( handle, 5, 0, 5, 0 ), "UnlockFile 5,5 failed\n" );
2126
2127 S(U(overlapped)).Offset = 100;
2128 S(U(overlapped)).OffsetHigh = 0;
2129 overlapped.hEvent = 0;
2130
2131 /* Test for broken LockFileEx a la Windows 95 OSR2. */
2132 if (LockFileEx( handle, 0, 0, 100, 0, &overlapped ))
2133 {
2134 /* LockFileEx is probably OK, test it more. */
2135 ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ),
2136 "LockFileEx 100,100 failed\n" );
2137 }
2138
2139 /* overlapping shared locks are OK */
2140 S(U(overlapped)).Offset = 150;
2141 limited_UnLockFile || ok( LockFileEx( handle, 0, 0, 100, 0, &overlapped ), "LockFileEx 150,100 failed\n" );
2142
2143 /* but exclusive is not */
2145 0, 50, 0, &overlapped ),
2146 "LockFileEx exclusive 150,50 succeeded\n" );
2147 if (!UnlockFileEx( handle, 0, 100, 0, &overlapped ))
2148 { /* UnLockFile is capable. */
2149 S(U(overlapped)).Offset = 100;
2150 ok( !UnlockFileEx( handle, 0, 100, 0, &overlapped ),
2151 "UnlockFileEx 150,100 again succeeded\n" );
2152 }
2153
2154 /* shared lock can overlap exclusive if handles are equal */
2155 S(U(overlapped)).Offset = 300;
2157 "LockFileEx exclusive 300,100 failed\n" );
2158 ok( !LockFileEx( handle2, LOCKFILE_FAIL_IMMEDIATELY, 0, 100, 0, &overlapped ),
2159 "LockFileEx handle2 300,100 succeeded\n" );
2161 ok( ret, "LockFileEx 300,100 failed\n" );
2162 ok( UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
2163 /* exclusive lock is removed first */
2164 ok( LockFileEx( handle2, LOCKFILE_FAIL_IMMEDIATELY, 0, 100, 0, &overlapped ),
2165 "LockFileEx handle2 300,100 failed\n" );
2166 ok( UnlockFileEx( handle2, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
2167 if (ret)
2168 ok( UnlockFileEx( handle, 0, 100, 0, &overlapped ), "UnlockFileEx 300,100 failed\n" );
2169
2170 ret = LockFile( handle, 0, 0x10000000, 0, 0xf0000000 );
2171 if (ret)
2172 {
2173 ok( !LockFile( handle, ~0, ~0, 1, 0 ), "LockFile ~0,1 succeeded\n" );
2174 ok( !LockFile( handle, 0, 0x20000000, 20, 0 ), "LockFile 0x20000000,20 succeeded\n" );
2175 ok( UnlockFile( handle, 0, 0x10000000, 0, 0xf0000000 ), "UnlockFile failed\n" );
2176 }
2177 else /* win9x */
2178 ok( GetLastError() == ERROR_INVALID_PARAMETER, "wrong LockFile error %u\n", GetLastError() );
2179
2180 /* wrap-around lock should not do anything */
2181 /* (but still succeeds on NT4 so we don't check result) */
2182 LockFile( handle, 0, 0x10000000, 0, 0xf0000001 );
2183
2184 limited_LockFile = 0;
2185 if (!LockFile( handle, ~0, ~0, 1, 0 ))
2186 {
2187 limited_LockFile = 1;
2188 }
2189
2190 limited_UnLockFile || ok( UnlockFile( handle, ~0, ~0, 1, 0 ), "Unlockfile ~0,1 failed\n" );
2191
2192 /* zero-byte lock */
2193 ok( LockFile( handle, 100, 0, 0, 0 ), "LockFile 100,0 failed\n" );
2194 if (!limited_LockFile) ok( !LockFile( handle, 98, 0, 4, 0 ), "LockFile 98,4 succeeded\n" );
2195 ok( LockFile( handle, 90, 0, 10, 0 ), "LockFile 90,10 failed\n" );
2196 if (!limited_LockFile) ok( !LockFile( handle, 100, 0, 10, 0 ), "LockFile 100,10 failed\n" );
2197
2198 ok( UnlockFile( handle, 90, 0, 10, 0 ), "UnlockFile 90,10 failed\n" );
2199 ok( !UnlockFile( handle, 100, 0, 10, 0 ), "UnlockFile 100,10 succeeded\n" );
2200
2201 ok( UnlockFile( handle, 100, 0, 0, 0 ), "UnlockFile 100,0 failed\n" );
2202
2203 CloseHandle( handle2 );
2204cleanup:
2207}
2208
2210{
2214 BYTE *buffer;
2215 DWORD lfanew = sizeof(*dos);
2216 DWORD size = lfanew + sizeof(*nt) + sizeof(*sec);
2217 DWORD written;
2218 BOOL ret;
2219
2221 if (file == INVALID_HANDLE_VALUE) return FALSE;
2222
2224
2227 dos->e_cblp = sizeof(*dos);
2228 dos->e_cp = 1;
2229 dos->e_cparhdr = lfanew / 16;
2230 dos->e_minalloc = 0;
2231 dos->e_maxalloc = 0xffff;
2232 dos->e_ss = 0x0000;
2233 dos->e_sp = 0x00b8;
2234 dos->e_lfarlc = lfanew;
2235 dos->e_lfanew = lfanew;
2236
2237 nt = (IMAGE_NT_HEADERS *)(buffer + lfanew);
2239#if defined __i386__
2241#elif defined __x86_64__
2243#elif defined __powerpc__
2245#elif defined __arm__
2247#elif defined __aarch64__
2249#else
2250# error You must specify the machine type
2251#endif
2258 nt->OptionalHeader.ImageBase = 0x10000000;
2267 nt->OptionalHeader.SizeOfImage = 0x2000;
2271
2272 sec = (IMAGE_SECTION_HEADER *)(nt + 1);
2273 memcpy( sec->Name, ".rodata", sizeof(".rodata") );
2274 sec->Misc.VirtualSize = 0x1000;
2275 sec->VirtualAddress = 0x1000;
2276 sec->SizeOfRawData = 0;
2277 sec->PointerToRawData = 0;
2279
2280 ret = WriteFile( file, buffer, size, &written, NULL ) && written == size;
2282 CloseHandle( file );
2283 return ret;
2284}
2285
2286static unsigned int map_file_access( unsigned int access )
2287{
2293}
2294
2295static BOOL is_sharing_compatible( DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2 )
2296{
2297 access1 = map_file_access( access1 );
2298 access2 = map_file_access( access2 );
2301
2302 if (!access1) sharing1 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
2303 if (!access2) sharing2 = FILE_SHARE_READ|FILE_SHARE_WRITE|FILE_SHARE_DELETE;
2304
2305 if ((access1 & (FILE_READ_DATA|FILE_EXECUTE)) && !(sharing2 & FILE_SHARE_READ)) return FALSE;
2306 if ((access1 & (FILE_WRITE_DATA|FILE_APPEND_DATA)) && !(sharing2 & FILE_SHARE_WRITE)) return FALSE;
2307 if ((access1 & DELETE) && !(sharing2 & FILE_SHARE_DELETE)) return FALSE;
2308 if ((access2 & (FILE_READ_DATA|FILE_EXECUTE)) && !(sharing1 & FILE_SHARE_READ)) return FALSE;
2309 if ((access2 & (FILE_WRITE_DATA|FILE_APPEND_DATA)) && !(sharing1 & FILE_SHARE_WRITE)) return FALSE;
2310 if ((access2 & DELETE) && !(sharing1 & FILE_SHARE_DELETE)) return FALSE;
2311 return TRUE;
2312}
2313
2314static BOOL is_sharing_map_compatible( DWORD map_access, DWORD access2, DWORD sharing2 )
2315{
2316 if ((map_access == PAGE_READWRITE || map_access == PAGE_EXECUTE_READWRITE) &&
2317 !(sharing2 & FILE_SHARE_WRITE)) return FALSE;
2318 access2 = map_file_access( access2 );
2319 if ((map_access & SEC_IMAGE) && (access2 & FILE_WRITE_DATA)) return FALSE;
2320 return TRUE;
2321}
2322
2323static void test_file_sharing(void)
2324{
2325 struct mode { DWORD dw; const char* str; };
2326#define M(x) {x, # x}
2327 static const struct mode access_modes[] =
2335 static const struct mode sharing_modes[] =
2336 { M(0), M(FILE_SHARE_READ),
2340 static const struct mode mapping_modes[] =
2342#undef M
2343 int a1, s1, a2, s2;
2344 int ret;
2345 HANDLE h, h2;
2346
2347 /* make sure the file exists */
2348 if (!create_fake_dll( filename ))
2349 {
2350 ok(0, "couldn't create file \"%s\" (err=%d)\n", filename, GetLastError());
2351 return;
2352 }
2353
2354 for (a1 = 0; a1 < sizeof(access_modes)/sizeof(access_modes[0]); a1++)
2355 {
2356 for (s1 = 0; s1 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s1++)
2357 {
2358 SetLastError(0xdeadbeef);
2359 h = CreateFileA( filename, access_modes[a1].dw, sharing_modes[s1].dw,
2360 NULL, OPEN_EXISTING, 0, 0 );
2361 if (h == INVALID_HANDLE_VALUE)
2362 {
2363 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
2364 return;
2365 }
2366 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
2367 {
2368 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
2369 {
2370 SetLastError(0xdeadbeef);
2371 h2 = CreateFileA( filename, access_modes[a2].dw, sharing_modes[s2].dw,
2372 NULL, OPEN_EXISTING, 0, 0 );
2373 ret = GetLastError();
2374 if (is_sharing_compatible( access_modes[a1].dw, sharing_modes[s1].dw,
2375 access_modes[a2].dw, sharing_modes[s2].dw ))
2376 {
2377 ok( h2 != INVALID_HANDLE_VALUE,
2378 "open failed for modes %s / %s / %s / %s\n",
2379 access_modes[a1].str, sharing_modes[s1].str,
2380 access_modes[a2].str, sharing_modes[s2].str );
2381 ok( ret == 0, "wrong error code %d\n", ret );
2382 }
2383 else
2384 {
2385 ok( h2 == INVALID_HANDLE_VALUE,
2386 "open succeeded for modes %s / %s / %s / %s\n",
2387 access_modes[a1].str, sharing_modes[s1].str,
2388 access_modes[a2].str, sharing_modes[s2].str );
2390 "wrong error code %d\n", ret );
2391 }
2392 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
2393 }
2394 }
2395 CloseHandle( h );
2396 }
2397 }
2398
2399 for (a1 = 0; a1 < sizeof(mapping_modes)/sizeof(mapping_modes[0]); a1++)
2400 {
2401 HANDLE m;
2402
2404 SetLastError(0xdeadbeef);
2406 if (h == INVALID_HANDLE_VALUE)
2407 {
2408 ok(0,"couldn't create file \"%s\" (err=%d)\n",filename,GetLastError());
2409 return;
2410 }
2411 m = CreateFileMappingA( h, NULL, mapping_modes[a1].dw, 0, 0, NULL );
2412 ok( m != 0, "failed to create mapping %s err %u\n", mapping_modes[a1].str, GetLastError() );
2413 CloseHandle( h );
2414 if (!m) continue;
2415
2416 for (a2 = 0; a2 < sizeof(access_modes)/sizeof(access_modes[0]); a2++)
2417 {
2418 for (s2 = 0; s2 < sizeof(sharing_modes)/sizeof(sharing_modes[0]); s2++)
2419 {
2420 SetLastError(0xdeadbeef);
2421 h2 = CreateFileA( filename, access_modes[a2].dw, sharing_modes[s2].dw,
2422 NULL, OPEN_EXISTING, 0, 0 );
2423
2424 ret = GetLastError();
2425 if (h2 == INVALID_HANDLE_VALUE)
2426 {
2427 ok( !is_sharing_map_compatible(mapping_modes[a1].dw, access_modes[a2].dw, sharing_modes[s2].dw),
2428 "open failed for modes map %s / %s / %s\n",
2429 mapping_modes[a1].str, access_modes[a2].str, sharing_modes[s2].str );
2431 "wrong error code %d\n", ret );
2432 }
2433 else
2434 {
2435 if (!is_sharing_map_compatible(mapping_modes[a1].dw, access_modes[a2].dw, sharing_modes[s2].dw))
2436 ok( broken(1), /* no checking on nt4 */
2437 "open succeeded for modes map %s / %s / %s\n",
2438 mapping_modes[a1].str, access_modes[a2].str, sharing_modes[s2].str );
2439 ok( ret == 0xdeadbeef /* Win9x */ ||
2440 ret == 0, /* XP */
2441 "wrong error code %d\n", ret );
2442 CloseHandle( h2 );
2443 }
2444 }
2445 }
2446
2447 /* try CREATE_ALWAYS over an existing mapping */
2448 SetLastError(0xdeadbeef);
2450 NULL, CREATE_ALWAYS, 0, 0 );
2451 ret = GetLastError();
2452 if (mapping_modes[a1].dw & SEC_IMAGE)
2453 {
2454 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %s\n", mapping_modes[a1].str );
2455 ok( ret == ERROR_SHARING_VIOLATION, "wrong error code %d for %s\n", ret, mapping_modes[a1].str );
2456 }
2457 else
2458 {
2459 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %s\n", mapping_modes[a1].str );
2460 ok( ret == ERROR_USER_MAPPED_FILE, "wrong error code %d for %s\n", ret, mapping_modes[a1].str );
2461 }
2462 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
2463
2464 /* try DELETE_ON_CLOSE over an existing mapping */
2465 SetLastError(0xdeadbeef);
2468 ret = GetLastError();
2469 if (mapping_modes[a1].dw & SEC_IMAGE)
2470 {
2471 ok( h2 == INVALID_HANDLE_VALUE, "create succeeded for map %s\n", mapping_modes[a1].str );
2472 ok( ret == ERROR_ACCESS_DENIED, "wrong error code %d for %s\n", ret, mapping_modes[a1].str );
2473 }
2474 else
2475 {
2476 ok( h2 != INVALID_HANDLE_VALUE, "open failed for map %s err %u\n", mapping_modes[a1].str, ret );
2477 }
2478 if (h2 != INVALID_HANDLE_VALUE) CloseHandle( h2 );
2479
2480 CloseHandle( m );
2481 }
2482
2483 SetLastError(0xdeadbeef);
2485 ok( h != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
2486
2487 SetLastError(0xdeadbeef);
2489 ok( h2 == INVALID_HANDLE_VALUE, "CreateFileA should fail\n");
2490 ok( GetLastError() == ERROR_SHARING_VIOLATION, "wrong error code %d\n", GetLastError() );
2491
2493 ok( h2 != INVALID_HANDLE_VALUE, "CreateFileA error %d\n", GetLastError() );
2494
2495 CloseHandle(h);
2496 CloseHandle(h2);
2497
2499}
2500
2501static char get_windows_drive(void)
2502{
2503 char windowsdir[MAX_PATH];
2504 GetWindowsDirectoryA(windowsdir, sizeof(windowsdir));
2505 return windowsdir[0];
2506}
2507
2508static const struct
2509{
2510 const char *path;
2512}
2514{
2515 { "./test-dir", TRUE },
2516 { "./test-dir/", FALSE },
2517 { ".\\test-dir", TRUE },
2518 { ".\\test-dir\\", FALSE },
2519 { "/>test-dir", FALSE },
2520 { "<\"test->dir", FALSE },
2521 { "<test->dir", FALSE },
2522 { "><test->dir", FALSE },
2523 { ">>test-dir", FALSE },
2524 { ">test->dir", FALSE },
2525 { ">test-dir", FALSE },
2526 { "\"test-dir\"", FALSE },
2527 { "\"test-file\"", FALSE },
2528 { "test-/>dir", FALSE },
2529 { "test-dir/", FALSE },
2530 { "test-dir//", FALSE },
2531 { "test-dir/:", FALSE },
2532 { "test-dir/<", TRUE },
2533 { "test-dir/>", TRUE },
2534 { "test-dir/\"", TRUE },
2535 { "test-dir/\\", FALSE },
2536 { "test-dir/|", FALSE },
2537 { "test-dir<", TRUE },
2538 { "test-dir</", FALSE },
2539 { "test-dir<<", TRUE },
2540 { "test-dir<<<><><>\"\"\"\"<<<>", TRUE },
2541 { "test-dir<>", TRUE },
2542 { "test-dir<\"", TRUE },
2543 { "test-dir>", TRUE },
2544 { "test-dir>/", FALSE },
2545 { "test-dir><", TRUE },
2546 { "test-dir>>", TRUE },
2547 { "test-dir>\"", TRUE },
2548 { "test-dir\"", TRUE },
2549 { "test-dir\"/", FALSE },
2550 { "test-dir\"<", TRUE },
2551 { "test-dir\">", TRUE },
2552 { "test-dir\"\"", TRUE },
2553 { "test-dir\"\"\"\"\"", TRUE },
2554 { "test-dir\\", FALSE },
2555 { "test-dir\\/", FALSE },
2556 { "test-dir\\<", TRUE },
2557 { "test-dir\\>", TRUE },
2558 { "test-dir\\\"", TRUE },
2559 { "test-dir\\\\", FALSE },
2560 { "test-file/", FALSE },
2561 { "test-file/<", FALSE },
2562 { "test-file/>", FALSE },
2563 { "test-file/\"", FALSE },
2564 { "test-file<", TRUE },
2565 { "test-file<<", TRUE },
2566 { "test-file<>", TRUE },
2567 { "test-file<\"", TRUE },
2568 { "test-file>", TRUE },
2569 { "test-file><", TRUE },
2570 { "test-file>>", TRUE },
2571 { "test-file>\"", TRUE },
2572 { "test-file\"", TRUE },
2573 { "test-file\"<", TRUE },
2574 { "test-file\">", TRUE },
2575 { "test-file\"\"", TRUE },
2576 { "test-file\\", FALSE },
2577 { "test-file\\<", FALSE },
2578 { "test-file\\>", FALSE },
2579 { "test-file\\\"", FALSE },
2581
2582static void test_FindFirstFileA(void)
2583{
2584 HANDLE handle;
2586 int err, i;
2587 char buffer[5] = "C:\\";
2588 char buffer2[100];
2589 char nonexistent[MAX_PATH];
2590
2591 /* try FindFirstFileA on "C:\" */
2593
2594 SetLastError( 0xdeadbeaf );
2596 err = GetLastError();
2597 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on root directory should fail\n" );
2598 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2599
2600 /* try FindFirstFileA on "C:\*" */
2601 strcpy(buffer2, buffer);
2602 strcat(buffer2, "*");
2603 handle = FindFirstFileA(buffer2, &data);
2604 ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
2605 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2606 "FindFirstFile shouldn't return '%s' in drive root\n", data.cFileName );
2607 if (FindNextFileA( handle, &data ))
2608 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2609 "FindNextFile shouldn't return '%s' in drive root\n", data.cFileName );
2610 ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
2611
2612 /* try FindFirstFileA on windows dir */
2613 GetWindowsDirectoryA( buffer2, sizeof(buffer2) );
2614 strcat(buffer2, "\\*");
2615 handle = FindFirstFileA(buffer2, &data);
2616 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s should succeed\n", buffer2 );
2617 ok( !strcmp( data.cFileName, "." ), "FindFirstFile should return '.' first\n" );
2618 ok( FindNextFileA( handle, &data ), "FindNextFile failed\n" );
2619 ok( !strcmp( data.cFileName, ".." ), "FindNextFile should return '..' as second entry\n" );
2620 while (FindNextFileA( handle, &data ))
2621 ok ( strcmp( data.cFileName, "." ) && strcmp( data.cFileName, ".." ),
2622 "FindNextFile shouldn't return '%s'\n", data.cFileName );
2623 ok ( FindClose(handle) == TRUE, "Failed to close handle %s\n", buffer2 );
2624
2625 /* try FindFirstFileA on "C:\foo\" */
2626 SetLastError( 0xdeadbeaf );
2628 {
2629 char tmp[MAX_PATH];
2630 GetTempPathA( sizeof(tmp), tmp );
2631 GetTempFileNameA( tmp, "foo", 0, nonexistent );
2632 }
2634 strcpy(buffer2, nonexistent);
2635 strcat(buffer2, "\\");
2636 handle = FindFirstFileA(buffer2, &data);
2637 err = GetLastError();
2638 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2639 todo_wine {
2640 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2641 }
2642
2643 /* try FindFirstFileA without trailing backslash */
2644 SetLastError( 0xdeadbeaf );
2645 strcpy(buffer2, nonexistent);
2646 handle = FindFirstFileA(buffer2, &data);
2647 err = GetLastError();
2648 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2649 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2650
2651 /* try FindFirstFileA on "C:\foo\bar.txt" */
2652 SetLastError( 0xdeadbeaf );
2653 strcpy(buffer2, nonexistent);
2654 strcat(buffer2, "\\bar.txt");
2655 handle = FindFirstFileA(buffer2, &data);
2656 err = GetLastError();
2657 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2658 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2659
2660 /* try FindFirstFileA on "C:\foo\*.*" */
2661 SetLastError( 0xdeadbeaf );
2662 strcpy(buffer2, nonexistent);
2663 strcat(buffer2, "\\*.*");
2664 handle = FindFirstFileA(buffer2, &data);
2665 err = GetLastError();
2666 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2667 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2668
2669 /* try FindFirstFileA on "foo\bar.txt" */
2670 SetLastError( 0xdeadbeaf );
2671 strcpy(buffer2, nonexistent + 3);
2672 strcat(buffer2, "\\bar.txt");
2673 handle = FindFirstFileA(buffer2, &data);
2674 err = GetLastError();
2675 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2676 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2677
2678 /* try FindFirstFileA on "c:\nul" */
2679 SetLastError( 0xdeadbeaf );
2680 strcpy(buffer2, buffer);
2681 strcat(buffer2, "nul");
2682 handle = FindFirstFileA(buffer2, &data);
2683 err = GetLastError();
2684 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed: %d\n", buffer2, err );
2685 ok( 0 == lstrcmpiA(data.cFileName, "nul"), "wrong name %s\n", data.cFileName );
2686 ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes ||
2687 FILE_ATTRIBUTE_DEVICE == data.dwFileAttributes /* Win9x */,
2688 "wrong attributes %x\n", data.dwFileAttributes );
2689 if (data.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE)
2690 {
2691 ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
2692 ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
2693 }
2694 SetLastError( 0xdeadbeaf );
2695 ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
2696 ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
2697 ok( FindClose( handle ), "failed to close handle\n" );
2698
2699 /* try FindFirstFileA on "lpt1" */
2700 SetLastError( 0xdeadbeaf );
2701 strcpy(buffer2, "lpt1");
2702 handle = FindFirstFileA(buffer2, &data);
2703 err = GetLastError();
2704 ok( handle != INVALID_HANDLE_VALUE, "FindFirstFile on %s failed: %d\n", buffer2, err );
2705 ok( 0 == lstrcmpiA(data.cFileName, "lpt1"), "wrong name %s\n", data.cFileName );
2706 ok( FILE_ATTRIBUTE_ARCHIVE == data.dwFileAttributes ||
2707 FILE_ATTRIBUTE_DEVICE == data.dwFileAttributes /* Win9x */,
2708 "wrong attributes %x\n", data.dwFileAttributes );
2709 if (data.dwFileAttributes == FILE_ATTRIBUTE_ARCHIVE)
2710 {
2711 ok( 0 == data.nFileSizeHigh, "wrong size %d\n", data.nFileSizeHigh );
2712 ok( 0 == data.nFileSizeLow, "wrong size %d\n", data.nFileSizeLow );
2713 }
2714 SetLastError( 0xdeadbeaf );
2715 ok( !FindNextFileA( handle, &data ), "FindNextFileA succeeded\n" );
2716 ok( GetLastError() == ERROR_NO_MORE_FILES, "bad error %d\n", GetLastError() );
2717 ok( FindClose( handle ), "failed to close handle\n" );
2718
2719 /* try FindFirstFileA on "c:\nul\*" */
2720 SetLastError( 0xdeadbeaf );
2721 strcpy(buffer2, buffer);
2722 strcat(buffer2, "nul\\*");
2723 handle = FindFirstFileA(buffer2, &data);
2724 err = GetLastError();
2725 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2726 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2727
2728 /* try FindFirstFileA on "c:\nul*" */
2729 SetLastError( 0xdeadbeaf );
2730 strcpy(buffer2, buffer);
2731 strcat(buffer2, "nul*");
2732 handle = FindFirstFileA(buffer2, &data);
2733 err = GetLastError();
2734 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2735 ok ( err == ERROR_FILE_NOT_FOUND, "Bad Error number %d\n", err );
2736
2737 /* try FindFirstFileA on "c:\foo\bar\nul" */
2738 SetLastError( 0xdeadbeaf );
2739 strcpy(buffer2, buffer);
2740 strcat(buffer2, "foo\\bar\\nul");
2741 handle = FindFirstFileA(buffer2, &data);
2742 err = GetLastError();
2743 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2744 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2745
2746 /* try FindFirstFileA on "c:\foo\nul\bar" */
2747 SetLastError( 0xdeadbeaf );
2748 strcpy(buffer2, buffer);
2749 strcat(buffer2, "foo\\nul\\bar");
2750 handle = FindFirstFileA(buffer2, &data);
2751 err = GetLastError();
2752 ok ( handle == INVALID_HANDLE_VALUE, "FindFirstFile on %s should fail\n", buffer2 );
2753 ok ( err == ERROR_PATH_NOT_FOUND, "Bad Error number %d\n", err );
2754
2755 /* try FindFirstFileA with invalid characters */
2756 CreateDirectoryA("test-dir", NULL);
2757 _lclose(_lcreat("test-file", 0));
2758
2759 for (i = 0; i < sizeof(invalid_char_tests) / sizeof(invalid_char_tests[0]); i++)
2760 {
2763 {
2764 ok(handle != INVALID_HANDLE_VALUE, "FindFirstFileA on %s should succeed\n",
2766 }
2767 else
2768 {
2769 ok(handle == INVALID_HANDLE_VALUE, "FindFirstFileA on %s should fail\n",
2771 }
2774 }
2775
2776 DeleteFileA("test-file");
2777 RemoveDirectoryA("test-dir");
2778}
2779
2780static void test_FindNextFileA(void)
2781{
2782 HANDLE handle;
2783 WIN32_FIND_DATAA search_results;
2784 int err;
2785 char buffer[5] = "C:\\*";
2786
2788 handle = FindFirstFileA(buffer,&search_results);
2789 ok ( handle != INVALID_HANDLE_VALUE, "FindFirstFile on C:\\* should succeed\n" );
2790 while (FindNextFileA(handle, &search_results))
2791 {
2792 /* get to the end of the files */
2793 }
2794 ok ( FindClose(handle) == TRUE, "Failed to close handle\n");
2795 err = GetLastError();
2796 ok ( err == ERROR_NO_MORE_FILES, "GetLastError should return ERROR_NO_MORE_FILES\n");
2797}
2798
2800{
2801 WIN32_FIND_DATAA search_results;
2802 HANDLE handle;
2803 BOOL ret;
2804
2805 if (!pFindFirstFileExA)
2806 {
2807 win_skip("FindFirstFileExA() is missing\n");
2808 return;
2809 }
2810
2811 trace("Running FindFirstFileExA tests with level=%d, search_ops=%d, flags=%u\n",
2812 level, search_ops, flags);
2813
2814 CreateDirectoryA("test-dir", NULL);
2815 _lclose(_lcreat("test-dir\\file1", 0));
2816 _lclose(_lcreat("test-dir\\file2", 0));
2817 CreateDirectoryA("test-dir\\dir1", NULL);
2818 SetLastError(0xdeadbeef);
2819 handle = pFindFirstFileExA("test-dir\\*", level, &search_results, search_ops, NULL, flags);
2821 {
2822 win_skip("FindFirstFileExA is not implemented\n");
2823 goto cleanup;
2824 }
2826 {
2827 win_skip("FindFirstFileExA flag FIND_FIRST_EX_LARGE_FETCH not supported, skipping test\n");
2828 goto cleanup;
2829 }
2831 {
2832 win_skip("FindFirstFileExA level FindExInfoBasic not supported, skipping test\n");
2833 goto cleanup;
2834 }
2835
2836#define CHECK_NAME(fn) (strcmp((fn), "file1") == 0 || strcmp((fn), "file2") == 0 || strcmp((fn), "dir1") == 0)
2837#define CHECK_LEVEL(fn) (level != FindExInfoBasic || !(fn)[0])
2838
2839 ok(handle != INVALID_HANDLE_VALUE, "FindFirstFile failed (err=%u)\n", GetLastError());
2840 ok(strcmp(search_results.cFileName, ".") == 0, "First entry should be '.', is %s\n", search_results.cFileName);
2841 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2842
2843 ok(FindNextFileA(handle, &search_results), "Fetching second file failed\n");
2844 ok(strcmp(search_results.cFileName, "..") == 0, "Second entry should be '..' is %s\n", search_results.cFileName);
2845 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2846
2847 ok(FindNextFileA(handle, &search_results), "Fetching third file failed\n");
2848 ok(CHECK_NAME(search_results.cFileName), "Invalid third entry - %s\n", search_results.cFileName);
2849 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2850
2851 SetLastError(0xdeadbeef);
2852 ret = FindNextFileA(handle, &search_results);
2853 if (!ret && (GetLastError() == ERROR_NO_MORE_FILES) && (search_ops == FindExSearchLimitToDirectories))
2854 {
2855 skip("File system supports directory filtering\n");
2856 /* Results from the previous call are not cleared */
2857 ok(strcmp(search_results.cFileName, "dir1") == 0, "Third entry should be 'dir1' is %s\n", search_results.cFileName);
2858 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2859
2860 }
2861 else
2862 {
2863 ok(ret, "Fetching fourth file failed\n");
2864 ok(CHECK_NAME(search_results.cFileName), "Invalid fourth entry - %s\n", search_results.cFileName);
2865 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2866
2867 ok(FindNextFileA(handle, &search_results), "Fetching fifth file failed\n");
2868 ok(CHECK_NAME(search_results.cFileName), "Invalid fifth entry - %s\n", search_results.cFileName);
2869 ok(CHECK_LEVEL(search_results.cAlternateFileName), "FindFirstFile unexpectedly returned an alternate filename\n");
2870
2871 ok(FindNextFileA(handle, &search_results) == FALSE, "Fetching sixth file should fail\n");
2872 }
2873
2874#undef CHECK_NAME
2875#undef CHECK_LEVEL
2876
2877 FindClose( handle );
2878
2879 /* Most Windows systems seem to ignore the FIND_FIRST_EX_CASE_SENSITIVE flag. Unofficial documentation
2880 * suggests that there are registry keys and that it might depend on the used filesystem. */
2881 SetLastError(0xdeadbeef);
2882 handle = pFindFirstFileExA("TEST-DIR\\*", level, &search_results, search_ops, NULL, flags);
2884 {
2886 "Unexpected error %x, expected valid handle or ERROR_PATH_NOT_FOUND\n", GetLastError());
2887 trace("FindFirstFileExA flag FIND_FIRST_EX_CASE_SENSITIVE is %signored\n",
2888 (handle == INVALID_HANDLE_VALUE) ? "not " : "");
2889 }
2890 else
2891 ok(handle != INVALID_HANDLE_VALUE, "Unexpected error %x, expected valid handle\n", GetLastError());
2893 FindClose( handle );
2894
2895cleanup:
2896 DeleteFileA("test-dir\\file1");
2897 DeleteFileA("test-dir\\file2");
2898 RemoveDirectoryA("test-dir\\dir1");
2899 RemoveDirectoryA("test-dir");
2900}
2901
2903{
2905 HANDLE handle;
2906 int i;
2907 static const char* files[] = {
2908 "..a", "..a.a", ".a", ".a..a", ".a.a", ".aaa",
2909 "a", "a..a", "a.a", "a.a.a", "aa", "aaa", "aaaa"
2910 };
2911 static const struct {
2912 int todo;
2913 const char *pattern, *result;
2914 } tests[] = {
2915 {0, "*.*.*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2916 {0, "*.*.", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2917 {0, ".*.*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa'"},
2918 {0, "*.*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2919 {0, ".*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa'"},
2920 {1, "*.", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2921 {0, "*", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2922 {1, "*..*", ", '.', '..', '..a', '..a.a', '.a..a', 'a..a'"},
2923 {1, "*..", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2924 {1, ".*.", ", '.', '..', '.a', '.aaa'"},
2925 {0, "..*", ", '.', '..', '..a', '..a.a'"},
2926 {0, "**", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2927 {0, "**.", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2928 {0, "*. ", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2929 {1, "* .", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2930 {0, "* . ", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2931 {0, "*.. ", ", '.', '..', '..a', '..a.a', '.a', '.a..a', '.a.a', '.aaa', 'a', 'a..a', 'a.a', 'a.a.a', 'aa', 'aaa', 'aaaa'"},
2932 {1, "*. .", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2933 {1, "* ..", ", '.', '..', 'a', '.a', '..a', 'aa', 'aaa', 'aaaa', '.aaa'"},
2934 {1, " *..", ", '.aaa'"},
2935 {0, "..* ", ", '.', '..', '..a', '..a.a'"},
2936 {1, "?", ", '.', '..', 'a'"},
2937 {1, "?.", ", '.', '..', 'a'"},
2938 {1, "?. ", ", '.', '..', 'a'"},
2939 {1, "??.", ", '.', '..', 'a', 'aa'"},
2940 {1, "??. ", ", '.', '..', 'a', 'aa'"},
2941 {1, "???.", ", '.', '..', 'a', 'aa', 'aaa'"},
2942 {1, "?.??.", ", '.', '..', '.a', 'a', 'a.a'"}
2943 };
2944
2945 CreateDirectoryA("test-dir", NULL);
2946 SetCurrentDirectoryA("test-dir");
2947 for (i = 0; i < sizeof(files) / sizeof(files[0]); ++i)
2948 _lclose(_lcreat(files[i], 0));
2949
2950 for (i = 0; i < sizeof(tests) / sizeof(tests[0]); ++i)
2951 {
2952 char correct[512];
2953 char incorrect[512];
2954 char missing[512];
2955
2956 strcpy(missing, tests[i].result);
2957 correct[0] = incorrect[0] = 0;
2958
2960 if (handle) do {
2961 char* ptr;
2962 char quoted[16];
2963
2964 sprintf( quoted, ", '%.10s'", find_data.cFileName );
2965
2966 if ((ptr = strstr(missing, quoted)))
2967 {
2968 int len = strlen(quoted);
2969 while ((ptr[0] = ptr[len]) != 0)
2970 ++ptr;
2971 strcat(correct, quoted);
2972 }
2973 else
2974 strcat(incorrect, quoted);
2975 } while (FindNextFileA(handle, &find_data));
2977
2979 ok(missing[0] == 0 && incorrect[0] == 0,
2980 "FindFirstFile with '%s' found correctly %s, found incorrectly %s, and missed %s\n",
2981 tests[i].pattern,
2982 correct[0] ? correct+2 : "none",
2983 incorrect[0] ? incorrect+2 : "none",
2984 missing[0] ? missing+2 : "none");
2985 }
2986
2987 for (i = 0; i < sizeof(files) / sizeof(files[0]); ++i)
2988 DeleteFileA(files[i]);
2990 RemoveDirectoryA("test-dir");
2991}
2992
2994{
2999 if (*handle != INVALID_HANDLE_VALUE) {
3000
3001 return 1;
3002 }
3003
3004 return 0;
3005}
3006
3007static void test_MapFile(void)
3008{
3009 HANDLE handle;
3010 HANDLE hmap;
3011
3012 ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
3013
3014 hmap = CreateFileMappingA( handle, NULL, PAGE_READWRITE, 0, 0x1000, "named_file_map" );
3015 ok( hmap != NULL, "mapping should work, I named it!\n" );
3016
3017 ok( CloseHandle( hmap ), "can't close mapping handle\n");
3018
3019 /* We have to close file before we try new stuff with mapping again.
3020 Else we would always succeed on XP or block descriptors on 95. */
3022 ok( hmap != NULL, "We should still be able to map!\n" );
3023 ok( CloseHandle( hmap ), "can't close mapping handle\n");
3024 ok( CloseHandle( handle ), "can't close file handle\n");
3025 handle = NULL;
3026
3027 ok(test_Mapfile_createtemp(&handle), "Couldn't create test file.\n");
3028
3030 ok( hmap == NULL, "mapped zero size file\n");
3031 ok( GetLastError() == ERROR_FILE_INVALID, "not ERROR_FILE_INVALID\n");
3032
3033 hmap = CreateFileMappingA( handle, NULL, PAGE_READWRITE, 0x80000000, 0, NULL );
3034 ok( hmap == NULL || broken(hmap != NULL) /* NT4 */, "mapping should fail\n");
3035 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
3036 if ( hmap )
3037 CloseHandle( hmap );
3038
3039 hmap = CreateFileMappingA( handle, NULL, PAGE_READWRITE, 0x80000000, 0x10000, NULL );
3040 ok( hmap == NULL || broken(hmap != NULL) /* NT4 */, "mapping should fail\n");
3041 /* GetLastError() varies between win9x and WinNT and also depends on the filesystem */
3042 if ( hmap )
3043 CloseHandle( hmap );
3044
3045 /* On XP you can now map again, on Win 95 you cannot. */
3046
3047 ok( CloseHandle( handle ), "can't close file handle\n");
3048 ok( DeleteFileA( filename ), "DeleteFile failed after map\n" );
3049}
3050
3051static void test_GetFileType(void)
3052{
3053 DWORD type, type2;
3055 ok( h != INVALID_HANDLE_VALUE, "open %s failed\n", filename );
3056 type = GetFileType(h);
3057 ok( type == FILE_TYPE_DISK, "expected type disk got %d\n", type );
3058 CloseHandle( h );
3060 ok( h != INVALID_HANDLE_VALUE, "open nul failed\n" );
3061 type = GetFileType(h);
3062 ok( type == FILE_TYPE_CHAR, "expected type char for nul got %d\n", type );
3063 CloseHandle( h );
3066 ok( h != INVALID_HANDLE_VALUE, "GetStdHandle failed\n" );
3068 type2 = GetFileType( h );
3069 ok(type == type2, "expected type %d for STD_OUTPUT_HANDLE got %d\n", type2, type);
3070}
3071
3073
3074static void CALLBACK FileIOComplete(DWORD dwError, DWORD dwBytes, LPOVERLAPPED ovl)
3075{
3076/* printf("(%ld, %ld, %p { %ld, %ld, %ld, %ld, %p })\n", dwError, dwBytes, ovl, ovl->Internal, ovl->InternalHigh, ovl->Offset, ovl->OffsetHigh, ovl->hEvent);*/
3077 ReleaseSemaphore(ovl->hEvent, 1, NULL);
3079}
3080
3081static void test_async_file_errors(void)
3082{
3083 char szFile[MAX_PATH];
3084 HANDLE hSem = CreateSemaphoreW(NULL, 1, 1, NULL);
3085 HANDLE hFile;
3087 OVERLAPPED ovl;
3088 S(U(ovl)).Offset = 0;
3089 S(U(ovl)).OffsetHigh = 0;
3090 ovl.hEvent = hSem;
3091 completion_count = 0;
3092 szFile[0] = '\0';
3093 GetWindowsDirectoryA(szFile, sizeof(szFile)/sizeof(szFile[0])-1-strlen("\\win.ini"));
3094 strcat(szFile, "\\win.ini");
3097 if (hFile == INVALID_HANDLE_VALUE) /* win9x doesn't like FILE_SHARE_DELETE */
3100 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA(%s ...) failed\n", szFile);
3101 while (TRUE)
3102 {
3103 BOOL res;
3104 DWORD count;
3106 ;
3107 res = ReadFileEx(hFile, lpBuffer, 4096, &ovl, FileIOComplete);
3108 /*printf("Offset = %ld, result = %s\n", ovl.Offset, res ? "TRUE" : "FALSE");*/
3109 if (!res)
3110 break;
3111 if (!GetOverlappedResult(hFile, &ovl, &count, FALSE))
3112 break;
3113 S(U(ovl)).Offset += count;
3114 /* i/o completion routine only called if ReadFileEx returned success.
3115 * we only care about violations of this rule so undo what should have
3116 * been done */
3118 }
3119 ok(completion_count == 0, "completion routine should only be called when ReadFileEx succeeds (this rule was violated %d times)\n", completion_count);
3120 /*printf("Error = %ld\n", GetLastError());*/
3122}
3123
3126{
3128}
3129
3130static void test_read_write(void)
3131{
3132 DWORD bytes, ret, old_prot;
3133 HANDLE hFile;
3134 char temp_path[MAX_PATH];
3135 char filename[MAX_PATH];
3136 char *mem;
3137 static const char prefix[] = "pfx";
3138
3140 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
3141 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
3142
3143 ret = GetTempFileNameA(temp_path, prefix, 0, filename);
3144 ok(ret != 0, "GetTempFileNameA error %d\n", GetLastError());
3145
3148 ok(hFile != INVALID_HANDLE_VALUE, "CreateFileA: error %d\n", GetLastError());
3149
3151 if (pQueueUserAPC) {
3152 trace("Queueing an user APC\n"); /* verify the file is non alerable */
3153 ret = pQueueUserAPC(&user_apc, GetCurrentThread(), 0);
3154 ok(ret, "QueueUserAPC failed: %d\n", GetLastError());
3155 }
3156
3157 SetLastError(12345678);
3158 bytes = 12345678;
3159 ret = WriteFile(hFile, NULL, 0, &bytes, NULL);
3160 ok(ret && GetLastError() == 12345678,
3161 "ret = %d, error %d\n", ret, GetLastError());
3162 ok(!bytes, "bytes = %d\n", bytes);
3163
3164 SetLastError(12345678);
3165 bytes = 12345678;
3166 ret = WriteFile(hFile, NULL, 10, &bytes, NULL);
3167 ok((!ret && GetLastError() == ERROR_INVALID_USER_BUFFER) || /* Win2k */
3168 (ret && GetLastError() == 12345678), /* Win9x */
3169 "ret = %d, error %d\n", ret, GetLastError());
3170 ok(!bytes || /* Win2k */
3171 bytes == 10, /* Win9x */
3172 "bytes = %d\n", bytes);
3173
3174 /* make sure the file contains data */
3175 WriteFile(hFile, "this is the test data", 21, &bytes, NULL);
3177
3178 SetLastError(12345678);
3179 bytes = 12345678;
3180 ret = ReadFile(hFile, NULL, 0, &bytes, NULL);
3181 ok(ret && GetLastError() == 12345678,
3182 "ret = %d, error %d\n", ret, GetLastError());
3183 ok(!bytes, "bytes = %d\n", bytes);
3184
3185 SetLastError(12345678);
3186 bytes = 12345678;
3187 ret = ReadFile(hFile, NULL, 10, &bytes, NULL);
3188 ok(!ret && (GetLastError() == ERROR_NOACCESS || /* Win2k */
3189 GetLastError() == ERROR_INVALID_PARAMETER), /* Win9x */
3190 "ret = %d, error %d\n", ret, GetLastError());
3191 ok(!bytes, "bytes = %d\n", bytes);
3192
3193 ok(user_apc_ran == FALSE, "UserAPC ran, file using alertable io mode\n");
3194 if (pQueueUserAPC)
3195 SleepEx(0, TRUE); /* get rid of apc */
3196
3197 /* test passing protected memory as buffer */
3198
3200 ok( mem != NULL, "failed to allocate virtual mem error %u\n", GetLastError() );
3201
3202 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
3203 ok( ret, "WriteFile failed error %u\n", GetLastError() );
3204 ok( bytes == 0x4000, "only wrote %x bytes\n", bytes );
3205
3206 ret = VirtualProtect( mem + 0x2000, 0x2000, PAGE_NOACCESS, &old_prot );
3207 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
3208
3209 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
3210 ok( !ret, "WriteFile succeeded\n" );
3212 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
3213 "wrong error %u\n", GetLastError() );
3214 ok( bytes == 0, "wrote %x bytes\n", bytes );
3215
3216 ret = WriteFile( (HANDLE)0xdead, mem, 0x4000, &bytes, NULL );
3217 ok( !ret, "WriteFile succeeded\n" );
3218 ok( GetLastError() == ERROR_INVALID_HANDLE || /* handle is checked before buffer on NT */
3219 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
3220 "wrong error %u\n", GetLastError() );
3221 ok( bytes == 0, "wrote %x bytes\n", bytes );
3222
3223 ret = VirtualProtect( mem, 0x2000, PAGE_NOACCESS, &old_prot );
3224 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
3225
3226 ret = WriteFile( hFile, mem, 0x4000, &bytes, NULL );
3227 ok( !ret, "WriteFile succeeded\n" );
3229 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
3230 "wrong error %u\n", GetLastError() );
3231 ok( bytes == 0, "wrote %x bytes\n", bytes );
3232
3234
3235 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
3236 ok( !ret, "ReadFile succeeded\n" );
3238 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
3239 "wrong error %u\n", GetLastError() );
3240 ok( bytes == 0, "read %x bytes\n", bytes );
3241
3242 ret = VirtualProtect( mem, 0x2000, PAGE_READONLY, &old_prot );
3243 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
3244
3245 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
3246 ok( !ret, "ReadFile succeeded\n" );
3248 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
3249 "wrong error %u\n", GetLastError() );
3250 ok( bytes == 0, "read %x bytes\n", bytes );
3251
3252 ret = VirtualProtect( mem, 0x2000, PAGE_READWRITE, &old_prot );
3253 ok( ret, "VirtualProtect failed error %u\n", GetLastError() );
3254
3255 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
3256 ok( !ret, "ReadFile succeeded\n" );
3258 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
3259 "wrong error %u\n", GetLastError() );
3260 ok( bytes == 0, "read %x bytes\n", bytes );
3261
3262 SetFilePointer( hFile, 0x1234, NULL, FILE_BEGIN );
3265
3266 ret = ReadFile( hFile, mem, 0x4000, &bytes, NULL );
3267 ok( !ret, "ReadFile succeeded\n" );
3269 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
3270 "wrong error %u\n", GetLastError() );
3271 ok( bytes == 0, "read %x bytes\n", bytes );
3272
3273 ret = ReadFile( hFile, mem, 0x2000, &bytes, NULL );
3274 ok( ret, "ReadFile failed error %u\n", GetLastError() );
3275 ok( bytes == 0x1234, "read %x bytes\n", bytes );
3276
3277 ret = ReadFile( hFile, NULL, 1, &bytes, NULL );
3278 ok( !ret, "ReadFile succeeded\n" );
3280 GetLastError() == ERROR_INVALID_PARAMETER, /* win9x */
3281 "wrong error %u\n", GetLastError() );
3282 ok( bytes == 0, "read %x bytes\n", bytes );
3283
3285
3287 ok( ret, "CloseHandle: error %d\n", GetLastError());
3289 ok( ret, "DeleteFileA: error %d\n", GetLastError());
3290}
3291
3292static void test_OpenFile(void)
3293{
3294 HFILE hFile;
3295 OFSTRUCT ofs;
3296 BOOL ret;
3297 DWORD retval;
3298
3299 static const char file[] = "regedit.exe";
3300 static const char foo[] = ".\\foo-bar-foo.baz";
3301 static const char *foo_too_long = ".\\foo-bar-foo.baz+++++++++++++++"
3302 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
3303 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
3304 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
3305 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
3306 "+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++";
3307 char buff[MAX_PATH];
3308 char buff_long[4*MAX_PATH];
3309 char filled_0xA5[OFS_MAXPATHNAME];
3310 char *p;
3311 UINT length;
3312
3313 /* Check for existing file */
3314 if (!pGetSystemWindowsDirectoryA)
3316 else
3317 length = pGetSystemWindowsDirectoryA(buff, MAX_PATH);
3318
3319 if (length + sizeof(file) < MAX_PATH)
3320 {
3321 p = buff + strlen(buff);
3322 if (p > buff && p[-1] != '\\') *p++ = '\\';
3323 strcpy( p, file );
3324 memset(&ofs, 0xA5, sizeof(ofs));
3325 SetLastError(0xfaceabee);
3326
3327 hFile = OpenFile(buff, &ofs, OF_EXIST);
3328 ok( hFile == TRUE, "%s not found : %d\n", buff, GetLastError() );
3329 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
3330 "GetLastError() returns %d\n", GetLastError() );
3331 ok( ofs.cBytes == sizeof(ofs), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3332 ok( ofs.nErrCode == ERROR_SUCCESS, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3333 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
3334 "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
3335 ofs.szPathName, buff );
3336 }
3337
3338 memset(&filled_0xA5, 0xA5, OFS_MAXPATHNAME);
3340
3341 /* Check for nonexistent file */
3342 if (length + sizeof(foo) < MAX_PATH)
3343 {
3344 p = buff + strlen(buff);
3345 if (p > buff && p[-1] != '\\') *p++ = '\\';
3346 strcpy( p, foo + 2 );
3347 memset(&ofs, 0xA5, sizeof(ofs));
3348 SetLastError(0xfaceabee);
3349
3350 hFile = OpenFile(foo, &ofs, OF_EXIST);
3351 ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %d\n", GetLastError());
3352 ok( GetLastError() == ERROR_FILE_NOT_FOUND, "GetLastError() returns %d\n", GetLastError() );
3353 todo_wine
3354 ok( ofs.cBytes == 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3355 ok( ofs.nErrCode == ERROR_FILE_NOT_FOUND, "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3356 ok( lstrcmpiA(ofs.szPathName, buff) == 0 || strncmp(ofs.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
3357 "OpenFile returned '%s', but was expected to return '%s' or string filled with 0xA5\n",
3358 ofs.szPathName, buff );
3359 }
3360
3361 length = GetCurrentDirectoryA(MAX_PATH, buff_long);
3362 length += lstrlenA(foo_too_long + 1);
3363
3364 /* Check for nonexistent file with too long filename */
3365 if (length >= OFS_MAXPATHNAME && length < sizeof(buff_long))
3366 {
3367 lstrcatA(buff_long, foo_too_long + 1); /* Avoid '.' during concatenation */
3368 memset(&ofs, 0xA5, sizeof(ofs));
3369 SetLastError(0xfaceabee);
3370
3371 hFile = OpenFile(foo_too_long, &ofs, OF_EXIST);
3372 ok( hFile == HFILE_ERROR, "hFile != HFILE_ERROR : %d\n", GetLastError());
3374 "GetLastError() returns %d\n", GetLastError() );
3375 todo_wine
3376 ok( ofs.cBytes == 0xA5, "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3378 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3379 ok( strncmp(ofs.szPathName, filled_0xA5, OFS_MAXPATHNAME) == 0,
3380 "OpenFile returned '%s', but was expected to return string filled with 0xA5\n",
3381 ofs.szPathName );
3382 }
3383
3385
3386 if (length >= MAX_PATH)
3387 {
3388 trace("Buffer too small, requested length = %d, but MAX_PATH = %d. Skipping test.\n", length, MAX_PATH);
3389 return;
3390 }
3391 p = buff + strlen(buff);
3392 if (p > buff && p[-1] != '\\') *p++ = '\\';
3393 strcpy( p, filename );
3394
3395 memset(&ofs, 0xA5, sizeof(ofs));
3396 SetLastError(0xfaceabee);
3397 /* Create an empty file */
3398 hFile = OpenFile(filename, &ofs, OF_CREATE);
3399 ok( hFile != HFILE_ERROR, "OpenFile failed to create nonexistent file\n" );
3400 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
3401 "GetLastError() returns %d\n", GetLastError() );
3402 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3403 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
3404 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3405 ret = _lclose(hFile);
3406 ok( !ret, "_lclose() returns %d\n", ret );
3407 retval = GetFileAttributesA(filename);
3408 ok( retval != INVALID_FILE_ATTRIBUTES, "GetFileAttributesA: error %d\n", GetLastError() );
3409
3410 memset(&ofs, 0xA5, sizeof(ofs));
3411 SetLastError(0xfaceabee);
3412 /* Check various opening options: */
3413 /* for reading only, */
3414 hFile = OpenFile(filename, &ofs, OF_READ);
3415 ok( hFile != HFILE_ERROR, "OpenFile failed on read\n" );
3416 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
3417 "GetLastError() returns %d\n", GetLastError() );
3418 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3419 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
3420 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3421 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
3422 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
3423 ret = _lclose(hFile);
3424 ok( !ret, "_lclose() returns %d\n", ret );
3425
3426 memset(&ofs, 0xA5, sizeof(ofs));
3427 SetLastError(0xfaceabee);
3428 /* for writing only, */
3429 hFile = OpenFile(filename, &ofs, OF_WRITE);
3430 ok( hFile != HFILE_ERROR, "OpenFile failed on write\n" );
3431 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
3432 "GetLastError() returns %d\n", GetLastError() );
3433 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3434 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
3435 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3436 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
3437 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
3438 ret = _lclose(hFile);
3439 ok( !ret, "_lclose() returns %d\n", ret );
3440
3441 memset(&ofs, 0xA5, sizeof(ofs));
3442 SetLastError(0xfaceabee);
3443 /* for reading and writing, */
3445 ok( hFile != HFILE_ERROR, "OpenFile failed on read/write\n" );
3446 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
3447 "GetLastError() returns %d\n", GetLastError() );
3448 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3449 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
3450 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3451 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
3452 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
3453 ret = _lclose(hFile);
3454 ok( !ret, "_lclose() returns %d\n", ret );
3455
3456 memset(&ofs, 0xA5, sizeof(ofs));
3457 SetLastError(0xfaceabee);
3458 /* for checking file presence. */
3459 hFile = OpenFile(filename, &ofs, OF_EXIST);
3460 ok( hFile == 1, "OpenFile failed on finding our created file\n" );
3461 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
3462 "GetLastError() returns %d\n", GetLastError() );
3463 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3464 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
3465 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3466 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
3467 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
3468
3469 memset(&ofs, 0xA5, sizeof(ofs));
3470 SetLastError(0xfaceabee);
3471 /* Delete the file and make sure it doesn't exist anymore */
3472 hFile = OpenFile(filename, &ofs, OF_DELETE);
3473 ok( hFile == 1, "OpenFile failed on delete (%d)\n", hFile );
3474 ok( GetLastError() == 0xfaceabee || GetLastError() == ERROR_SUCCESS,
3475 "GetLastError() returns %d\n", GetLastError() );
3476 ok( ofs.cBytes == sizeof(OFSTRUCT), "OpenFile set ofs.cBytes to %d\n", ofs.cBytes );
3477 ok( ofs.nErrCode == ERROR_SUCCESS || broken(ofs.nErrCode != ERROR_SUCCESS) /* win9x */,
3478 "OpenFile set ofs.nErrCode to %d\n", ofs.nErrCode );
3479 ok( lstrcmpiA(ofs.szPathName, buff) == 0,
3480 "OpenFile returned '%s', but was expected to return '%s'\n", ofs.szPathName, buff );
3481
3482 retval = GetFileAttributesA(filename);
3483 ok( retval == INVALID_FILE_ATTRIBUTES, "GetFileAttributesA succeeded on deleted file\n" );
3484}
3485
3486static void test_overlapped(void)
3487{
3488 OVERLAPPED ov;
3489 DWORD r, result;
3490
3491 /* GetOverlappedResult crashes if the 2nd or 3rd param are NULL */
3492 if (0) /* tested: WinXP */
3493 {
3495 GetOverlappedResult(0, &ov, NULL, FALSE);
3497 }
3498
3499 memset( &ov, 0, sizeof ov );
3500 result = 1;
3501 r = GetOverlappedResult(0, &ov, &result, 0);
3502 if (r)
3503 ok( result == 0, "wrong result %u\n", result );
3504 else /* win9x */
3505 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
3506
3507 result = 0;
3508 ov.Internal = 0;
3509 ov.InternalHigh = 0xabcd;
3510 r = GetOverlappedResult(0, &ov, &result, 0);
3511 if (r)
3512 ok( result == 0xabcd, "wrong result %u\n", result );
3513 else /* win9x */
3514 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
3515
3516 SetLastError( 0xb00 );
3517 result = 0;
3519 ov.InternalHigh = 0xabcd;
3520 r = GetOverlappedResult(0, &ov, &result, 0);
3521 ok( GetLastError() == ERROR_INVALID_HANDLE, "wrong error %u\n", GetLastError() );
3522 ok( r == FALSE, "should return false\n");
3523 ok( result == 0xabcd || result == 0 /* win9x */, "wrong result %u\n", result );
3524
3525 SetLastError( 0xb00 );
3526 result = 0;
3528 ov.InternalHigh = 0xabcd;
3529 r = GetOverlappedResult(0, &ov, &result, 0);
3531 "wrong error %u\n", GetLastError() );
3532 ok( r == FALSE, "should return false\n");
3533 ok( result == 0, "wrong result %u\n", result );
3534
3535 SetLastError( 0xb00 );
3536 ov.hEvent = CreateEventW( NULL, 1, 1, NULL );
3538 ov.InternalHigh = 0xabcd;
3539 r = GetOverlappedResult(0, &ov, &result, 0);
3541 "wrong error %u\n", GetLastError() );
3542 ok( r == FALSE, "should return false\n");
3543
3544 r = GetOverlappedResult( 0, &ov, &result, TRUE );
3545 ok( r == TRUE, "should return TRUE\n" );
3546 ok( result == 0xabcd, "wrong result %u\n", result );
3547 ok( ov.Internal == STATUS_PENDING, "expected STATUS_PENDING, got %08lx\n", ov.Internal );
3548
3549 ResetEvent( ov.hEvent );
3550
3551 SetLastError( 0xb00 );
3553 ov.InternalHigh = 0;
3554 r = GetOverlappedResult(0, &ov, &result, 0);
3556 "wrong error %u\n", GetLastError() );
3557 ok( r == FALSE, "should return false\n");
3558
3559 r = CloseHandle( ov.hEvent );
3560 ok( r == TRUE, "close handle failed\n");
3561}
3562
3563static void test_RemoveDirectory(void)
3564{
3565 int rc;
3566 char directory[] = "removeme";
3567
3569 ok( rc, "Createdirectory failed, gle=%d\n", GetLastError() );
3570
3572 ok( rc, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
3573
3574 rc = RemoveDirectoryA(".");
3575 if (!rc)
3576 {
3577 rc = SetCurrentDirectoryA("..");
3578 ok( rc, "SetCurrentDirectory failed, gle=%d\n", GetLastError() );
3579
3581 ok( rc, "RemoveDirectory failed, gle=%d\n", GetLastError() );
3582 }
3583}
3584
3585static BOOL check_file_time( const FILETIME *ft1, const FILETIME *ft2, UINT tolerance )
3586{
3587 ULONGLONG t1 = ((ULONGLONG)ft1->dwHighDateTime << 32) | ft1->dwLowDateTime;
3588 ULONGLONG t2 = ((ULONGLONG)ft2->dwHighDateTime << 32) | ft2->dwLowDateTime;
3589 return abs(t1 - t2) <= tolerance;
3590}
3591
3592static void test_ReplaceFileA(void)
3593{
3594 char replaced[MAX_PATH], replacement[MAX_PATH], backup[MAX_PATH];
3595 HANDLE hReplacedFile, hReplacementFile, hBackupFile;
3596 static const char replacedData[] = "file-to-replace";
3597 static const char replacementData[] = "new-file";
3598 static const char backupData[] = "backup-file";
3599 FILETIME ftReplaced, ftReplacement, ftBackup;
3600 static const char prefix[] = "pfx";
3601 char temp_path[MAX_PATH];
3602 DWORD ret;
3603 BOOL retok, removeBackup = FALSE;
3604
3605 if (!pReplaceFileA)
3606 {
3607 win_skip("ReplaceFileA() is missing\n");
3608 return;
3609 }
3610
3612 ok(ret != 0, "GetTempPathA error %d\n", GetLastError());
3613 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
3614
3615 ret = GetTempFileNameA(temp_path, prefix, 0, replaced);
3616 ok(ret != 0, "GetTempFileNameA error (replaced) %d\n", GetLastError());
3617
3618 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
3619 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
3620
3621 ret = GetTempFileNameA(temp_path, prefix, 0, backup);
3622 ok(ret != 0, "GetTempFileNameA error (backup) %d\n", GetLastError());
3623
3624 /* place predictable data in the file to be replaced */
3625 hReplacedFile = CreateFileA(replaced, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
3626 ok(hReplacedFile != INVALID_HANDLE_VALUE,
3627 "failed to open replaced file\n");
3628 retok = WriteFile(hReplacedFile, replacedData, sizeof(replacedData), &ret, NULL );
3629 ok( retok && ret == sizeof(replacedData),
3630 "WriteFile error (replaced) %d\n", GetLastError());
3631 ok(GetFileSize(hReplacedFile, NULL) == sizeof(replacedData),
3632 "replaced file has wrong size\n");
3633 /* place predictable data in the file to be the replacement */
3634 hReplacementFile = CreateFileA(replacement, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
3635 ok(hReplacementFile != INVALID_HANDLE_VALUE,
3636 "failed to open replacement file\n");
3637 retok = WriteFile(hReplacementFile, replacementData, sizeof(replacementData), &ret, NULL );
3638 ok( retok && ret == sizeof(replacementData),
3639 "WriteFile error (replacement) %d\n", GetLastError());
3640 ok(GetFileSize(hReplacementFile, NULL) == sizeof(replacementData),
3641 "replacement file has wrong size\n");
3642 /* place predictable data in the backup file (to be over-written) */
3643 hBackupFile = CreateFileA(backup, GENERIC_WRITE, 0, NULL, OPEN_EXISTING, 0, 0 );
3644 ok(hBackupFile != INVALID_HANDLE_VALUE,
3645 "failed to open backup file\n");
3646 retok = WriteFile(hBackupFile, backupData, sizeof(backupData), &ret, NULL );
3647 ok( retok && ret == sizeof(backupData),
3648 "WriteFile error (replacement) %d\n", GetLastError());
3649 ok(GetFileSize(hBackupFile, NULL) == sizeof(backupData),
3650 "backup file has wrong size\n");
3651 /* change the filetime on the "replaced" file to ensure that it changes */
3652 ret = GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
3653 ok( ret, "GetFileTime error (replaced) %d\n", GetLastError());
3654 ftReplaced.dwLowDateTime -= 600000000; /* 60 second */
3655 ret = SetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
3656 ok( ret, "SetFileTime error (replaced) %d\n", GetLastError());
3657 GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced); /* get the actual time back */
3658 CloseHandle(hReplacedFile);
3659 /* change the filetime on the backup to ensure that it changes */
3660 ret = GetFileTime(hBackupFile, NULL, NULL, &ftBackup);
3661 ok( ret, "GetFileTime error (backup) %d\n", GetLastError());
3662 ftBackup.dwLowDateTime -= 1200000000; /* 120 second */
3663 ret = SetFileTime(hBackupFile, NULL, NULL, &ftBackup);
3664 ok( ret, "SetFileTime error (backup) %d\n", GetLastError());
3665 GetFileTime(hBackupFile, NULL, NULL, &ftBackup); /* get the actual time back */
3666 CloseHandle(hBackupFile);
3667 /* get the filetime on the replacement file to perform checks */
3668 ret = GetFileTime(hReplacementFile, NULL, NULL, &ftReplacement);
3669 ok( ret, "GetFileTime error (replacement) %d\n", GetLastError());
3670 CloseHandle(hReplacementFile);
3671
3672 /* perform replacement w/ backup
3673 * TODO: flags are not implemented
3674 */
3675 SetLastError(0xdeadbeef);
3676 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
3677 ok(ret, "ReplaceFileA: unexpected error %d\n", GetLastError());
3678 /* make sure that the backup has the size of the old "replaced" file */
3680 ok(hBackupFile != INVALID_HANDLE_VALUE,
3681 "failed to open backup file\n");
3682 ret = GetFileSize(hBackupFile, NULL);
3683 ok(ret == sizeof(replacedData),
3684 "backup file has wrong size %d\n", ret);
3685 /* make sure that the "replaced" file has the size of the replacement file */
3686 hReplacedFile = CreateFileA(replaced, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
3687 ok(hReplacedFile != INVALID_HANDLE_VALUE,
3688 "failed to open replaced file: %d\n", GetLastError());
3689 if (hReplacedFile != INVALID_HANDLE_VALUE)
3690 {
3691 ret = GetFileSize(hReplacedFile, NULL);
3692 ok(ret == sizeof(replacementData),
3693 "replaced file has wrong size %d\n", ret);
3694 /* make sure that the replacement file no-longer exists */
3695 hReplacementFile = CreateFileA(replacement, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
3696 ok(hReplacementFile == INVALID_HANDLE_VALUE,
3697 "unexpected error, replacement file should not exist %d\n", GetLastError());
3698 /* make sure that the backup has the old "replaced" filetime */
3699 ret = GetFileTime(hBackupFile, NULL, NULL, &ftBackup);
3700 ok( ret, "GetFileTime error (backup %d\n", GetLastError());
3701 ok(check_file_time(&ftBackup, &ftReplaced, 20000000), "backup file has wrong filetime\n");
3702 CloseHandle(hBackupFile);
3703 /* make sure that the "replaced" has the old replacement filetime */
3704 ret = GetFileTime(hReplacedFile, NULL, NULL, &ftReplaced);
3705 ok( ret, "GetFileTime error (backup %d\n", GetLastError());
3706 ok(check_file_time(&ftReplaced, &ftReplacement, 20000000),
3707 "replaced file has wrong filetime %x%08x / %x%08x\n",
3708 ftReplaced.dwHighDateTime, ftReplaced.dwLowDateTime,
3709 ftReplacement.dwHighDateTime, ftReplacement.dwLowDateTime );
3710 CloseHandle(hReplacedFile);
3711 }
3712 else
3713 skip("couldn't open replacement file, skipping tests\n");
3714
3715 /* re-create replacement file for pass w/o backup (blank) */
3716 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
3717 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
3718 /* perform replacement w/o backup
3719 * TODO: flags are not implemented
3720 */
3721 SetLastError(0xdeadbeef);
3722 ret = pReplaceFileA(replaced, replacement, NULL, 0, 0, 0);
3724 "ReplaceFileA: unexpected error %d\n", GetLastError());
3725
3726 /* re-create replacement file for pass w/ backup (backup-file not existing) */
3727 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
3728 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
3730 ok(ret, "DeleteFileA: error (backup) %d\n", GetLastError());
3731 /* perform replacement w/ backup (no pre-existing backup)
3732 * TODO: flags are not implemented
3733 */
3734 SetLastError(0xdeadbeef);
3735 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
3737 "ReplaceFileA: unexpected error %d\n", GetLastError());
3738 if (ret)
3739 removeBackup = TRUE;
3740
3741 /* re-create replacement file for pass w/ no permissions to "replaced" */
3742 ret = GetTempFileNameA(temp_path, prefix, 0, replacement);
3743 ok(ret != 0, "GetTempFileNameA error (replacement) %d\n", GetLastError());
3746 "SetFileAttributesA: error setting to read only %d\n", GetLastError());
3747 /* perform replacement w/ backup (no permission to "replaced")
3748 * TODO: flags are not implemented
3749 */
3750 SetLastError(0xdeadbeef);
3751 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
3752 ok(ret != ERROR_UNABLE_TO_REMOVE_REPLACED, "ReplaceFileA: unexpected error %d\n", GetLastError());
3753 /* make sure that the replacement file still exists */
3754 hReplacementFile = CreateFileA(replacement, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
3755 ok(hReplacementFile != INVALID_HANDLE_VALUE ||
3756 broken(GetLastError() == ERROR_FILE_NOT_FOUND), /* win2k */
3757 "unexpected error, replacement file should still exist %d\n", GetLastError());
3758 CloseHandle(hReplacementFile);
3761 "SetFileAttributesA: error setting to normal %d\n", GetLastError());
3762
3763 /* replacement file still exists, make pass w/o "replaced" */
3764 ret = DeleteFileA(replaced);
3766 "DeleteFileA: error (replaced) %d\n", GetLastError());
3767 /* perform replacement w/ backup (no pre-existing backup or "replaced")
3768 * TODO: flags are not implemented
3769 */
3770 SetLastError(0xdeadbeef);
3771 ret = pReplaceFileA(replaced, replacement, backup, 0, 0, 0);
3774 "ReplaceFileA: unexpected error %d\n", GetLastError());
3775
3776 /* perform replacement w/o existing "replacement" file
3777 * TODO: flags are not implemented
3778 */
3779 SetLastError(0xdeadbeef);
3780 ret = pReplaceFileA(replaced, replacement, NULL, 0, 0, 0);
3783 "ReplaceFileA: unexpected error %d\n", GetLastError());
3784 DeleteFileA( replacement );
3785
3786 /*
3787 * if the first round (w/ backup) worked then as long as there is no
3788 * failure then there is no need to check this round (w/ backup is the
3789 * more complete case)
3790 */
3791
3792 /* delete temporary files, replacement and replaced are already deleted */
3793 if (removeBackup)
3794 {
3796 ok(ret ||
3797 broken(GetLastError() == ERROR_ACCESS_DENIED), /* win2k */
3798 "DeleteFileA: error (backup) %d\n", GetLastError());
3799 }
3800}
3801
3802/*
3803 * ReplaceFileW is a simpler case of ReplaceFileA, there is no
3804 * need to be as thorough.
3805 */
3806static void test_ReplaceFileW(void)
3807{
3808 WCHAR replaced[MAX_PATH], replacement[MAX_PATH], backup[MAX_PATH];
3809 static const WCHAR prefix[] = {'p','f','x',0};
3811 DWORD ret;
3812 BOOL removeBackup = FALSE;
3813
3814 if (!pReplaceFileW)
3815 {
3816 win_skip("ReplaceFileW() is missing\n");
3817 return;
3818 }
3819
3822 {
3823 win_skip("GetTempPathW is not available\n");
3824 return;
3825 }
3826 ok(ret != 0, "GetTempPathW error %d\n", GetLastError());
3827 ok(ret < MAX_PATH, "temp path should fit into MAX_PATH\n");
3828
3829 ret = GetTempFileNameW(temp_path, prefix, 0, replaced);
3830 ok(ret != 0, "GetTempFileNameW error (replaced) %d\n", GetLastError());
3831
3832 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3833 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3834
3835 ret = GetTempFileNameW(temp_path, prefix, 0, backup);
3836 ok(ret != 0, "GetTempFileNameW error (backup) %d\n", GetLastError());
3837
3838 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3839 ok(ret, "ReplaceFileW: error %d\n", GetLastError());
3840
3841 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3842 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3843 ret = pReplaceFileW(replaced, replacement, NULL, 0, 0, 0);
3845 "ReplaceFileW: error %d\n", GetLastError());
3846
3847 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3848 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3850 ok(ret, "DeleteFileW: error (backup) %d\n", GetLastError());
3851 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3853 "ReplaceFileW: error %d\n", GetLastError());
3854
3855 ret = GetTempFileNameW(temp_path, prefix, 0, replacement);
3856 ok(ret != 0, "GetTempFileNameW error (replacement) %d\n", GetLastError());
3859 "SetFileAttributesW: error setting to read only %d\n", GetLastError());
3860
3861 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3863 "ReplaceFileW: unexpected error %d\n", GetLastError());
3866 "SetFileAttributesW: error setting to normal %d\n", GetLastError());
3867 if (ret)
3868 removeBackup = TRUE;
3869
3870 ret = DeleteFileW(replaced);
3871 ok(ret, "DeleteFileW: error (replaced) %d\n", GetLastError());
3872 ret = pReplaceFileW(replaced, replacement, backup, 0, 0, 0);
3873 ok(!ret, "ReplaceFileW: error %d\n", GetLastError());
3874
3875 ret = pReplaceFileW(replaced, replacement, NULL, 0, 0, 0);
3878 "ReplaceFileW: unexpected error %d\n", GetLastError());
3879 DeleteFileW( replacement );
3880
3881 if (removeBackup)
3882 {
3884 ok(ret ||
3885 broken(GetLastError() == ERROR_ACCESS_DENIED), /* win2k */
3886 "DeleteFileW: error (backup) %d\n", GetLastError());
3887 }
3888}
3889
3890static void test_CreateFile(void)
3891{
3892 static const struct test_data
3893 {
3894 DWORD disposition, access, error, clean_up;
3895 } td[] =
3896 {
3897 /* 0 */ { 0, 0, ERROR_INVALID_PARAMETER, 0 },
3898 /* 1 */ { 0, GENERIC_READ, ERROR_INVALID_PARAMETER, 0 },
3900 /* 3 */ { CREATE_NEW, 0, ERROR_FILE_EXISTS, 1 },
3901 /* 4 */ { CREATE_NEW, 0, 0, 1 },
3902 /* 5 */ { CREATE_NEW, GENERIC_READ, 0, 1 },
3903 /* 6 */ { CREATE_NEW, GENERIC_WRITE, 0, 1 },
3904 /* 7 */ { CREATE_NEW, GENERIC_READ|GENERIC_WRITE, 0, 0 },
3905 /* 8 */ { CREATE_ALWAYS, 0, 0, 0 },
3906 /* 9 */ { CREATE_ALWAYS, GENERIC_READ, 0, 0 },
3907 /* 10*/ { CREATE_ALWAYS, GENERIC_WRITE, 0, 0 },
3908 /* 11*/ { CREATE_ALWAYS, GENERIC_READ|GENERIC_WRITE, 0, 1 },
3909 /* 12*/ { OPEN_EXISTING, 0, ERROR_FILE_NOT_FOUND, 0 },
3910 /* 13*/ { CREATE_ALWAYS, 0, 0, 0 },
3911 /* 14*/ { OPEN_EXISTING, 0, 0, 0 },
3912 /* 15*/ { OPEN_EXISTING, GENERIC_READ, 0, 0 },
3913 /* 16*/ { OPEN_EXISTING, GENERIC_WRITE, 0, 0 },
3914 /* 17*/ { OPEN_EXISTING, GENERIC_READ|GENERIC_WRITE, 0, 1 },
3915 /* 18*/ { OPEN_ALWAYS, 0, 0, 0 },
3916 /* 19*/ { OPEN_ALWAYS, GENERIC_READ, 0, 0 },
3917 /* 20*/ { OPEN_ALWAYS, GENERIC_WRITE, 0, 0 },
3918 /* 21*/ { OPEN_ALWAYS, GENERIC_READ|GENERIC_WRITE, 0, 0 },
3919 /* 22*/ { TRUNCATE_EXISTING, 0, ERROR_INVALID_PARAMETER, 0 },
3921 /* 24*/ { TRUNCATE_EXISTING, GENERIC_WRITE, 0, 0 },
3922 /* 25*/ { TRUNCATE_EXISTING, GENERIC_READ|GENERIC_WRITE, 0, 0 },
3924 };
3925 char temp_path[MAX_PATH];
3926 char file_name[MAX_PATH];
3927 DWORD i, ret, written;
3928 HANDLE hfile;
3929
3932
3933 i = strlen(temp_path);
3934 if (i && temp_path[i - 1] == '\\') temp_path[i - 1] = 0;
3935
3936 for (i = 0; i <= 5; i++)
3937 {
3938 SetLastError(0xdeadbeef);
3939 hfile = CreateFileA(temp_path, GENERIC_READ, 0, NULL, i, 0, 0);
3940 ok(hfile == INVALID_HANDLE_VALUE, "CreateFile should fail\n");
3941 if (i == 0 || i == 5)
3942 {
3943/* FIXME: remove once Wine is fixed */
3944todo_wine_if (i == 5)
3945 ok(GetLastError() == ERROR_INVALID_PARAMETER, "%d: expected ERROR_INVALID_PARAMETER, got %d\n", i, GetLastError());
3946 }
3947 else
3948 {
3949/* FIXME: remove once Wine is fixed */
3950todo_wine_if (i == 1)
3951 ok(GetLastError() == ERROR_ACCESS_DENIED, "%d: expected ERROR_ACCESS_DENIED, got %d\n", i, GetLastError());
3952 }
3953
3954 SetLastError(0xdeadbeef);
3955 hfile = CreateFileA(temp_path, GENERIC_WRITE, 0, NULL, i, 0, 0);
3956 ok(hfile == INVALID_HANDLE_VALUE, "CreateFile should fail\n");
3957 if (i == 0)
3958 ok(GetLastError() == ERROR_INVALID_PARAMETER, "%d: expected ERROR_INVALID_PARAMETER, got %d\n", i, GetLastError());
3959 else
3960 {
3961/* FIXME: remove once Wine is fixed */
3962todo_wine_if (i == 1)
3963 ok(GetLastError() == ERROR_ACCESS_DENIED, "%d: expected ERROR_ACCESS_DENIED, got %d\n", i, GetLastError());
3964 }
3965 }
3966
3967 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
3968 {
3969 SetLastError(0xdeadbeef);
3970 hfile = CreateFileA(file_name, td[i].access, 0, NULL, td[i].disposition, 0, 0);
3971 if (!td[i].error)
3972 {
3973 ok(hfile != INVALID_HANDLE_VALUE, "%d: CreateFile error %d\n", i, GetLastError());
3974 written = 0xdeadbeef;
3975 SetLastError(0xdeadbeef);
3976 ret = WriteFile(hfile, &td[i].error, sizeof(td[i].error), &written, NULL);
3977 if (td[i].access & GENERIC_WRITE)
3978 ok(ret, "%d: WriteFile error %d\n", i, GetLastError());
3979 else
3980 {
3981 ok(!ret, "%d: WriteFile should fail\n", i);
3982 ok(GetLastError() == ERROR_ACCESS_DENIED, "%d: expected ERROR_ACCESS_DENIED, got %d\n", i, GetLastError());
3983 }
3984 SetLastError(0xdeadbeef);
3985 ret = SetFileTime(hfile, NULL, NULL, NULL);
3986 if (td[i].access & GENERIC_WRITE) /* actually FILE_WRITE_ATTRIBUTES */
3987 ok(ret, "%d: SetFileTime error %d\n", i, GetLastError());
3988 else
3989 {
3990 todo_wine
3991 {
3992 ok(!ret, "%d: SetFileTime should fail\n", i);
3993 ok(GetLastError() == ERROR_ACCESS_DENIED, "%d: expected ERROR_ACCESS_DENIED, got %d\n", i, GetLastError());
3994 }
3995 }
3996 CloseHandle(hfile);
3997 }
3998 else
3999 {
4000 /* FIXME: remove the condition below once Wine is fixed */
4001 if (td[i].disposition == TRUNCATE_EXISTING && !(td[i].access & GENERIC_WRITE))
4002 {
4003 todo_wine
4004 {
4005 ok(hfile == INVALID_HANDLE_VALUE, "%d: CreateFile should fail\n", i);
4006 ok(GetLastError() == td[i].error, "%d: expected %d, got %d\n", i, td[i].error, GetLastError());
4007 }
4008 CloseHandle(hfile);
4009 }
4010 else
4011 {
4012 ok(hfile == INVALID_HANDLE_VALUE, "%d: CreateFile should fail\n", i);
4013 ok(GetLastError() == td[i].error, "%d: expected %d, got %d\n", i, td[i].error, GetLastError());
4014 }
4015 }
4016
4017 if (td[i].clean_up) DeleteFileA(file_name);
4018 }
4019
4021}
4022
4024{
4025 int i;
4026 char tempPath[MAX_PATH], tempFileName[MAX_PATH], buffer[1024], *strPtr;
4027 BOOL ret;
4028 DWORD ret2, written;
4030 FILE_ID_BOTH_DIR_INFO *bothDirInfo;
4031 FILE_BASIC_INFO *basicInfo;
4032 FILE_STANDARD_INFO *standardInfo;
4033 FILE_NAME_INFO *nameInfo;
4034 LARGE_INTEGER prevWrite;
4035 FILE_IO_PRIORITY_HINT_INFO priohintinfo;
4036 FILE_ALLOCATION_INFO allocinfo;
4037 FILE_DISPOSITION_INFO dispinfo;
4038 FILE_END_OF_FILE_INFO eofinfo;
4039 FILE_RENAME_INFO renameinfo;
4040
4041 struct {
4042 FILE_INFO_BY_HANDLE_CLASS handleClass;
4043 void *ptr;
4044 DWORD size;
4045 DWORD errorCode;
4046 } checks[] = {
4047 {0xdeadbeef, NULL, 0, ERROR_INVALID_PARAMETER},
4048 {FileIdBothDirectoryInfo, NULL, 0, ERROR_BAD_LENGTH},
4049 {FileIdBothDirectoryInfo, NULL, sizeof(buffer), ERROR_NOACCESS},
4050 {FileIdBothDirectoryInfo, buffer, 0, ERROR_BAD_LENGTH}};
4051
4052 if (!pGetFileInformationByHandleEx)
4053 {
4054 win_skip("GetFileInformationByHandleEx is missing.\n");
4055 return;
4056 }
4057
4058 ret2 = GetTempPathA(sizeof(tempPath), tempPath);
4059 ok(ret2, "GetFileInformationByHandleEx: GetTempPathA failed, got error %u.\n", GetLastError());
4060
4061 /* ensure the existence of a file in the temp folder */
4062 ret2 = GetTempFileNameA(tempPath, "abc", 0, tempFileName);
4063 ok(ret2, "GetFileInformationByHandleEx: GetTempFileNameA failed, got error %u.\n", GetLastError());
4064 ret2 = GetFileAttributesA(tempFileName);
4065 ok(ret2 != INVALID_FILE_ATTRIBUTES, "GetFileInformationByHandleEx: "
4066 "GetFileAttributesA failed to find the temp file, got error %u.\n", GetLastError());
4067
4070 ok(directory != INVALID_HANDLE_VALUE, "GetFileInformationByHandleEx: failed to open the temp folder, "
4071 "got error %u.\n", GetLastError());
4072
4073 for (i = 0; i < sizeof(checks) / sizeof(checks[0]); i += 1)
4074 {
4075 SetLastError(0xdeadbeef);
4076 ret = pGetFileInformationByHandleEx(directory, checks[i].handleClass, checks[i].ptr, checks[i].size);
4077 ok(!ret && GetLastError() == checks[i].errorCode, "GetFileInformationByHandleEx: expected error %u, "
4078 "got %u.\n", checks[i].errorCode, GetLastError());
4079 }
4080
4081 while (TRUE)
4082 {
4083 memset(buffer, 0xff, sizeof(buffer));
4084 ret = pGetFileInformationByHandleEx(directory, FileIdBothDirectoryInfo, buffer, sizeof(buffer));
4086 break;
4087 ok(ret, "GetFileInformationByHandleEx: failed to query for FileIdBothDirectoryInfo, got error %u.\n", GetLastError());
4088 if (!ret)
4089 break;
4090 bothDirInfo = (FILE_ID_BOTH_DIR_INFO *)buffer;
4091 while (TRUE)
4092 {
4093 ok(bothDirInfo->FileAttributes != 0xffffffff, "GetFileInformationByHandleEx: returned invalid file attributes.\n");
4094 ok(bothDirInfo->FileId.u.LowPart != 0xffffffff, "GetFileInformationByHandleEx: returned invalid file id.\n");
4095 ok(bothDirInfo->FileNameLength != 0xffffffff, "GetFileInformationByHandleEx: returned invalid file name length.\n");
4096 if (!bothDirInfo->NextEntryOffset)
4097 break;
4098 bothDirInfo = (FILE_ID_BOTH_DIR_INFO *)(((char *)bothDirInfo) + bothDirInfo->NextEntryOffset);
4099 }
4100 }
4101
4103
4105 NULL, OPEN_EXISTING, 0, NULL);
4106 ok(file != INVALID_HANDLE_VALUE, "GetFileInformationByHandleEx: failed to open the temp file, "
4107 "got error %u.\n", GetLastError());
4108
4109 /* Test FileBasicInfo; make sure the write time changes when a file is updated */
4110 memset(buffer, 0xff, sizeof(buffer));
4111 ret = pGetFileInformationByHandleEx(file, FileBasicInfo, buffer, sizeof(buffer));
4112 ok(ret, "GetFileInformationByHandleEx: failed to get FileBasicInfo, %u\n", GetLastError());
4113 basicInfo = (FILE_BASIC_INFO *)buffer;
4114 prevWrite = basicInfo->LastWriteTime;
4116
4117 Sleep(30); /* Make sure a new write time is different from the previous */
4118
4119 /* Write something to the file, to make sure the write time has changed */
4121 NULL, OPEN_EXISTING, 0, NULL);
4122 ok(file != INVALID_HANDLE_VALUE, "GetFileInformationByHandleEx: failed to open the temp file, "
4123 "got error %u.\n", GetLastError());
4124 ret = WriteFile(file, tempFileName, strlen(tempFileName), &written, NULL);
4125 ok(ret, "GetFileInformationByHandleEx: Write failed\n");
4127
4129 NULL, OPEN_EXISTING, 0, NULL);
4130 ok(file != INVALID_HANDLE_VALUE, "GetFileInformationByHandleEx: failed to open the temp file, "
4131 "got error %u.\n", GetLastError());
4132
4133 memset(buffer, 0xff, sizeof(buffer));
4134 ret = pGetFileInformationByHandleEx(file, FileBasicInfo, buffer, sizeof(buffer));
4135 ok(ret, "GetFileInformationByHandleEx: failed to get FileBasicInfo, %u\n", GetLastError());
4136 basicInfo = (FILE_BASIC_INFO *)buffer;
4137 /* Could also check that the creation time didn't change - on windows
4138 * it doesn't, but on wine, it does change even if it shouldn't. */
4139 ok(basicInfo->LastWriteTime.QuadPart != prevWrite.QuadPart,
4140 "GetFileInformationByHandleEx: last write time didn't change\n");
4141
4142 /* Test FileStandardInfo, check some basic parameters */
4143 memset(buffer, 0xff, sizeof(buffer));
4144 ret = pGetFileInformationByHandleEx(file, FileStandardInfo, buffer, sizeof(buffer));
4145 ok(ret, "GetFileInformationByHandleEx: failed to get FileStandardInfo, %u\n", GetLastError());
4146 standardInfo = (FILE_STANDARD_INFO *)buffer;
4147 ok(standardInfo->NumberOfLinks == 1, "GetFileInformationByHandleEx: Unexpected number of links\n");
4148 ok(standardInfo->DeletePending == FALSE, "GetFileInformationByHandleEx: Unexpected pending delete\n");
4149 ok(standardInfo->Directory == FALSE, "GetFileInformationByHandleEx: Incorrect directory flag\n");
4150
4151 /* Test FileNameInfo */
4152 memset(buffer, 0xff, sizeof(buffer));
4153 ret = pGetFileInformationByHandleEx(file, FileNameInfo, buffer, sizeof(buffer));
4154 ok(ret, "GetFileInformationByHandleEx: failed to get FileNameInfo, %u\n", GetLastError());
4155 nameInfo = (FILE_NAME_INFO *)buffer;
4156 strPtr = strchr(tempFileName, '\\');
4157 ok(strPtr != NULL, "GetFileInformationByHandleEx: Temp filename didn't contain backslash\n");
4158 ok(nameInfo->FileNameLength == strlen(strPtr) * 2,
4159 "GetFileInformationByHandleEx: Incorrect file name length\n");
4160 for (i = 0; i < nameInfo->FileNameLength/2; i++)
4161 ok(strPtr[i] == nameInfo->FileName[i], "Incorrect filename char %d: %c vs %c\n",
4162 i, strPtr[i], nameInfo->FileName[i]);
4163
4164 /* invalid classes */
4165 SetLastError(0xdeadbeef);
4166 ret = pGetFileInformationByHandleEx(file, FileEndOfFileInfo, &eofinfo, sizeof(eofinfo));
4167 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4168
4169 SetLastError(0xdeadbeef);
4170 ret = pGetFileInformationByHandleEx(file, FileIoPriorityHintInfo, &priohintinfo, sizeof(priohintinfo));
4171 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4172
4173 SetLastError(0xdeadbeef);
4174 ret = pGetFileInformationByHandleEx(file, FileAllocationInfo, &allocinfo, sizeof(allocinfo));
4175 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4176
4177 SetLastError(0xdeadbeef);
4178 ret = pGetFileInformationByHandleEx(file, FileDispositionInfo, &dispinfo, sizeof(dispinfo));
4179 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4180
4181 SetLastError(0xdeadbeef);
4182 ret = pGetFileInformationByHandleEx(file, FileRenameInfo, &renameinfo, sizeof(renameinfo));
4183 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4184
4186 DeleteFileA(tempFileName);
4187}
4188
4189static void test_OpenFileById(void)
4190{
4191 char tempPath[MAX_PATH], tempFileName[MAX_PATH], buffer[256], tickCount[256];
4192 WCHAR tempFileNameW[MAX_PATH];
4193 BOOL ret, found;
4194 DWORD ret2, count, tempFileNameLen;
4195 HANDLE directory, handle, tempFile;
4196 FILE_ID_BOTH_DIR_INFO *bothDirInfo;
4197 FILE_ID_DESCRIPTOR fileIdDescr;
4198
4199 if (!pGetFileInformationByHandleEx || !pOpenFileById)
4200 {
4201 win_skip("GetFileInformationByHandleEx or OpenFileById is missing.\n");
4202 return;
4203 }
4204
4205 ret2 = GetTempPathA(sizeof(tempPath), tempPath);
4206 ok(ret2, "OpenFileById: GetTempPath failed, got error %u.\n", GetLastError());
4207
4208 /* ensure the existence of a file in the temp folder */
4209 ret2 = GetTempFileNameA(tempPath, "abc", 0, tempFileName);
4210 ok(ret2, "OpenFileById: GetTempFileNameA failed, got error %u.\n", GetLastError());
4211 ret2 = GetFileAttributesA(tempFileName);
4213 "OpenFileById: GetFileAttributesA failed to find the temp file, got error %u\n", GetLastError());
4214
4215 ret2 = MultiByteToWideChar(CP_ACP, 0, tempFileName + strlen(tempPath), -1, tempFileNameW, sizeof(tempFileNameW)/sizeof(tempFileNameW[0]));
4216 ok(ret2, "OpenFileById: MultiByteToWideChar failed to convert tempFileName, got error %u.\n", GetLastError());
4217 tempFileNameLen = ret2 - 1;
4218
4220 ok(tempFile != INVALID_HANDLE_VALUE, "OpenFileById: failed to create a temp file, "
4221 "got error %u.\n", GetLastError());
4222 ret2 = sprintf(tickCount, "%u", GetTickCount());
4223 ret = WriteFile(tempFile, tickCount, ret2, &count, NULL);
4224 ok(ret, "OpenFileById: WriteFile failed, got error %u.\n", GetLastError());
4225 CloseHandle(tempFile);
4226
4229 ok(directory != INVALID_HANDLE_VALUE, "OpenFileById: failed to open the temp folder, "
4230 "got error %u.\n", GetLastError());
4231
4232 /* get info about the temp folder itself */
4233 bothDirInfo = (FILE_ID_BOTH_DIR_INFO *)buffer;
4234 ret = pGetFileInformationByHandleEx(directory, FileIdBothDirectoryInfo, buffer, sizeof(buffer));
4235 ok(ret, "OpenFileById: failed to query for FileIdBothDirectoryInfo, got error %u.\n", GetLastError());
4236 ok(bothDirInfo->FileNameLength == sizeof(WCHAR) && bothDirInfo->FileName[0] == '.',
4237 "OpenFileById: failed to return the temp folder at the first entry, got error %u.\n", GetLastError());
4238
4239 /* open the temp folder itself */
4240 fileIdDescr.dwSize = sizeof(fileIdDescr);
4241 fileIdDescr.Type = FileIdType;
4242 U(fileIdDescr).FileId = bothDirInfo->FileId;
4243 handle = pOpenFileById(directory, &fileIdDescr, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, 0);
4244 todo_wine
4245 ok(handle != INVALID_HANDLE_VALUE, "OpenFileById: failed to open the temp folder itself, got error %u.\n", GetLastError());
4247
4248 /* find the temp file in the temp folder */
4249 found = FALSE;
4250 while (!found)
4251 {
4252 ret = pGetFileInformationByHandleEx(directory, FileIdBothDirectoryInfo, buffer, sizeof(buffer));
4253 ok(ret, "OpenFileById: failed to query for FileIdBothDirectoryInfo, got error %u.\n", GetLastError());
4254 if (!ret)
4255 break;
4256 bothDirInfo = (FILE_ID_BOTH_DIR_INFO *)buffer;
4257 while (TRUE)
4258 {
4259 if (tempFileNameLen == bothDirInfo->FileNameLength / sizeof(WCHAR) &&
4260 memcmp(tempFileNameW, bothDirInfo->FileName, bothDirInfo->FileNameLength) == 0)
4261 {
4262 found = TRUE;
4263 break;
4264 }
4265 if (!bothDirInfo->NextEntryOffset)
4266 break;
4267 bothDirInfo = (FILE_ID_BOTH_DIR_INFO *)(((char *)bothDirInfo) + bothDirInfo->NextEntryOffset);
4268 }
4269 }
4270 ok(found, "OpenFileById: failed to find the temp file in the temp folder.\n");
4271
4272 SetLastError(0xdeadbeef);
4275 "OpenFileById: expected ERROR_INVALID_PARAMETER, got error %u.\n", GetLastError());
4276
4277 fileIdDescr.dwSize = sizeof(fileIdDescr);
4278 fileIdDescr.Type = FileIdType;
4279 U(fileIdDescr).FileId = bothDirInfo->FileId;
4280 handle = pOpenFileById(directory, &fileIdDescr, GENERIC_READ, FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE, NULL, 0);
4281 ok(handle != INVALID_HANDLE_VALUE, "OpenFileById: failed to open the file, got error %u.\n", GetLastError());
4282
4283 ret = ReadFile(handle, buffer, sizeof(buffer), &count, NULL);
4284 buffer[count] = 0;
4285 ok(ret, "OpenFileById: ReadFile failed, got error %u.\n", GetLastError());
4286 ok(strcmp(tickCount, buffer) == 0, "OpenFileById: invalid contents of the temp file.\n");
4287
4290 DeleteFileA(tempFileName);
4291}
4292
4293static void test_SetFileValidData(void)
4294{
4295 BOOL ret;
4296 HANDLE handle;
4297 DWORD error, count;
4299 TOKEN_PRIVILEGES privs;
4300 HANDLE token = NULL;
4301
4302 if (!pSetFileValidData)
4303 {
4304 win_skip("SetFileValidData is missing\n");
4305 return;
4306 }
4307 GetTempPathA(sizeof(path), path);
4308 GetTempFileNameA(path, "tst", 0, filename);
4310 WriteFile(handle, "test", sizeof("test") - 1, &count, NULL);
4312
4313 SetLastError(0xdeadbeef);
4314 ret = pSetFileValidData(INVALID_HANDLE_VALUE, 0);
4315 error = GetLastError();
4316 ok(!ret, "SetFileValidData succeeded\n");
4317 ok(error == ERROR_INVALID_HANDLE, "got %u\n", error);
4318
4319 SetLastError(0xdeadbeef);
4320 ret = pSetFileValidData(INVALID_HANDLE_VALUE, -1);
4321 error = GetLastError();
4322 ok(!ret, "SetFileValidData succeeded\n");
4323 ok(error == ERROR_INVALID_HANDLE, "got %u\n", error);
4324
4325 /* file opened for reading */
4327
4328 SetLastError(0xdeadbeef);
4329 ret = pSetFileValidData(handle, 0);
4330 ok(!ret, "SetFileValidData succeeded\n");
4331 error = GetLastError();
4332 ok(error == ERROR_ACCESS_DENIED, "got %u\n", error);
4333
4334 SetLastError(0xdeadbeef);
4335 ret = pSetFileValidData(handle, -1);
4336 error = GetLastError();
4337 ok(!ret, "SetFileValidData succeeded\n");
4338 ok(error == ERROR_ACCESS_DENIED, "got %u\n", error);
4340
4342
4343 SetLastError(0xdeadbeef);
4344 ret = pSetFileValidData(handle, 0);
4345 error = GetLastError();
4346 ok(!ret, "SetFileValidData succeeded\n");
4349
4350 privs.PrivilegeCount = 1;
4352
4355 !AdjustTokenPrivileges(token, FALSE, &privs, sizeof(privs), NULL, NULL) ||
4357 {
4358 win_skip("cannot enable SE_MANAGE_VOLUME_NAME privilege\n");
4361 return;
4362 }
4364
4365 SetLastError(0xdeadbeef);
4366 ret = pSetFileValidData(handle, 0);
4367 error = GetLastError();
4368 ok(!ret, "SetFileValidData succeeded\n");
4369 ok(error == ERROR_INVALID_PARAMETER, "got %u\n", error);
4370
4371 SetLastError(0xdeadbeef);
4372 ret = pSetFileValidData(handle, -1);
4373 error = GetLastError();
4374 ok(!ret, "SetFileValidData succeeded\n");
4375 ok(error == ERROR_INVALID_PARAMETER, "got %u\n", error);
4376
4377 SetLastError(0xdeadbeef);
4378 ret = pSetFileValidData(handle, 2);
4379 error = GetLastError();
4380 todo_wine ok(!ret, "SetFileValidData succeeded\n");
4382
4383 ret = pSetFileValidData(handle, 4);
4384 ok(ret, "SetFileValidData failed %u\n", GetLastError());
4385
4386 SetLastError(0xdeadbeef);
4387 ret = pSetFileValidData(handle, 8);
4388 error = GetLastError();
4389 ok(!ret, "SetFileValidData succeeded\n");
4390 ok(error == ERROR_INVALID_PARAMETER, "got %u\n", error);
4391
4393 ok(count != INVALID_SET_FILE_POINTER, "SetFilePointer failed %u\n", GetLastError());
4395 ok(ret, "SetEndOfFile failed %u\n", GetLastError());
4396
4397 SetLastError(0xdeadbeef);
4398 ret = pSetFileValidData(handle, 2);
4399 error = GetLastError();
4400 todo_wine ok(!ret, "SetFileValidData succeeded\n");
4402
4403 ret = pSetFileValidData(handle, 4);
4404 ok(ret, "SetFileValidData failed %u\n", GetLastError());
4405
4406 ret = pSetFileValidData(handle, 8);
4407 ok(ret, "SetFileValidData failed %u\n", GetLastError());
4408
4409 ret = pSetFileValidData(handle, 4);
4410 error = GetLastError();
4411 todo_wine ok(!ret, "SetFileValidData succeeded\n");
4413
4414 ret = pSetFileValidData(handle, 1024);
4415 ok(ret, "SetFileValidData failed %u\n", GetLastError());
4416
4417 ret = pSetFileValidData(handle, 2048);
4418 error = GetLastError();
4419 ok(!ret, "SetFileValidData succeeded\n");
4420 ok(error == ERROR_INVALID_PARAMETER, "got %u\n", error);
4421
4422 privs.Privileges[0].Attributes = 0;
4423 AdjustTokenPrivileges(token, FALSE, &privs, sizeof(privs), NULL, NULL);
4424
4428}
4429
4430static void test_WriteFileGather(void)
4431{
4433 HANDLE hfile, hiocp1, hiocp2;
4434 DWORD ret, size;
4435 ULONG_PTR key;
4436 FILE_SEGMENT_ELEMENT fse[2];
4437 OVERLAPPED ovl, *povl = NULL;
4438 SYSTEM_INFO si;
4439 LPVOID buf = NULL;
4440
4442 ok( ret != 0, "GetTempPathA error %d\n", GetLastError() );
4443 ok( ret < MAX_PATH, "temp path should fit into MAX_PATH\n" );
4444 ret = GetTempFileNameA( temp_path, "wfg", 0, filename );
4445 ok( ret != 0, "GetTempFileNameA error %d\n", GetLastError() );
4446
4449 ok( hfile != INVALID_HANDLE_VALUE, "CreateFile failed err %u\n", GetLastError() );
4450 if (hfile == INVALID_HANDLE_VALUE) return;
4451
4453 hiocp2 = CreateIoCompletionPort( hfile, hiocp1, 999, 0 );
4454 ok( hiocp2 != 0, "CreateIoCompletionPort failed err %u\n", GetLastError() );
4455
4456 GetSystemInfo( &si );
4458 ok( buf != NULL, "VirtualAlloc failed err %u\n", GetLastError() );
4459
4460 memset( &ovl, 0, sizeof(ovl) );
4461 memset( fse, 0, sizeof(fse) );
4462 fse[0].Buffer = buf;
4463 if (!WriteFileGather( hfile, fse, si.dwPageSize, NULL, &ovl ))
4464 ok( GetLastError() == ERROR_IO_PENDING, "WriteFileGather failed err %u\n", GetLastError() );
4465
4466 ret = GetQueuedCompletionStatus( hiocp2, &size, &key, &povl, 1000 );
4467 ok( ret, "GetQueuedCompletionStatus failed err %u\n", GetLastError());
4468 ok( povl == &ovl, "wrong ovl %p\n", povl );
4469
4470 memset( &ovl, 0, sizeof(ovl) );
4471 memset( fse, 0, sizeof(fse) );
4472 fse[0].Buffer = buf;
4473 if (!ReadFileScatter( hfile, fse, si.dwPageSize, NULL, &ovl ))
4474 ok( GetLastError() == ERROR_IO_PENDING, "ReadFileScatter failed err %u\n", GetLastError() );
4475
4476 ret = GetQueuedCompletionStatus( hiocp2, &size, &key, &povl, 1000 );
4477 ok( ret, "GetQueuedCompletionStatus failed err %u\n", GetLastError());
4478 ok( povl == &ovl, "wrong ovl %p\n", povl );
4479
4480 CloseHandle( hfile );
4481 CloseHandle( hiocp1 );
4482 CloseHandle( hiocp2 );
4485}
4486
4487static unsigned file_map_access(unsigned access)
4488{
4494}
4495
4496static BOOL is_access_compatible(unsigned obj_access, unsigned desired_access)
4497{
4498 obj_access = file_map_access(obj_access);
4499 desired_access = file_map_access(desired_access);
4500 return (obj_access & desired_access) == desired_access;
4501}
4502
4503static void test_file_access(void)
4504{
4505 static const struct
4506 {
4507 unsigned access, create_error, write_error, read_error;
4508 } td[] =
4509 {
4510 { GENERIC_READ | GENERIC_WRITE, 0, 0, 0 },
4513 { FILE_READ_DATA | FILE_WRITE_DATA, 0, 0, 0 },
4517 { FILE_READ_DATA | FILE_APPEND_DATA, 0, 0, 0 },
4520 };
4521 char path[MAX_PATH], fname[MAX_PATH];
4522 unsigned char buf[16];
4523 HANDLE hfile, hdup;
4524 DWORD i, j, ret, bytes;
4525
4527 GetTempFileNameA(path, "foo", 0, fname);
4528
4529 for (i = 0; i < sizeof(td)/sizeof(td[0]); i++)
4530 {
4531 SetLastError(0xdeadbeef);
4532 hfile = CreateFileA(fname, td[i].access, 0, NULL, CREATE_ALWAYS,
4534 if (td[i].create_error)
4535 {
4536 ok(hfile == INVALID_HANDLE_VALUE, "%d: CreateFile should fail\n", i);
4537 ok(td[i].create_error == GetLastError(), "%d: expected %d, got %d\n", i, td[i].create_error, GetLastError());
4538 continue;
4539 }
4540 else
4541 ok(hfile != INVALID_HANDLE_VALUE, "%d: CreateFile error %d\n", i, GetLastError());
4542
4543 for (j = 0; j < sizeof(td)/sizeof(td[0]); j++)
4544 {
4545 SetLastError(0xdeadbeef);
4547 td[j].access, 0, 0);
4548 if (is_access_compatible(td[i].access, td[j].access))
4549 ok(ret, "DuplicateHandle(%#x => %#x) error %d\n", td[i].access, td[j].access, GetLastError());
4550 else
4551 {
4552 /* FIXME: Remove once Wine is fixed */
4554 (!(td[i].access & (GENERIC_WRITE | FILE_WRITE_DATA)) && (td[j].access & FILE_WRITE_DATA)) ||
4555 (!(td[i].access & (GENERIC_READ | FILE_READ_DATA)) && (td[j].access & FILE_READ_DATA)) ||
4556 (!(td[i].access & (GENERIC_WRITE)) && (td[j].access & FILE_APPEND_DATA))))
4557 {
4558 ok(!ret, "DuplicateHandle(%#x => %#x) should fail\n", td[i].access, td[j].access);
4559 ok(GetLastError() == ERROR_ACCESS_DENIED, "expected ERROR_ACCESS_DENIED, got %d\n", GetLastError());
4560 }
4561 }
4562 if (ret) CloseHandle(hdup);
4563 }
4564
4565 SetLastError(0xdeadbeef);
4566 bytes = 0xdeadbeef;
4567 ret = WriteFile(hfile, "\x5e\xa7", 2, &bytes, NULL);
4568 if (td[i].write_error)
4569 {
4570 ok(!ret, "%d: WriteFile should fail\n", i);
4571 ok(td[i].write_error == GetLastError(), "%d: expected %d, got %d\n", i, td[i].write_error, GetLastError());
4572 ok(bytes == 0, "%d: expected 0, got %u\n", i, bytes);
4573 }
4574 else
4575 {
4576 ok(ret, "%d: WriteFile error %d\n", i, GetLastError());
4577 ok(bytes == 2, "%d: expected 2, got %u\n", i, bytes);
4578 }
4579
4580 SetLastError(0xdeadbeef);
4581 ret = SetFilePointer(hfile, 0, NULL, FILE_BEGIN);
4582 ok(ret != INVALID_SET_FILE_POINTER, "SetFilePointer error %d\n", GetLastError());
4583
4584 SetLastError(0xdeadbeef);
4585 bytes = 0xdeadbeef;
4586 ret = ReadFile(hfile, buf, sizeof(buf), &bytes, NULL);
4587 if (td[i].read_error)
4588 {
4589 ok(!ret, "%d: ReadFile should fail\n", i);
4590 ok(td[i].read_error == GetLastError(), "%d: expected %d, got %d\n", i, td[i].read_error, GetLastError());
4591 ok(bytes == 0, "%d: expected 0, got %u\n", i, bytes);
4592 }
4593 else
4594 {
4595 ok(ret, "%d: ReadFile error %d\n", i, GetLastError());
4596 if (td[i].write_error)
4597 ok(bytes == 0, "%d: expected 0, got %u\n", i, bytes);
4598 else
4599 {
4600 ok(bytes == 2, "%d: expected 2, got %u\n", i, bytes);
4601 ok(buf[0] == 0x5e && buf[1] == 0xa7, "%d: expected 5ea7, got %02x%02x\n", i, buf[0], buf[1]);
4602 }
4603 }
4604
4605 CloseHandle(hfile);
4606 }
4607}
4608
4610{
4611 static char prefix[] = "GetFinalPathNameByHandleA";
4612 static char dos_prefix[] = "\\\\?\\";
4613 char temp_path[MAX_PATH], test_path[MAX_PATH];
4614 char long_path[MAX_PATH], result_path[MAX_PATH];
4615 char dos_path[MAX_PATH + sizeof(dos_prefix)];
4616 HANDLE file;
4617 DWORD count;
4618 UINT ret;
4619
4620 if (!pGetFinalPathNameByHandleA)
4621 {
4622 skip("GetFinalPathNameByHandleA is missing\n");
4623 return;
4624 }
4625
4626 /* Test calling with INVALID_HANDLE_VALUE */
4627 SetLastError(0xdeadbeaf);
4628 count = pGetFinalPathNameByHandleA(INVALID_HANDLE_VALUE, result_path, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4629 ok(count == 0, "Expected length 0, got %u\n", count);
4630 ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %u\n", GetLastError());
4631
4633 ok(count, "Failed to get temp path, error %u\n", GetLastError());
4634 ret = GetTempFileNameA(temp_path, prefix, 0, test_path);
4635 ok(ret != 0, "GetTempFileNameA error %u\n", GetLastError());
4636 ret = GetLongPathNameA(test_path, long_path, MAX_PATH);
4637 ok(ret != 0, "GetLongPathNameA error %u\n", GetLastError());
4638 strcpy(dos_path, dos_prefix);
4639 strcat(dos_path, long_path);
4640
4641 count = pGetFinalPathNameByHandleA(INVALID_HANDLE_VALUE, NULL, 0, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4642 ok(count == 0, "Expected length 0, got %u\n", count);
4643 ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %u\n", GetLastError());
4644
4645 file = CreateFileA(test_path, GENERIC_READ | GENERIC_WRITE, 0, NULL,
4647 ok(file != INVALID_HANDLE_VALUE, "CreateFileA error %u\n", GetLastError());
4648
4649 if (0) {
4650 /* Windows crashes on NULL path */
4651 count = pGetFinalPathNameByHandleA(file, NULL, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4652 ok(count == 0, "Expected length 0, got %u\n", count);
4653 ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %u\n", GetLastError());
4654 }
4655
4656 /* Test 0-length path */
4657 count = pGetFinalPathNameByHandleA(file, result_path, 0, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4658 ok(count == strlen(dos_path), "Expected length %u, got %u\n", lstrlenA(dos_path), count);
4659
4660 /* Test 0 and NULL path */
4661 count = pGetFinalPathNameByHandleA(file, NULL, 0, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4662 ok(count == strlen(dos_path), "Expected length %u, got %u\n", lstrlenA(dos_path), count);
4663
4664 /* Test VOLUME_NAME_DOS with sufficient buffer size */
4665 memset(result_path, 0x11, sizeof(result_path));
4666 count = pGetFinalPathNameByHandleA(file, result_path, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4667 ok(count == strlen(dos_path), "Expected length %u, got %u\n", (DWORD)strlen(dos_path), count);
4668 ok(lstrcmpiA(dos_path, result_path) == 0, "Expected %s, got %s\n", dos_path, result_path);
4669
4670 /* Test VOLUME_NAME_DOS with insufficient buffer size */
4671 memset(result_path, 0x11, sizeof(result_path));
4672 count = pGetFinalPathNameByHandleA(file, result_path, strlen(dos_path)-2, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4673 ok(count == strlen(dos_path), "Expected length %u, got %u\n", (DWORD)strlen(dos_path), count);
4674 ok(result_path[0] == 0x11, "Result path was modified\n");
4675
4676 memset(result_path, 0x11, sizeof(result_path));
4677 count = pGetFinalPathNameByHandleA(file, result_path, strlen(dos_path)-1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4678 ok(count == strlen(dos_path), "Expected length %u, got %u\n", (DWORD)strlen(dos_path), count);
4679 ok(result_path[0] == 0x11, "Result path was modified\n");
4680
4681 memset(result_path, 0x11, sizeof(result_path));
4682 count = pGetFinalPathNameByHandleA(file, result_path, strlen(dos_path), FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4683 ok(count == strlen(dos_path), "Expected length %u, got %u\n", (DWORD)strlen(dos_path), count);
4684 ok(result_path[0] == 0x11, "Result path was modified\n");
4685
4686 memset(result_path, 0x11, sizeof(result_path));
4687 count = pGetFinalPathNameByHandleA(file, result_path, strlen(dos_path)+1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4688 ok(count == strlen(dos_path), "Expected length %u, got %u\n", (DWORD)strlen(dos_path), count);
4689 ok(result_path[0] != 0x11, "Result path was not modified\n");
4690 ok(!result_path[strlen(dos_path)], "Expected nullterminated string\n");
4691 ok(result_path[strlen(dos_path)+1] == 0x11, "Buffer overflow\n");
4692
4694}
4695
4697{
4698 static WCHAR prefix[] = {'G','e','t','F','i','n','a','l','P','a','t','h',
4699 'N','a','m','e','B','y','H','a','n','d','l','e','W','\0'};
4700 static WCHAR dos_prefix[] = {'\\','\\','?','\\','\0'};
4701 WCHAR temp_path[MAX_PATH], test_path[MAX_PATH];
4702 WCHAR long_path[MAX_PATH], result_path[MAX_PATH];
4703 WCHAR dos_path[MAX_PATH + sizeof(dos_prefix)];
4704 WCHAR drive_part[MAX_PATH];
4705 WCHAR *file_part;
4706 WCHAR volume_path[MAX_PATH + 50];
4707 WCHAR nt_path[2 * MAX_PATH];
4708 BOOL success;
4709 HANDLE file;
4710 DWORD count;
4711 UINT ret;
4712
4713 if (!pGetFinalPathNameByHandleW)
4714 {
4715 skip("GetFinalPathNameByHandleW is missing\n");
4716 return;
4717 }
4718
4719 /* Test calling with INVALID_HANDLE_VALUE */
4720 SetLastError(0xdeadbeaf);
4721 count = pGetFinalPathNameByHandleW(INVALID_HANDLE_VALUE, result_path, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4722 ok(count == 0, "Expected length 0, got %u\n", count);
4723 ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %u\n", GetLastError());
4724
4725 count = pGetFinalPathNameByHandleW(INVALID_HANDLE_VALUE, NULL, 0, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4726 ok(count == 0, "Expected length 0, got %u\n", count);
4727 ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %u\n", GetLastError());
4728
4730 ok(count, "Failed to get temp path, error %u\n", GetLastError());
4731 ret = GetTempFileNameW(temp_path, prefix, 0, test_path);
4732 ok(ret != 0, "GetTempFileNameW error %u\n", GetLastError());
4733 ret = GetLongPathNameW(test_path, long_path, MAX_PATH);
4734 ok(ret != 0, "GetLongPathNameW error %u\n", GetLastError());
4735 lstrcpyW(dos_path, dos_prefix);
4736 lstrcatW(dos_path, long_path);
4737
4738 file = CreateFileW(test_path, GENERIC_READ | GENERIC_WRITE, 0, NULL,
4740 ok(file != INVALID_HANDLE_VALUE, "CreateFileW error %u\n", GetLastError());
4741
4742 if (0) {
4743 /* Windows crashes on NULL path */
4744 count = pGetFinalPathNameByHandleW(file, NULL, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4745 ok(count == 0, "Expected length 0, got %u\n", count);
4746 ok(GetLastError() == ERROR_INVALID_HANDLE, "Expected ERROR_INVALID_HANDLE, got %u\n", GetLastError());
4747 }
4748
4749 /* Test 0-length path */
4750 count = pGetFinalPathNameByHandleW(file, result_path, 0, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4751 ok(count == lstrlenW(dos_path) + 1 ||
4752 broken(count == lstrlenW(dos_path) + 2), "Expected length %u, got %u\n", lstrlenW(dos_path) + 1, count);
4753
4754 /* Test 0 and NULL path */
4755 count = pGetFinalPathNameByHandleW(file, NULL, 0, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4756 ok(count == lstrlenW(dos_path) + 1 ||
4757 broken(count == lstrlenW(dos_path) + 2), "Expected length %u, got %u\n", lstrlenW(dos_path) + 1, count);
4758
4759 /* Test VOLUME_NAME_DOS with sufficient buffer size */
4760 memset(result_path, 0x11, sizeof(result_path));
4761 count = pGetFinalPathNameByHandleW(file, result_path, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4762 ok(count == lstrlenW(dos_path), "Expected length %u, got %u\n", lstrlenW(dos_path), count);
4763 ok(lstrcmpiW(dos_path, result_path) == 0, "Expected %s, got %s\n", wine_dbgstr_w(dos_path), wine_dbgstr_w(result_path));
4764
4765 /* Test VOLUME_NAME_DOS with insufficient buffer size */
4766 memset(result_path, 0x11, sizeof(result_path));
4767 count = pGetFinalPathNameByHandleW(file, result_path, lstrlenW(dos_path)-1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4768 ok(count == lstrlenW(dos_path) + 1, "Expected length %u, got %u\n", lstrlenW(dos_path) + 1, count);
4769 ok(result_path[0] == 0x1111, "Result path was modified\n");
4770
4771 memset(result_path, 0x11, sizeof(result_path));
4772 count = pGetFinalPathNameByHandleW(file, result_path, lstrlenW(dos_path), FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4773 ok(count == lstrlenW(dos_path) + 1, "Expected length %u, got %u\n", lstrlenW(dos_path) + 1, count);
4774 ok(result_path[0] == 0x1111, "Result path was modified\n");
4775
4776 memset(result_path, 0x11, sizeof(result_path));
4777 count = pGetFinalPathNameByHandleW(file, result_path, lstrlenW(dos_path)+1, FILE_NAME_NORMALIZED | VOLUME_NAME_DOS);
4778 ok(count == lstrlenW(dos_path), "Expected length %u, got %u\n", lstrlenW(dos_path), count);
4779 ok(result_path[0] != 0x1111, "Result path was not modified\n");
4780 ok(!result_path[lstrlenW(dos_path)], "Expected nullterminated string\n");
4781 ok(result_path[lstrlenW(dos_path)+1] == 0x1111, "Buffer overflow\n");
4782
4783 success = GetVolumePathNameW(long_path, drive_part, MAX_PATH);
4784 ok(success, "GetVolumePathNameW error %u\n", GetLastError());
4785 success = GetVolumeNameForVolumeMountPointW(drive_part, volume_path, sizeof(volume_path) / sizeof(WCHAR));
4786 ok(success, "GetVolumeNameForVolumeMountPointW error %u\n", GetLastError());
4787
4788 /* Test for VOLUME_NAME_GUID */
4789 lstrcatW(volume_path, long_path + lstrlenW(drive_part));
4790 memset(result_path, 0x11, sizeof(result_path));
4791 count = pGetFinalPathNameByHandleW(file, result_path, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_GUID);
4792 ok(count == lstrlenW(volume_path), "Expected length %u, got %u\n", lstrlenW(volume_path), count);
4793 ok(lstrcmpiW(volume_path, result_path) == 0, "Expected %s, got %s\n",
4794 wine_dbgstr_w(volume_path), wine_dbgstr_w(result_path));
4795
4796 /* Test for VOLUME_NAME_NONE */
4797 file_part = long_path + lstrlenW(drive_part) - 1;
4798 memset(result_path, 0x11, sizeof(result_path));
4799 count = pGetFinalPathNameByHandleW(file, result_path, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_NONE);
4800 ok(count == lstrlenW(file_part), "Expected length %u, got %u\n", lstrlenW(file_part), count);
4801 ok(lstrcmpiW(file_part, result_path) == 0, "Expected %s, got %s\n",
4802 wine_dbgstr_w(file_part), wine_dbgstr_w(result_path));
4803
4804 drive_part[lstrlenW(drive_part)-1] = 0;
4805 success = QueryDosDeviceW(drive_part, nt_path, sizeof(nt_path) / sizeof(WCHAR));
4806 ok(success, "QueryDosDeviceW error %u\n", GetLastError());
4807
4808 /* Test for VOLUME_NAME_NT */
4809 lstrcatW(nt_path, file_part);
4810 memset(result_path, 0x11, sizeof(result_path));
4811 count = pGetFinalPathNameByHandleW(file, result_path, MAX_PATH, FILE_NAME_NORMALIZED | VOLUME_NAME_NT);
4812 ok(count == lstrlenW(nt_path), "Expected length %u, got %u\n", lstrlenW(nt_path), count);
4813 ok(lstrcmpiW(nt_path, result_path) == 0, "Expected %s, got %s\n",
4814 wine_dbgstr_w(nt_path), wine_dbgstr_w(result_path));
4815
4817}
4818
4820{
4821 FILE_ATTRIBUTE_TAG_INFO fileattrinfo = { 0 };
4822 FILE_REMOTE_PROTOCOL_INFO protinfo = { 0 };
4823 FILE_STANDARD_INFO stdinfo = { {{0}},{{0}},0,FALSE,FALSE };
4824 FILE_COMPRESSION_INFO compressinfo;
4825 FILE_DISPOSITION_INFO dispinfo;
4826 char tempFileName[MAX_PATH];
4827 char tempPath[MAX_PATH];
4828 HANDLE file;
4829 BOOL ret;
4830
4831 if (!pSetFileInformationByHandle)
4832 {
4833 win_skip("SetFileInformationByHandle is not supported\n");
4834 return;
4835 }
4836
4837 ret = GetTempPathA(sizeof(tempPath), tempPath);
4838 ok(ret, "GetTempPathA failed, got error %u.\n", GetLastError());
4839
4840 /* ensure the existence of a file in the temp folder */
4841 ret = GetTempFileNameA(tempPath, "abc", 0, tempFileName);
4842 ok(ret, "GetTempFileNameA failed, got error %u.\n", GetLastError());
4843
4846 ok(file != INVALID_HANDLE_VALUE, "failed to open the temp file, error %u.\n", GetLastError());
4847
4848 /* invalid classes */
4849 SetLastError(0xdeadbeef);
4850 ret = pSetFileInformationByHandle(file, FileStandardInfo, &stdinfo, sizeof(stdinfo));
4851 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4852
4853 memset(&compressinfo, 0, sizeof(compressinfo));
4854 SetLastError(0xdeadbeef);
4855 ret = pSetFileInformationByHandle(file, FileCompressionInfo, &compressinfo, sizeof(compressinfo));
4856 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4857
4858 SetLastError(0xdeadbeef);
4859 ret = pSetFileInformationByHandle(file, FileAttributeTagInfo, &fileattrinfo, sizeof(fileattrinfo));
4860 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4861
4862 memset(&protinfo, 0, sizeof(protinfo));
4863 protinfo.StructureVersion = 1;
4864 protinfo.StructureSize = sizeof(protinfo);
4865 SetLastError(0xdeadbeef);
4866 ret = pSetFileInformationByHandle(file, FileRemoteProtocolInfo, &protinfo, sizeof(protinfo));
4867 ok(!ret && GetLastError() == ERROR_INVALID_PARAMETER, "got %d, error %d\n", ret, GetLastError());
4868
4869 /* test FileDispositionInfo, additional details already covered by ntdll tests */
4870 SetLastError(0xdeadbeef);
4871 ret = pSetFileInformationByHandle(file, FileDispositionInfo, &dispinfo, 0);
4873 ok(!ret && GetLastError() == ERROR_BAD_LENGTH, "got %d, error %d\n", ret, GetLastError());
4874
4875 dispinfo.DeleteFile = TRUE;
4876 ret = pSetFileInformationByHandle(file, FileDispositionInfo, &dispinfo, sizeof(dispinfo));
4877 ok(ret, "setting FileDispositionInfo failed, error %d\n", GetLastError());
4878
4880}
4881
4883{
4884 static const WCHAR path1[] = {'\\','\\','?','\\',0};
4885 static const WCHAR path2[] = {'\\','?','?','\\',0};
4886 static const WCHAR path3[] = {'\\','D','o','s','D','e','v','i','c','e','s','\\',0};
4888 BOOL ret;
4889
4890 SetLastError(0xdeadbeef);
4892 ok(!ret, "GetFileAttributesExW succeeded\n");
4893 ok(GetLastError() == ERROR_INVALID_NAME, "Expected error ERROR_INVALID_NAME, got %u\n", GetLastError());
4894
4895 SetLastError(0xdeadbeef);
4897 ok(!ret, "GetFileAttributesExW succeeded\n");
4898 ok(GetLastError() == ERROR_INVALID_NAME, "Expected error ERROR_INVALID_NAME, got %u\n", GetLastError());
4899
4900 SetLastError(0xdeadbeef);
4902 ok(!ret, "GetFileAttributesExW succeeded\n");
4903 ok(GetLastError() == ERROR_FILE_NOT_FOUND, "Expected error ERROR_FILE_NOT_FOUND, got %u\n", GetLastError());
4904}
4905
4907{
4908 char temp_path[MAX_PATH];
4909 DWORD ret;
4910
4912
4914 ok(ret != 0, "GetTempPath error %u\n", GetLastError());
4915 ret = GetTempFileNameA(temp_path, "tmp", 0, filename);
4916 ok(ret != 0, "GetTempFileName error %u\n", GetLastError());
4918 ok(ret != 0, "DeleteFile error %u\n", GetLastError());
4919
4920 test__hread( );
4921 test__hwrite( );
4922 test__lclose( );
4923 test__lcreat( );
4924 test__llseek( );
4925 test__llopen( );
4926 test__lread( );
4927 test__lwrite( );
4948 /* FindExLimitToDirectories is ignored if the file system doesn't support directory filtering */
4953 test_LockFile();
4956 test_MapFile();
4960 test_OpenFile();
4974}
unsigned char BOOLEAN
#define broken(x)
Definition: _sntprintf.h:21
char * strcat(char *DstString, const char *SrcString)
Definition: utclib.c:568
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
char * strstr(char *String1, char *String2)
Definition: utclib.c:653
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
int strncmp(const char *String1, const char *String2, ACPI_SIZE Count)
Definition: utclib.c:534
char * strcpy(char *DstString, const char *SrcString)
Definition: utclib.c:388
char * strchr(const char *String, int ch)
Definition: utclib.c:501
static unsigned char bytes[4]
Definition: adnsresfilter.c:74
static long backup()
Definition: maze.c:403
#define trace
Definition: atltest.h:70
#define ok(value,...)
Definition: atltest.h:57
#define skip(...)
Definition: atltest.h:64
#define START_TEST(x)
Definition: atltest.h:75
LONG NTSTATUS
Definition: precomp.h:26
static const WCHAR nameW[]
Definition: main.c:46
#define FILE_DIRECTORY_FILE
Definition: constants.h:491
#define FILE_NON_DIRECTORY_FILE
Definition: constants.h:492
#define FILE_DELETE_ON_CLOSE
Definition: constants.h:494
#define U(x)
Definition: wordpad.c:45
HANDLE WINAPI GetStdHandle(IN DWORD nStdHandle)
Definition: console.c:203
static TAGREF LPCWSTR LPDWORD LPVOID lpBuffer
Definition: db.cpp:175
static TAGID TAGID find
Definition: db.cpp:155
#define ERROR_IO_PENDING
Definition: dderror.h:15
#define ERROR_INVALID_FUNCTION
Definition: dderror.h:6
#define ERROR_SUCCESS
Definition: deptool.c:10
#define NULL
Definition: types.h:112
#define TRUE
Definition: types.h:120
#define FALSE
Definition: types.h:117
static int find_data(const struct Vector *v, const BYTE *pData, int size)
Definition: filtermapper.c:162
#define NTSTATUS
Definition: precomp.h:21
BOOL WINAPI LookupPrivilegeValueA(LPCSTR lpSystemName, LPCSTR lpName, PLUID lpLuid)
Definition: misc.c:732
BOOL WINAPI AdjustTokenPrivileges(HANDLE TokenHandle, BOOL DisableAllPrivileges, PTOKEN_PRIVILEGES NewState, DWORD BufferLength, PTOKEN_PRIVILEGES PreviousState, PDWORD ReturnLength)
Definition: security.c:374
BOOL WINAPI OpenProcessToken(HANDLE ProcessHandle, DWORD DesiredAccess, PHANDLE TokenHandle)
Definition: security.c:294
static cab_ULONG checksum(const cab_UBYTE *data, cab_UWORD bytes, cab_ULONG csum)
Definition: fdi.c:353
static WCHAR reason[MAX_STRING_RESOURCE_LEN]
Definition: object.c:1904
#define CloseHandle
Definition: compat.h:739
#define IMAGE_FILE_MACHINE_ARMNT
Definition: compat.h:127
#define GetProcessHeap()
Definition: compat.h:736
#define ERROR_CALL_NOT_IMPLEMENTED
Definition: compat.h:102
#define ERROR_INVALID_PARAMETER
Definition: compat.h:101
#define PAGE_READONLY
Definition: compat.h:138
#define FILE_BEGIN
Definition: compat.h:761
#define INVALID_SET_FILE_POINTER
Definition: compat.h:732
#define GetCurrentDirectoryW(x, y)
Definition: compat.h:756
#define CP_ACP
Definition: compat.h:109
#define OPEN_EXISTING
Definition: compat.h:775
#define IMAGE_FILE_MACHINE_POWERPC
Definition: compat.h:128
#define ReadFile(a, b, c, d, e)
Definition: compat.h:742
#define SetFilePointer
Definition: compat.h:743
#define SetLastError(x)
Definition: compat.h:752
#define GetProcAddress(x, y)
Definition: compat.h:753
#define INVALID_HANDLE_VALUE
Definition: compat.h:731
#define HeapAlloc
Definition: compat.h:733
#define CreateFileMappingW(a, b, c, d, e, f)
Definition: compat.h:744
#define CreateFileA(a, b, c, d, e, f, g)
Definition: compat.h:740
#define GetCurrentProcess()
Definition: compat.h:759
#define GENERIC_READ
Definition: compat.h:135
#define MAX_PATH
Definition: compat.h:34
#define HeapFree(x, y, z)
Definition: compat.h:735
#define ERROR_INVALID_HANDLE
Definition: compat.h:98
#define CreateFileW
Definition: compat.h:741
#define IMAGE_FILE_MACHINE_ARM64
Definition: compat.h:129
#define FILE_ATTRIBUTE_NORMAL
Definition: compat.h:137
#define CALLBACK
Definition: compat.h:35
#define lstrcpyW
Definition: compat.h:749
#define MultiByteToWideChar
Definition: compat.h:110
#define ERROR_ACCESS_DENIED
Definition: compat.h:97
#define FILE_SHARE_READ
Definition: compat.h:136
#define ERROR_INVALID_NAME
Definition: compat.h:103
#define HEAP_ZERO_MEMORY
Definition: compat.h:134
#define lstrlenW
Definition: compat.h:750
static void cleanup(void)
Definition: main.c:1335
static HRESULT create_error(script_ctx_t *ctx, jsdisp_t *constr, UINT number, jsstr_t *msg, jsdisp_t **ret)
Definition: error.c:188
DWORD WINAPI QueryDosDeviceW(LPCWSTR lpDeviceName, LPWSTR lpTargetPath, DWORD ucchMax)
Definition: dosdev.c:542
BOOL WINAPI CopyFileExA(IN LPCSTR lpExistingFileName, IN LPCSTR lpNewFileName, IN LPPROGRESS_ROUTINE lpProgressRoutine OPTIONAL, IN LPVOID lpData OPTIONAL, IN LPBOOL pbCancel OPTIONAL, IN DWORD dwCopyFlags)
Definition: copy.c:366
BOOL WINAPI CopyFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName, IN BOOL bFailIfExists)
Definition: copy.c:439
BOOL WINAPI CopyFileA(IN LPCSTR lpExistingFileName, IN LPCSTR lpNewFileName, IN BOOL bFailIfExists)
Definition: copy.c:404
HFILE WINAPI OpenFile(LPCSTR lpFileName, LPOFSTRUCT lpReOpenBuff, UINT uStyle)
Definition: create.c:368
BOOL WINAPI DeleteFileA(IN LPCSTR lpFileName)
Definition: delete.c:24
BOOL WINAPI DeleteFileW(IN LPCWSTR lpFileName)
Definition: delete.c:39
BOOL WINAPI RemoveDirectoryA(IN LPCSTR lpPathName)
Definition: dir.c:714
BOOL WINAPI CreateDirectoryW(IN LPCWSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:90
BOOL WINAPI RemoveDirectoryW(IN LPCWSTR lpPathName)
Definition: dir.c:732
BOOL WINAPI CreateDirectoryA(IN LPCSTR lpPathName, IN LPSECURITY_ATTRIBUTES lpSecurityAttributes)
Definition: dir.c:37
BOOL WINAPI GetFileInformationByHandle(HANDLE hFile, LPBY_HANDLE_FILE_INFORMATION lpFileInformation)
Definition: fileinfo.c:458
BOOL WINAPI SetFileAttributesW(LPCWSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:794
BOOL WINAPI SetFileAttributesA(LPCSTR lpFileName, DWORD dwFileAttributes)
Definition: fileinfo.c:776
DWORD WINAPI GetFileType(HANDLE hFile)
Definition: fileinfo.c:269
BOOL WINAPI SetEndOfFile(HANDLE hFile)
Definition: fileinfo.c:1004
BOOL WINAPI GetFileAttributesExW(LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId, LPVOID lpFileInformation)
Definition: fileinfo.c:552
BOOL WINAPI SetFileTime(IN HANDLE hFile, CONST FILETIME *lpCreationTime OPTIONAL, CONST FILETIME *lpLastAccessTime OPTIONAL, CONST FILETIME *lpLastWriteTime OPTIONAL)
Definition: fileinfo.c:948
DWORD WINAPI GetFileSize(HANDLE hFile, LPDWORD lpFileSizeHigh)
Definition: fileinfo.c:331
BOOL WINAPI GetFileTime(IN HANDLE hFile, OUT LPFILETIME lpCreationTime OPTIONAL, OUT LPFILETIME lpLastAccessTime OPTIONAL, OUT LPFILETIME lpLastWriteTime OPTIONAL)
Definition: fileinfo.c:896
DWORD WINAPI GetFileAttributesA(LPCSTR lpFileName)
Definition: fileinfo.c:636
HANDLE WINAPI FindFirstFileA(IN LPCSTR lpFileName, OUT LPWIN32_FIND_DATAA lpFindFileData)
Definition: find.c:263
BOOL WINAPI FindClose(HANDLE hFindFile)
Definition: find.c:502
BOOL WINAPI FindNextFileA(IN HANDLE hFindFile, OUT LPWIN32_FIND_DATAA lpFindFileData)
Definition: find.c:336
BOOL WINAPI UnlockFileEx(IN HANDLE hFile, IN DWORD dwReserved, IN DWORD nNumberOfBytesToUnLockLow, IN DWORD nNumberOfBytesToUnLockHigh, IN LPOVERLAPPED lpOverlapped)
Definition: lock.c:183
BOOL WINAPI UnlockFile(IN HANDLE hFile, IN DWORD dwFileOffsetLow, IN DWORD dwFileOffsetHigh, IN DWORD nNumberOfBytesToUnlockLow, IN DWORD nNumberOfBytesToUnlockHigh)
Definition: lock.c:142
BOOL WINAPI LockFileEx(IN HANDLE hFile, IN DWORD dwFlags, IN DWORD dwReserved, IN DWORD nNumberOfBytesToLockLow, IN DWORD nNumberOfBytesToLockHigh, IN LPOVERLAPPED lpOverlapped)
Definition: lock.c:82
BOOL WINAPI LockFile(IN HANDLE hFile, IN DWORD dwFileOffsetLow, IN DWORD dwFileOffsetHigh, IN DWORD nNumberOfBytesToLockLow, IN DWORD nNumberOfBytesToLockHigh)
Definition: lock.c:25
BOOL WINAPI MoveFileA(IN LPCSTR lpExistingFileName, IN LPCSTR lpNewFileName)
Definition: move.c:1137
BOOL WINAPI MoveFileW(IN LPCWSTR lpExistingFileName, IN LPCWSTR lpNewFileName)
Definition: move.c:1104
BOOL WINAPI WriteFileGather(HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToWrite, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped)
Definition: rw.c:379
BOOL WINAPI ReadFileScatter(HANDLE hFile, FILE_SEGMENT_ELEMENT aSegmentArray[], DWORD nNumberOfBytesToRead, LPDWORD lpReserved, LPOVERLAPPED lpOverlapped)
Definition: rw.c:337
BOOL WINAPI WriteFile(IN HANDLE hFile, IN LPCVOID lpBuffer, IN DWORD nNumberOfBytesToWrite OPTIONAL, OUT LPDWORD lpNumberOfBytesWritten, IN LPOVERLAPPED lpOverlapped OPTIONAL)
Definition: rw.c:24
BOOL WINAPI ReadFileEx(IN HANDLE hFile, IN LPVOID lpBuffer, IN DWORD nNumberOfBytesToRead OPTIONAL, IN LPOVERLAPPED lpOverlapped, IN LPOVERLAPPED_COMPLETION_ROUTINE lpCompletionRoutine)
Definition: rw.c:299
BOOL WINAPI GetVolumePathNameW(IN LPCWSTR lpszFileName, IN LPWSTR lpszVolumePathName, IN DWORD cchBufferLength)
Definition: volume.c:815
BOOL WINAPI DuplicateHandle(IN HANDLE hSourceProcessHandle, IN HANDLE hSourceHandle, IN HANDLE hTargetProcessHandle, OUT LPHANDLE lpTargetHandle, IN DWORD dwDesiredAccess, IN BOOL bInheritHandle, IN DWORD dwOptions)
Definition: handle.c:149
HMODULE WINAPI DECLSPEC_HOTPATCH GetModuleHandleA(LPCSTR lpModuleName)
Definition: loader.c:812
DWORD WINAPI GetCurrentDirectoryA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2146
DWORD WINAPI GetTempPathW(IN DWORD count, OUT LPWSTR path)
Definition: path.c:2080
UINT WINAPI GetWindowsDirectoryA(OUT LPSTR lpBuffer, IN UINT uSize)
Definition: path.c:2337
DWORD WINAPI GetLongPathNameA(IN LPCSTR lpszShortPath, OUT LPSTR lpszLongPath, IN DWORD cchBuffer)
Definition: path.c:1671
BOOL WINAPI SetCurrentDirectoryW(IN LPCWSTR lpPathName)
Definition: path.c:2249
DWORD WINAPI GetLongPathNameW(IN LPCWSTR lpszShortPath, OUT LPWSTR lpszLongPath, IN DWORD cchBuffer)
Definition: path.c:1456
BOOL WINAPI SetCurrentDirectoryA(IN LPCSTR lpPathName)
Definition: path.c:2206
DWORD WINAPI GetTempPathA(IN DWORD nBufferLength, OUT LPSTR lpBuffer)
Definition: path.c:2054
VOID WINAPI GetSystemInfo(IN LPSYSTEM_INFO lpSystemInfo)
Definition: sysinfo.c:143
DWORD WINAPI GetTickCount(VOID)
Definition: time.c:455
LONG WINAPI CompareFileTime(IN CONST FILETIME *lpFileTime1, IN CONST FILETIME *lpFileTime2)
Definition: time.c:106
#define INFINITE
Definition: serial.h:102
ANSI_STRING * PANSI_STRING
Definition: env_spec_w32.h:380
static unsigned char buff[32768]
Definition: fatten.c:17
#define abs(i)
Definition: fconv.c:206
HANDLE NTAPI CreateFileMappingA(IN HANDLE hFile, IN LPSECURITY_ATTRIBUTES lpFileMappingAttributes, IN DWORD flProtect, IN DWORD dwMaximumSizeHigh, IN DWORD dwMaximumSizeLow, IN LPCSTR lpName)
Definition: filemap.c:23
UINT WINAPI GetTempFileNameW(IN LPCWSTR lpPathName, IN LPCWSTR lpPrefixString, IN UINT uUnique, OUT LPWSTR lpTempFileName)
Definition: filename.c:84
UINT WINAPI GetTempFileNameA(IN LPCSTR lpPathName, IN LPCSTR lpPrefixString, IN UINT uUnique, OUT LPSTR lpTempFileName)
Definition: filename.c:26
unsigned int BOOL
Definition: ntddk_ex.h:94
unsigned long DWORD
Definition: ntddk_ex.h:95
#define IMAGE_NUMBEROF_DIRECTORY_ENTRIES
Definition: ntddk_ex.h:135
#define FILE_OPEN
Definition: from_kernel.h:54
#define FILE_OPEN_IF
Definition: from_kernel.h:56
GLint level
Definition: gl.h:1546
GLint GLint GLint GLint GLint x
Definition: gl.h:1548
GLuint GLuint GLsizei GLenum type
Definition: gl.h:1545
GLuint GLuint GLsizei count
Definition: gl.h:1545
GLint GLenum GLsizei GLsizei GLsizei GLint GLsizei const GLvoid * data
Definition: gl.h:1950
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
GLsizeiptr size
Definition: glext.h:5919
GLuint res
Definition: glext.h:9613
GLuint buffer
Definition: glext.h:5915
const GLubyte * c
Definition: glext.h:8905
GLubyte * pattern
Definition: glext.h:7787
GLenum mode
Definition: glext.h:6217
GLenum const GLfloat * params
Definition: glext.h:5645
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
GLbitfield flags
Definition: glext.h:7161
GLuint GLsizei GLsizei * length
Definition: glext.h:6040
GLuint GLint GLboolean GLint GLenum access
Definition: glext.h:7866
GLfloat GLfloat p
Definition: glext.h:8902
GLfloat param
Definition: glext.h:5796
GLenum GLsizei len
Definition: glext.h:6722
GLuint64EXT * result
Definition: glext.h:11304
GLintptr offset
Definition: glext.h:5920
const GLfloat * m
Definition: glext.h:10848
GLfloat GLfloat GLfloat GLfloat h
Definition: glext.h:7723
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat token
Definition: glfuncs.h:210
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
HLOCAL NTAPI LocalAlloc(UINT uFlags, SIZE_T dwBytes)
Definition: heapmem.c:1390
LPVOID NTAPI LocalLock(HLOCAL hMem)
Definition: heapmem.c:1616
HLOCAL NTAPI LocalFree(HLOCAL hMem)
Definition: heapmem.c:1594
int hex(char ch)
static const WCHAR emptyW[]
Definition: navigate.c:40
void __cdecl srand(_In_ unsigned int _Seed)
_Check_return_ int __cdecl rand(void)
Definition: rand.c:10
#define OBJ_CASE_INSENSITIVE
Definition: winternl.h:228
REFIID LPVOID DWORD_PTR dw
Definition: atlbase.h:40
#define S_OK
Definition: intsafe.h:52
const char * filename
Definition: ioapi.h:137
HANDLE WINAPI CreateIoCompletionPort(IN HANDLE FileHandle, IN HANDLE ExistingCompletionPort, IN ULONG_PTR CompletionKey, IN DWORD NumberOfConcurrentThreads)
Definition: iocompl.c:65
BOOL WINAPI GetOverlappedResult(IN HANDLE hFile, IN LPOVERLAPPED lpOverlapped, OUT LPDWORD lpNumberOfBytesTransferred, IN BOOL bWait)
Definition: iocompl.c:221
BOOL WINAPI GetQueuedCompletionStatus(IN HANDLE CompletionHandle, IN LPDWORD lpNumberOfBytesTransferred, OUT PULONG_PTR lpCompletionKey, OUT LPOVERLAPPED *lpOverlapped, IN DWORD dwMilliseconds)
Definition: iocompl.c:131
#define c
Definition: ke_i.h:80
#define _lread(a, b, c)
Definition: kernel32.h:171
#define wine_dbgstr_w
Definition: kernel32.h:34
int WINAPI _lclose(HFILE hFile)
Definition: lfile.c:138
LONG WINAPI _llseek(HFILE hFile, LONG lOffset, int iOrigin)
Definition: lfile.c:149
HFILE WINAPI _lopen(LPCSTR lpPathName, int iReadWrite)
Definition: lfile.c:70
HFILE WINAPI _lcreat(LPCSTR lpPathName, int iAttribute)
Definition: lfile.c:116
long WINAPI _hwrite(HFILE hFile, LPCSTR lpBuffer, long lBytes)
Definition: lfile.c:41
long WINAPI _hread(HFILE hFile, LPVOID lpBuffer, long lBytes)
Definition: lfile.c:20
__cdecl __MINGW_NOTHROW char * dirname(char *)
int WINAPI lstrcmpiA(LPCSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:42
int WINAPI lstrcmpiW(LPCWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:194
LPSTR WINAPI lstrcpyA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:100
LPWSTR WINAPI lstrcatW(LPWSTR lpString1, LPCWSTR lpString2)
Definition: lstring.c:274
LPSTR WINAPI lstrcatA(LPSTR lpString1, LPCSTR lpString2)
Definition: lstring.c:123
int WINAPI lstrlenA(LPCSTR lpString)
Definition: lstring.c:145
struct S1 s1
struct S2 s2
__u16 time
Definition: mkdosfs.c:8
static int blocks
Definition: mkdosfs.c:527
#define error(str)
Definition: mkdosfs.c:1605
#define memcpy(s1, s2, n)
Definition: mkisofs.h:878
BOOL WINAPI GetVolumeNameForVolumeMountPointW(IN LPCWSTR VolumeMountPoint, OUT LPWSTR VolumeName, IN DWORD VolumeNameLength)
Definition: mntpoint.c:496
#define CREATE_ALWAYS
Definition: disk.h:72
#define ERROR_ALREADY_EXISTS
Definition: disk.h:80
#define TRUNCATE_EXISTING
Definition: disk.h:71
#define FILE_FLAG_OVERLAPPED
Definition: disk.h:46
#define FILE_FLAG_NO_BUFFERING
Definition: disk.h:45
#define FILE_FLAG_BACKUP_SEMANTICS
Definition: disk.h:41
#define FILE_FLAG_RANDOM_ACCESS
Definition: disk.h:44
#define FILE_FLAG_DELETE_ON_CLOSE
Definition: disk.h:42
#define CREATE_NEW
Definition: disk.h:69
#define OPEN_ALWAYS
Definition: disk.h:70
#define FILE_ATTRIBUTE_DEVICE
Definition: disk.h:27
#define ERROR_FILE_NOT_FOUND
Definition: disk.h:79
static PVOID ptr
Definition: dispmode.c:27
static struct test_info tests[]
#define sprintf(buf, format,...)
Definition: sprintf.c:55
static const WCHAR filenameW[]
Definition: amstream.c:41
BOOL todo
Definition: filedlg.c:313
static const struct update_accum a1
Definition: msg.c:578
static const struct update_accum a2
Definition: msg.c:586
static const WCHAR nonexistent[]
Definition: font.c:33
static ACCESS_MASK
Definition: file.c:43
static POBJECT_ATTRIBUTES
Definition: file.c:43
static void test_ReplaceFileA(void)
Definition: file.c:3592
static void CALLBACK user_apc(ULONG_PTR param)
Definition: file.c:3125
static PCWSTR
Definition: file.c:39
static LPSTR
Definition: file.c:34
static void test_FindFirstFileExA(FINDEX_INFO_LEVELS level, FINDEX_SEARCH_OPS search_ops, DWORD flags)
Definition: file.c:2799
static void test_GetFileInformationByHandleEx(void)
Definition: file.c:4023
static void test_ReplaceFileW(void)
Definition: file.c:3806
static void test_DeleteFileA(void)
Definition: file.c:1748
static char filename[MAX_PATH]
Definition: file.c:51
static const char sillytext[]
Definition: file.c:52
static PCSZ
Definition: file.c:48
static void test_CreateFileA(void)
Definition: file.c:1184
static HANDLE ULONG_PTR dwData
Definition: file.c:35
static void test_FindNextFileA(void)
Definition: file.c:2780
static DWORD WINAPI copy_progress_cb(LARGE_INTEGER total_size, LARGE_INTEGER total_transferred, LARGE_INTEGER stream_size, LARGE_INTEGER stream_transferred, DWORD stream, DWORD reason, HANDLE source, HANDLE dest, LPVOID userdata)
Definition: file.c:1111
static void test__lcreat(void)
Definition: file.c:272
const char * path
Definition: file.c:2510
static void test_OpenFileById(void)
Definition: file.c:4189
static void test_async_file_errors(void)
Definition: file.c:3081
#define IsDotDir(x)
Definition: file.c:1853
static void test_GetFileType(void)
Definition: file.c:3051
static BOOL is_sharing_map_compatible(DWORD map_access, DWORD access2, DWORD sharing2)
Definition: file.c:2314
static FINDEX_SEARCH_OPS
Definition: file.c:30
static void test_CopyFile2(void)
Definition: file.c:882
static LPSECURITY_ATTRIBUTES
Definition: file.c:37
static int completion_count
Definition: file.c:3072
#define PATTERN_OFFSET
Definition: file.c:2004
static void test__hwrite(void)
Definition: file.c:146
static BOOL is_access_compatible(unsigned obj_access, unsigned desired_access)
Definition: file.c:4496
static BOOL create_fake_dll(LPCSTR filename)
Definition: file.c:2209
static void test_MoveFileA(void)
Definition: file.c:1855
static void test_CreateFileW(void)
Definition: file.c:1541
static void test__llopen(void)
Definition: file.c:504
static LPWSTR
Definition: file.c:42
static void test_OpenFile(void)
Definition: file.c:3292
static BOOL check_file_time(const FILETIME *ft1, const FILETIME *ft2, UINT tolerance)
Definition: file.c:3585
static void test_GetFinalPathNameByHandleA(void)
Definition: file.c:4609
static void test_RemoveDirectory(void)
Definition: file.c:3563
static void test_offset_in_overlapped_structure(void)
Definition: file.c:2006
static void test_WriteFileGather(void)
Definition: file.c:4430
static BOOL user_apc_ran
Definition: file.c:3124
static void test__hread(void)
Definition: file.c:99
static void CALLBACK FileIOComplete(DWORD dwError, DWORD dwBytes, LPOVERLAPPED ovl)
Definition: file.c:3074
static void test_LockFile(void)
Definition: file.c:2079
static void test_CreateFile(void)
Definition: file.c:3890
#define CHECK_LEVEL(fn)
static char get_windows_drive(void)
Definition: file.c:2501
static LPFILE_ID_DESCRIPTOR
Definition: file.c:37
static void test_FindFirstFile_wildcards(void)
Definition: file.c:2902
static void test_file_access(void)
Definition: file.c:4503
static void test_DeleteFileW(void)
Definition: file.c:1801
static void test__lread(void)
Definition: file.c:544
static void test_file_sharing(void)
Definition: file.c:2323
static void test_GetTempFileNameA(void)
Definition: file.c:1711
static void test_CopyFileA(void)
Definition: file.c:675
static void test_FindFirstFileA(void)
Definition: file.c:2582
static unsigned int map_file_access(unsigned int access)
Definition: file.c:2286
static PWSTR CURDIR *static BOOLEAN
Definition: file.c:46
static unsigned file_map_access(unsigned access)
Definition: file.c:4487
static PLARGE_INTEGER
Definition: file.c:44
static HANDLE hThread
Definition: file.c:35
static void dumpmem(unsigned char *mem, int len)
Definition: file.c:1165
static LPCWSTR
Definition: file.c:32
static void test_CopyFileEx(void)
Definition: file.c:1120
static PUNICODE_STRING
Definition: file.c:45
static void test_CopyFileW(void)
Definition: file.c:847
static LPVOID
Definition: file.c:30
static void test_GetFinalPathNameByHandleW(void)
Definition: file.c:4696
static void test_MoveFileW(void)
Definition: file.c:1972
static void get_nt_pathW(const char *name, UNICODE_STRING *nameW)
Definition: file.c:254
#define CHECK_NAME(fn)
static void test_GetFileAttributesExW(void)
Definition: file.c:4882
static LPCSTR
Definition: file.c:31
static void test_overlapped(void)
Definition: file.c:3486
static FINDEX_INFO_LEVELS
Definition: file.c:30
static int test_Mapfile_createtemp(HANDLE *handle)
Definition: file.c:2993
static void test__llseek(void)
Definition: file.c:466
static void test_SetFileValidData(void)
Definition: file.c:4293
static void test_SetFileInformationByHandle(void)
Definition: file.c:4819
static void test_CreateFile2(void)
Definition: file.c:1630
#define M(x)
static BOOL is_sharing_compatible(DWORD access1, DWORD sharing1, DWORD access2, DWORD sharing2)
Definition: file.c:2295
static void test_read_write(void)
Definition: file.c:3130
static PWSTR CURDIR *static PCANSI_STRING
Definition: file.c:46
static void test__lclose(void)
Definition: file.c:233
static void test__lwrite(void)
Definition: file.c:589
static void InitFunctionPointers(void)
Definition: file.c:72
static const struct @1661 invalid_char_tests[]
static void test_MapFile(void)
Definition: file.c:3007
static PIO_STATUS_BLOCK
Definition: file.c:43
static LONGLONG
Definition: file.c:38
static FILE_INFO_BY_HANDLE_CLASS
Definition: file.c:36
BOOL expected
Definition: file.c:2511
static UINT
Definition: file.c:33
IMAGE_NT_HEADERS nt
Definition: module.c:50
IMAGE_DOS_HEADER dos
Definition: module.c:49
static HINSTANCE hkernel32
Definition: process.c:66
static HINSTANCE hntdll
Definition: process.c:66
#define todo_wine_if(is_todo)
Definition: custom.c:76
#define todo_wine
Definition: custom.c:79
static HANDLE PIO_APC_ROUTINE PVOID PIO_STATUS_BLOCK io
Definition: file.c:100
static char * dest
Definition: rtl.c:135
static const DWORD access_modes[4]
Definition: storage32.c:2073
static const char * contents
Definition: parser.c:511
static const WCHAR path3[]
Definition: misc.c:320
static LPCWSTR file_name
Definition: protocol.c:147
WCHAR strW[12]
Definition: clipboard.c:2029
static const WCHAR path1[]
Definition: path.c:28
static const WCHAR path2[]
Definition: path.c:29
char temp_path[MAX_PATH]
Definition: mspatcha.c:123
_In_ HANDLE hFile
Definition: mswsock.h:90
unsigned int UINT
Definition: ndis.h:50
#define SEC_COMMIT
Definition: mmtypes.h:100
#define SEC_IMAGE
Definition: mmtypes.h:97
#define BOOL
Definition: nt_native.h:43
#define FILE_SHARE_WRITE
Definition: nt_native.h:681
#define PAGE_WRITECOPY
Definition: nt_native.h:1305
#define FILE_WRITE_DATA
Definition: nt_native.h:631
#define FILE_READ_DATA
Definition: nt_native.h:628
#define FILE_ATTRIBUTE_READONLY
Definition: nt_native.h:702
#define FILE_GENERIC_EXECUTE
Definition: nt_native.h:668
#define PAGE_READWRITE
Definition: nt_native.h:1304
#define FILE_READ_ATTRIBUTES
Definition: nt_native.h:647
#define FILE_DELETE_CHILD
Definition: nt_native.h:645
#define FILE_READ_EA
Definition: nt_native.h:638
#define FILE_SHARE_DELETE
Definition: nt_native.h:682
#define FILE_EXECUTE
Definition: nt_native.h:642
#define FILE_WRITE_ATTRIBUTES
Definition: nt_native.h:649
#define FILE_APPEND_DATA
Definition: nt_native.h:634
#define GENERIC_ALL
Definition: nt_native.h:92
#define FILE_ATTRIBUTE_ARCHIVE
Definition: nt_native.h:706
#define FILE_ATTRIBUTE_DIRECTORY
Definition: nt_native.h:705
#define DELETE
Definition: nt_native.h:57
#define FILE_ALL_ACCESS
Definition: nt_native.h:651
#define MEM_RELEASE
Definition: nt_native.h:1316
#define DWORD
Definition: nt_native.h:44
#define GENERIC_WRITE
Definition: nt_native.h:90
#define MEM_COMMIT
Definition: nt_native.h:1313
#define FILE_GENERIC_READ
Definition: nt_native.h:653
#define FILE_WRITE_EA
Definition: nt_native.h:640
#define GENERIC_EXECUTE
Definition: nt_native.h:91
#define PAGE_NOACCESS
Definition: nt_native.h:1302
#define PAGE_EXECUTE_READWRITE
Definition: nt_native.h:1308
#define FILE_GENERIC_WRITE
Definition: nt_native.h:660
#define IMAGE_SCN_MEM_WRITE
Definition: ntimage.h:241
#define IMAGE_SUBSYSTEM_WINDOWS_GUI
Definition: ntimage.h:437
#define IMAGE_FILE_MACHINE_AMD64
Definition: ntimage.h:17
#define IMAGE_SCN_MEM_READ
Definition: ntimage.h:240
#define IMAGE_NT_OPTIONAL_HDR_MAGIC
Definition: ntimage.h:387
PVOID *typedef PHANDLE
Definition: ntsecpkg.h:455
#define STATUS_INVALID_HANDLE
Definition: ntstatus.h:245
#define STATUS_PENDING
Definition: ntstatus.h:82
#define IMAGE_FILE_EXECUTABLE_IMAGE
Definition: pedump.c:160
#define IMAGE_FILE_MACHINE_I386
Definition: pedump.c:174
struct _IMAGE_OPTIONAL_HEADER IMAGE_OPTIONAL_HEADER
#define IMAGE_NT_SIGNATURE
Definition: pedump.c:93
#define IMAGE_FILE_DLL
Definition: pedump.c:169
long LONG
Definition: pedump.c:60
#define IMAGE_DOS_SIGNATURE
Definition: pedump.c:89
#define INT
Definition: polytest.cpp:20
#define err(...)
static FILE * out
Definition: regtests2xml.c:44
const WCHAR * str
_Check_return_ _CRTIMP _CONST_RETURN char *__cdecl strrchr(_In_z_ const char *_Str, _In_ int _Ch)
#define win_skip
Definition: test.h:160
#define S(x)
Definition: test.h:217
int const char int stream_size
Definition: zlib.h:814
static int fd
Definition: io.c:51
#define memset(x, y, z)
Definition: compat.h:39
#define STATUS_CANNOT_DELETE
Definition: shellext.h:71
HRESULT hr
Definition: shlfolder.c:183
namespace GUID const ADDRINFOEXW ADDRINFOEXW struct timeval OVERLAPPED * overlapped
Definition: sock.c:81
LPSECURITY_ATTRIBUTES lpSecurityAttributes
Definition: fileapi.h:31
DWORD dwHighDateTime
Definition: mapidefs.h:66
DWORD dwLowDateTime
Definition: mapidefs.h:65
WORD SizeOfOptionalHeader
Definition: ntddk_ex.h:127
IMAGE_OPTIONAL_HEADER32 OptionalHeader
Definition: ntddk_ex.h:184
IMAGE_FILE_HEADER FileHeader
Definition: ntddk_ex.h:183
WORD MinorOperatingSystemVersion
Definition: ntddk_ex.h:161
WORD MajorOperatingSystemVersion
Definition: ntddk_ex.h:160
DWORD PointerToRawData
Definition: pedump.c:290
union _IMAGE_SECTION_HEADER::@1555 Misc
BYTE Name[IMAGE_SIZEOF_SHORT_NAME]
Definition: pedump.c:281
WORD nErrCode
Definition: winbase.h:1291
CHAR szPathName[OFS_MAXPATHNAME]
Definition: winbase.h:1294
BYTE cBytes
Definition: winbase.h:1289
HANDLE hEvent
Definition: winbase.h:820
ULONG_PTR Internal
Definition: winbase.h:811
ULONG_PTR InternalHigh
Definition: winbase.h:812
DWORD dwPageSize
Definition: winbase.h:1173
$ULONG PrivilegeCount
Definition: setypes.h:1023
LUID_AND_ATTRIBUTES Privileges[ANYSIZE_ARRAY]
Definition: setypes.h:1024
Definition: cookie.c:202
Definition: fci.c:127
Definition: copy.c:22
Definition: mem.c:156
Definition: name.c:39
Definition: ps.c:97
Definition: parse.h:23
Definition: fci.c:110
Definition: file.c:64
const DWORD err
Definition: file.c:66
const char * file
Definition: file.c:65
const LONG err2
Definition: file.c:67
const DWORD options
Definition: file.c:68
const BOOL todo_flag
Definition: file.c:69
DWORD WINAPI SleepEx(IN DWORD dwMilliseconds, IN BOOL bAlertable)
Definition: synch.c:802
VOID WINAPI DECLSPEC_HOTPATCH Sleep(IN DWORD dwMilliseconds)
Definition: synch.c:790
DWORD WINAPI WaitForSingleObjectEx(IN HANDLE hHandle, IN DWORD dwMilliseconds, IN BOOL bAlertable)
Definition: synch.c:94
HANDLE WINAPI DECLSPEC_HOTPATCH CreateEventW(IN LPSECURITY_ATTRIBUTES lpEventAttributes OPTIONAL, IN BOOL bManualReset, IN BOOL bInitialState, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:651
BOOL WINAPI DECLSPEC_HOTPATCH ResetEvent(IN HANDLE hEvent)
Definition: synch.c:714
HANDLE WINAPI DECLSPEC_HOTPATCH CreateSemaphoreW(IN LPSECURITY_ATTRIBUTES lpSemaphoreAttributes OPTIONAL, IN LONG lInitialCount, IN LONG lMaximumCount, IN LPCWSTR lpName OPTIONAL)
Definition: synch.c:444
BOOL WINAPI DECLSPEC_HOTPATCH ReleaseSemaphore(IN HANDLE hSemaphore, IN LONG lReleaseCount, IN LPLONG lpPreviousCount)
Definition: synch.c:542
uint16_t * PWSTR
Definition: typedefs.h:56
void * PVOID
Definition: typedefs.h:50
PVOID HANDLE
Definition: typedefs.h:73
int32_t INT
Definition: typedefs.h:58
uint32_t ULONG_PTR
Definition: typedefs.h:65
uint32_t ULONG
Definition: typedefs.h:59
uint64_t ULONGLONG
Definition: typedefs.h:67
#define STATUS_NOT_A_DIRECTORY
Definition: udferr_usr.h:169
#define STATUS_ACCESS_DENIED
Definition: udferr_usr.h:145
LONGLONG QuadPart
Definition: typedefs.h:114
#define INVALID_FILE_ATTRIBUTES
Definition: vfdcmd.c:23
int ret
LPVOID NTAPI VirtualAlloc(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flAllocationType, IN DWORD flProtect)
Definition: virtmem.c:65
BOOL NTAPI VirtualProtect(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD flNewProtect, OUT PDWORD lpflOldProtect)
Definition: virtmem.c:135
BOOL NTAPI VirtualFree(IN LPVOID lpAddress, IN SIZE_T dwSize, IN DWORD dwFreeType)
Definition: virtmem.c:119
#define success(from, fromstr, to, tostr)
#define COPY_FILE_FAIL_IF_EXISTS
Definition: winbase.h:205
enum _FINDEX_SEARCH_OPS FINDEX_SEARCH_OPS
#define LOCKFILE_FAIL_IMMEDIATELY
Definition: winbase.h:385
#define STD_OUTPUT_HANDLE
Definition: winbase.h:268
#define FILE_END
Definition: winbase.h:114
DWORD WINAPI GetLastError(void)
Definition: except.c:1042
HANDLE WINAPI GetCurrentThread(void)
Definition: proc.c:1148
#define OF_EXIST
Definition: winbase.h:127
#define LOCKFILE_EXCLUSIVE_LOCK
Definition: winbase.h:386
@ FindExSearchLimitToDirectories
Definition: winbase.h:1135
#define WAIT_IO_COMPLETION
Definition: winbase.h:411
#define LPTR
Definition: winbase.h:381
_In_ LPCSTR lpName
Definition: winbase.h:2789
#define FIND_FIRST_EX_LARGE_FETCH
Definition: winbase.h:235
#define FIND_FIRST_EX_CASE_SENSITIVE
Definition: winbase.h:234
#define FILE_CURRENT
Definition: winbase.h:113
#define HFILE_ERROR
Definition: winbase.h:111
#define OF_READWRITE
Definition: winbase.h:117
UINT WINAPI _lwrite(_In_ HFILE hFile, _In_reads_bytes_(uBytes) LPCCH lpBuffer, _In_ UINT uBytes)
#define FILE_TYPE_CHAR
Definition: winbase.h:260
@ GetFileExInfoStandard
Definition: winbase.h:1161
#define OFS_MAXPATHNAME
Definition: winbase.h:152
#define PROGRESS_CANCEL
Definition: winbase.h:147
#define CALLBACK_STREAM_SWITCH
Definition: winbase.h:151
#define OF_READ
Definition: winbase.h:116
#define OF_CREATE
Definition: winbase.h:125
#define OF_DELETE
Definition: winbase.h:126
enum _FINDEX_INFO_LEVELS FINDEX_INFO_LEVELS
#define OF_WRITE
Definition: winbase.h:118
@ FindExInfoStandard
Definition: winbase.h:1128
@ FindExInfoBasic
Definition: winbase.h:1129
#define FILE_TYPE_DISK
Definition: winbase.h:259
int HFILE
Definition: windef.h:298
#define HRESULT
Definition: msvc.h:7
#define WINAPI
Definition: msvc.h:6
#define ERROR_BAD_NETPATH
Definition: winerror.h:145
#define ERROR_IO_INCOMPLETE
Definition: winerror.h:576
#define ERROR_SHARING_VIOLATION
Definition: winerror.h:135
#define ERROR_BAD_LENGTH
Definition: winerror.h:127
#define ERROR_INVALID_USER_BUFFER
Definition: winerror.h:1091
#define ERROR_PATH_NOT_FOUND
Definition: winerror.h:106
#define ERROR_NOT_ALL_ASSIGNED
Definition: winerror.h:782
#define ERROR_BAD_PATHNAME
Definition: winerror.h:233
#define ERROR_FILE_EXISTS
Definition: winerror.h:165
#define ERROR_NO_MORE_FILES
Definition: winerror.h:121
#define ERROR_FILE_INVALID
Definition: winerror.h:585
#define ERROR_FILENAME_EXCED_RANGE
Definition: winerror.h:263
#define HRESULT_FROM_WIN32(x)
Definition: winerror.h:92
#define ERROR_REQUEST_ABORTED
Definition: winerror.h:738
#define ERROR_USER_MAPPED_FILE
Definition: winerror.h:727
#define ERROR_NOACCESS
Definition: winerror.h:578
#define ERROR_INVALID_DATA
Definition: winerror.h:116
#define ERROR_PRIVILEGE_NOT_HELD
Definition: winerror.h:796
#define ERROR_UNABLE_TO_REMOVE_REPLACED
Definition: winerror.h:696
#define SE_MANAGE_VOLUME_NAME
Definition: winnt_old.h:393
#define TOKEN_ADJUST_PRIVILEGES
Definition: setypes.h:930
#define SE_PRIVILEGE_ENABLED
Definition: setypes.h:63
const char * LPCSTR
Definition: xmlstorage.h:183
char * LPSTR
Definition: xmlstorage.h:182
__wchar_t WCHAR
Definition: xmlstorage.h:180
unsigned char BYTE
Definition: xxhash.c:193