?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Implemented asynchronous ReadFile and WriteFile.
[wine/wine-kai.git] / files / file.c
blob48709977490fc1db3fb86578a8ad397415262bb5
1 /*
2 * File handling functions
3 *
4 * Copyright 1993 John Burton
5 * Copyright 1996 Alexandre Julliard
6 *
7 * TODO:
8 * Fix the CopyFileEx methods to implement the "extended" functionality.
9 * Right now, they simply call the CopyFile method.
10 */
11
12 #include "config.h"
13
14 #include <assert.h>
15 #include <ctype.h>
16 #include <errno.h>
17 #include <fcntl.h>
18 #include <stdlib.h>
19 #include <stdio.h>
20 #include <string.h>
21 #ifdef HAVE_SYS_ERRNO_H
22 #include <sys/errno.h>
23 #endif
24 #include <sys/types.h>
25 #include <sys/stat.h>
26 #ifdef HAVE_SYS_MMAN_H
27 #include <sys/mman.h>
28 #endif
29 #include <sys/time.h>
30 #include <time.h>
31 #include <unistd.h>
32 #include <utime.h>
33
34 #include "winerror.h"
35 #include "windef.h"
36 #include "winbase.h"
37 #include "wine/winbase16.h"
38 #include "wine/port.h"
39 #include "drive.h"
40 #include "file.h"
41 #include "heap.h"
42 #include "msdos.h"
43 #include "task.h"
44 #include "wincon.h"
45 #include "debugtools.h"
46
47 #include "server.h"
48
49 DEFAULT_DEBUG_CHANNEL(file);
50
51 #if defined(MAP_ANONYMOUS) && !defined(MAP_ANON)
52 #define MAP_ANON MAP_ANONYMOUS
53 #endif
54
55 /* Size of per-process table of DOS handles */
56 #define DOS_TABLE_SIZE 256
57
58 static HANDLE dos_handles[DOS_TABLE_SIZE];
59
60
61 /***********************************************************************
62 * FILE_ConvertOFMode
63 *
64 * Convert OF_* mode into flags for CreateFile.
65 */
66 static void FILE_ConvertOFMode( INT mode, DWORD *access, DWORD *sharing )
67 {
68 switch(mode & 0x03)
69 {
70 case OF_READ: *access = GENERIC_READ; break;
71 case OF_WRITE: *access = GENERIC_WRITE; break;
72 case OF_READWRITE: *access = GENERIC_READ | GENERIC_WRITE; break;
73 default: *access = 0; break;
74 }
75 switch(mode & 0x70)
76 {
77 case OF_SHARE_EXCLUSIVE: *sharing = 0; break;
78 case OF_SHARE_DENY_WRITE: *sharing = FILE_SHARE_READ; break;
79 case OF_SHARE_DENY_READ: *sharing = FILE_SHARE_WRITE; break;
80 case OF_SHARE_DENY_NONE:
81 case OF_SHARE_COMPAT:
82 default: *sharing = FILE_SHARE_READ | FILE_SHARE_WRITE; break;
83 }
84 }
85
86
87 /***********************************************************************
88 * FILE_strcasecmp
89 *
90 * locale-independent case conversion for file I/O
91 */
92 int FILE_strcasecmp( const char *str1, const char *str2 )
93 {
94 for (;;)
95 {
96 int ret = FILE_toupper(*str1) - FILE_toupper(*str2);
97 if (ret || !*str1) return ret;
98 str1++;
99 str2++;
100 }
101 }
102
103
104 /***********************************************************************
105 * FILE_strncasecmp
106 *
107 * locale-independent case conversion for file I/O
108 */
109 int FILE_strncasecmp( const char *str1, const char *str2, int len )
110 {
111 int ret = 0;
112 for ( ; len > 0; len--, str1++, str2++)
113 if ((ret = FILE_toupper(*str1) - FILE_toupper(*str2)) || !*str1) break;
114 return ret;
115 }
116
117
118 /***********************************************************************
119 * FILE_SetDosError
120 *
121 * Set the DOS error code from errno.
122 */
123 void FILE_SetDosError(void)
124 {
125 int save_errno = errno; /* errno gets overwritten by printf */
126
127 TRACE("errno = %d %s\n", errno, strerror(errno));
128 switch (save_errno)
129 {
130 case EAGAIN:
131 SetLastError( ERROR_SHARING_VIOLATION );
132 break;
133 case EBADF:
134 SetLastError( ERROR_INVALID_HANDLE );
135 break;
136 case ENOSPC:
137 SetLastError( ERROR_HANDLE_DISK_FULL );
138 break;
139 case EACCES:
140 case EPERM:
141 case EROFS:
142 SetLastError( ERROR_ACCESS_DENIED );
143 break;
144 case EBUSY:
145 SetLastError( ERROR_LOCK_VIOLATION );
146 break;
147 case ENOENT:
148 SetLastError( ERROR_FILE_NOT_FOUND );
149 break;
150 case EISDIR:
151 SetLastError( ERROR_CANNOT_MAKE );
152 break;
153 case ENFILE:
154 case EMFILE:
155 SetLastError( ERROR_NO_MORE_FILES );
156 break;
157 case EEXIST:
158 SetLastError( ERROR_FILE_EXISTS );
159 break;
160 case EINVAL:
161 case ESPIPE:
162 SetLastError( ERROR_SEEK );
163 break;
164 case ENOTEMPTY:
165 SetLastError( ERROR_DIR_NOT_EMPTY );
166 break;
167 case ENOEXEC:
168 SetLastError( ERROR_BAD_FORMAT );
169 break;
170 default:
171 WARN( "unknown file error: %s", strerror(save_errno) );
172 SetLastError( ERROR_GEN_FAILURE );
173 break;
174 }
175 errno = save_errno;
176 }
177
178
179 /***********************************************************************
180 * FILE_DupUnixHandle
181 *
182 * Duplicate a Unix handle into a task handle.
183 * Returns 0 on failure.
184 */
185 HANDLE FILE_DupUnixHandle( int fd, DWORD access )
186 {
187 struct alloc_file_handle_request *req = get_req_buffer();
188 req->access = access;
189 server_call_fd( REQ_ALLOC_FILE_HANDLE, fd );
190 return req->handle;
191 }
192
193
194 /***********************************************************************
195 * FILE_GetUnixHandle
196 *
197 * Retrieve the Unix handle corresponding to a file handle.
198 * Returns -1 on failure.
199 */
200 int FILE_GetUnixHandle( HANDLE handle, DWORD access )
201 {
202 int ret, fd = -1;
203 SERVER_START_REQ
204 {
205 struct get_handle_fd_request *req = wine_server_alloc_req( sizeof(*req), 0 );
206 req->handle = handle;
207 req->access = access;
208 if (!(ret = server_call( REQ_GET_HANDLE_FD ))) fd = req->fd;
209 }
210 SERVER_END_REQ;
211 if (!ret)
212 {
213 if (fd == -1) return wine_server_recv_fd( handle, 1 );
214 fd = dup(fd);
215 }
216 return fd;
217 }
218
219
220 /*************************************************************************
221 * FILE_OpenConsole
222 *
223 * Open a handle to the current process console.
224 * Returns 0 on failure.
225 */
226 static HANDLE FILE_OpenConsole( BOOL output, DWORD access, LPSECURITY_ATTRIBUTES sa )
227 {
228 HANDLE ret;
229
230 SERVER_START_REQ
231 {
232 struct open_console_request *req = server_alloc_req( sizeof(*req), 0 );
233
234 req->output = output;
235 req->access = access;
236 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
237 SetLastError(0);
238 server_call( REQ_OPEN_CONSOLE );
239 ret = req->handle;
240 }
241 SERVER_END_REQ;
242 return ret;
243 }
244
245
246 /***********************************************************************
247 * FILE_CreateFile
248 *
249 * Implementation of CreateFile. Takes a Unix path name.
250 * Returns 0 on failure.
251 */
252 HANDLE FILE_CreateFile( LPCSTR filename, DWORD access, DWORD sharing,
253 LPSECURITY_ATTRIBUTES sa, DWORD creation,
254 DWORD attributes, HANDLE template, BOOL fail_read_only )
255 {
256 DWORD err;
257 HANDLE ret;
258 size_t len = strlen(filename);
259
260 if (len > REQUEST_MAX_VAR_SIZE)
261 {
262 FIXME("filename '%s' too long\n", filename );
263 SetLastError( ERROR_INVALID_PARAMETER );
264 return 0;
265 }
266
267 restart:
268 SERVER_START_REQ
269 {
270 struct create_file_request *req = server_alloc_req( sizeof(*req), len );
271 req->access = access;
272 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
273 req->sharing = sharing;
274 req->create = creation;
275 req->attrs = attributes;
276 memcpy( server_data_ptr(req), filename, len );
277 SetLastError(0);
278 err = server_call( REQ_CREATE_FILE );
279 ret = req->handle;
280 }
281 SERVER_END_REQ;
282
283 /* If write access failed, retry without GENERIC_WRITE */
284
285 if (!ret && !fail_read_only && (access & GENERIC_WRITE))
286 {
287 if ((err == STATUS_MEDIA_WRITE_PROTECTED) || (err == STATUS_ACCESS_DENIED))
288 {
289 TRACE("Write access failed for file '%s', trying without "
290 "write access\n", filename);
291 access &= ~GENERIC_WRITE;
292 goto restart;
293 }
294 }
295
296 if (!ret)
297 WARN("Unable to create file '%s' (GLE %ld)\n", filename,
298 GetLastError());
299
300 return ret;
301 }
302
303
304 /***********************************************************************
305 * FILE_CreateDevice
306 *
307 * Same as FILE_CreateFile but for a device
308 * Returns 0 on failure.
309 */
310 HANDLE FILE_CreateDevice( int client_id, DWORD access, LPSECURITY_ATTRIBUTES sa )
311 {
312 HANDLE ret;
313 SERVER_START_REQ
314 {
315 struct create_device_request *req = server_alloc_req( sizeof(*req), 0 );
316
317 req->access = access;
318 req->inherit = (sa && (sa->nLength>=sizeof(*sa)) && sa->bInheritHandle);
319 req->id = client_id;
320 SetLastError(0);
321 server_call( REQ_CREATE_DEVICE );
322 ret = req->handle;
323 }
324 SERVER_END_REQ;
325 return ret;
326 }
327
328
329 /*************************************************************************
330 * CreateFileA [KERNEL32.45] Creates or opens a file or other object
331 *
332 * Creates or opens an object, and returns a handle that can be used to
333 * access that object.
334 *
335 * PARAMS
336 *
337 * filename [I] pointer to filename to be accessed
338 * access [I] access mode requested
339 * sharing [I] share mode
340 * sa [I] pointer to security attributes
341 * creation [I] how to create the file
342 * attributes [I] attributes for newly created file
343 * template [I] handle to file with extended attributes to copy
344 *
345 * RETURNS
346 * Success: Open handle to specified file
347 * Failure: INVALID_HANDLE_VALUE
348 *
349 * NOTES
350 * Should call SetLastError() on failure.
351 *
352 * BUGS
353 *
354 * Doesn't support character devices, pipes, template files, or a
355 * lot of the 'attributes' flags yet.
356 */
357 HANDLE WINAPI CreateFileA( LPCSTR filename, DWORD access, DWORD sharing,
358 LPSECURITY_ATTRIBUTES sa, DWORD creation,
359 DWORD attributes, HANDLE template )
360 {
361 DOS_FULL_NAME full_name;
362 HANDLE ret;
363
364 if (!filename)
365 {
366 SetLastError( ERROR_INVALID_PARAMETER );
367 return INVALID_HANDLE_VALUE;
368 }
369 TRACE("%s %s%s%s%s%s%s%s\n",filename,
370 ((access & GENERIC_READ)==GENERIC_READ)?"GENERIC_READ ":"",
371 ((access & GENERIC_WRITE)==GENERIC_WRITE)?"GENERIC_WRITE ":"",
372 (!access)?"QUERY_ACCESS ":"",
373 ((sharing & FILE_SHARE_READ)==FILE_SHARE_READ)?"FILE_SHARE_READ ":"",
374 ((sharing & FILE_SHARE_WRITE)==FILE_SHARE_WRITE)?"FILE_SHARE_WRITE ":"",
375 ((sharing & FILE_SHARE_DELETE)==FILE_SHARE_DELETE)?"FILE_SHARE_DELETE ":"",
376 (creation ==CREATE_NEW)?"CREATE_NEW":
377 (creation ==CREATE_ALWAYS)?"CREATE_ALWAYS ":
378 (creation ==OPEN_EXISTING)?"OPEN_EXISTING ":
379 (creation ==OPEN_ALWAYS)?"OPEN_ALWAYS ":
380 (creation ==TRUNCATE_EXISTING)?"TRUNCATE_EXISTING ":"");
381
382 /* If the name starts with '\\?\', ignore the first 4 chars. */
383 if (!strncmp(filename, "\\\\?\\", 4))
384 {
385 filename += 4;
386 if (!strncmp(filename, "UNC\\", 4))
387 {
388 FIXME("UNC name (%s) not supported.\n", filename );
389 SetLastError( ERROR_PATH_NOT_FOUND );
390 return INVALID_HANDLE_VALUE;
391 }
392 }
393
394 if (!strncmp(filename, "\\\\.\\", 4)) {
395 if (!DOSFS_GetDevice( filename ))
396 {
397 ret = DEVICE_Open( filename+4, access, sa );
398 goto done;
399 }
400 else
401 filename+=4; /* fall into DOSFS_Device case below */
402 }
403
404 /* If the name still starts with '\\', it's a UNC name. */
405 if (!strncmp(filename, "\\\\", 2))
406 {
407 FIXME("UNC name (%s) not supported.\n", filename );
408 SetLastError( ERROR_PATH_NOT_FOUND );
409 return INVALID_HANDLE_VALUE;
410 }
411
412 /* If the name contains a DOS wild card (* or ?), do no create a file */
413 if(strchr(filename,'*') || strchr(filename,'?'))
414 return INVALID_HANDLE_VALUE;
415
416 /* Open a console for CONIN$ or CONOUT$ */
417 if (!strcasecmp(filename, "CONIN$"))
418 {
419 ret = FILE_OpenConsole( FALSE, access, sa );
420 goto done;
421 }
422 if (!strcasecmp(filename, "CONOUT$"))
423 {
424 ret = FILE_OpenConsole( TRUE, access, sa );
425 goto done;
426 }
427
428 if (DOSFS_GetDevice( filename ))
429 {
430 TRACE("opening device '%s'\n", filename );
431
432 if (!(ret = DOSFS_OpenDevice( filename, access )))
433 {
434 /* Do not silence this please. It is a critical error. -MM */
435 ERR("Couldn't open device '%s'!\n",filename);
436 SetLastError( ERROR_FILE_NOT_FOUND );
437 }
438 goto done;
439 }
440
441 /* check for filename, don't check for last entry if creating */
442 if (!DOSFS_GetFullName( filename,
443 (creation == OPEN_EXISTING) ||
444 (creation == TRUNCATE_EXISTING),
445 &full_name )) {
446 WARN("Unable to get full filename from '%s' (GLE %ld)\n",
447 filename, GetLastError());
448 return INVALID_HANDLE_VALUE;
449 }
450
451 ret = FILE_CreateFile( full_name.long_name, access, sharing,
452 sa, creation, attributes, template,
453 DRIVE_GetFlags(full_name.drive) & DRIVE_FAIL_READ_ONLY );
454 done:
455 if (!ret) ret = INVALID_HANDLE_VALUE;
456 return ret;
457 }
458
459
460
461 /*************************************************************************
462 * CreateFileW (KERNEL32.48)
463 */
464 HANDLE WINAPI CreateFileW( LPCWSTR filename, DWORD access, DWORD sharing,
465 LPSECURITY_ATTRIBUTES sa, DWORD creation,
466 DWORD attributes, HANDLE template)
467 {
468 LPSTR afn = HEAP_strdupWtoA( GetProcessHeap(), 0, filename );
469 HANDLE res = CreateFileA( afn, access, sharing, sa, creation, attributes, template );
470 HeapFree( GetProcessHeap(), 0, afn );
471 return res;
472 }
473
474
475 /***********************************************************************
476 * FILE_FillInfo
477 *
478 * Fill a file information from a struct stat.
479 */
480 static void FILE_FillInfo( struct stat *st, BY_HANDLE_FILE_INFORMATION *info )
481 {
482 if (S_ISDIR(st->st_mode))
483 info->dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
484 else
485 info->dwFileAttributes = FILE_ATTRIBUTE_ARCHIVE;
486 if (!(st->st_mode & S_IWUSR))
487 info->dwFileAttributes |= FILE_ATTRIBUTE_READONLY;
488
489 RtlSecondsSince1970ToTime( st->st_mtime, &info->ftCreationTime );
490 RtlSecondsSince1970ToTime( st->st_mtime, &info->ftLastWriteTime );
491 RtlSecondsSince1970ToTime( st->st_atime, &info->ftLastAccessTime );
492
493 info->dwVolumeSerialNumber = 0; /* FIXME */
494 info->nFileSizeHigh = 0;
495 info->nFileSizeLow = S_ISDIR(st->st_mode) ? 0 : st->st_size;
496 info->nNumberOfLinks = st->st_nlink;
497 info->nFileIndexHigh = 0;
498 info->nFileIndexLow = st->st_ino;
499 }
500
501
502 /***********************************************************************
503 * FILE_Stat
504 *
505 * Stat a Unix path name. Return TRUE if OK.
506 */
507 BOOL FILE_Stat( LPCSTR unixName, BY_HANDLE_FILE_INFORMATION *info )
508 {
509 struct stat st;
510
511 if (lstat( unixName, &st ) == -1)
512 {
513 FILE_SetDosError();
514 return FALSE;
515 }
516 if (!S_ISLNK(st.st_mode)) FILE_FillInfo( &st, info );
517 else
518 {
519 /* do a "real" stat to find out
520 about the type of the symlink destination */
521 if (stat( unixName, &st ) == -1)
522 {
523 FILE_SetDosError();
524 return FALSE;
525 }
526 FILE_FillInfo( &st, info );
527 info->dwFileAttributes |= FILE_ATTRIBUTE_SYMLINK;
528 }
529 return TRUE;
530 }
531
532
533 /***********************************************************************
534 * GetFileInformationByHandle (KERNEL32.219)
535 */
536 DWORD WINAPI GetFileInformationByHandle( HANDLE hFile,
537 BY_HANDLE_FILE_INFORMATION *info )
538 {
539 DWORD ret;
540 if (!info) return 0;
541
542 SERVER_START_REQ
543 {
544 struct get_file_info_request *req = server_alloc_req( sizeof(*req), 0 );
545 req->handle = hFile;
546 if ((ret = !server_call( REQ_GET_FILE_INFO )))
547 {
548 RtlSecondsSince1970ToTime( req->write_time, &info->ftCreationTime );
549 RtlSecondsSince1970ToTime( req->write_time, &info->ftLastWriteTime );
550 RtlSecondsSince1970ToTime( req->access_time, &info->ftLastAccessTime );
551 info->dwFileAttributes = req->attr;
552 info->dwVolumeSerialNumber = req->serial;
553 info->nFileSizeHigh = req->size_high;
554 info->nFileSizeLow = req->size_low;
555 info->nNumberOfLinks = req->links;
556 info->nFileIndexHigh = req->index_high;
557 info->nFileIndexLow = req->index_low;
558 }
559 }
560 SERVER_END_REQ;
561 return ret;
562 }
563
564
565 /**************************************************************************
566 * GetFileAttributes16 (KERNEL.420)
567 */
568 DWORD WINAPI GetFileAttributes16( LPCSTR name )
569 {
570 return GetFileAttributesA( name );
571 }
572
573
574 /**************************************************************************
575 * GetFileAttributesA (KERNEL32.217)
576 */
577 DWORD WINAPI GetFileAttributesA( LPCSTR name )
578 {
579 DOS_FULL_NAME full_name;
580 BY_HANDLE_FILE_INFORMATION info;
581
582 if (name == NULL || *name=='\0') return -1;
583
584 if (!DOSFS_GetFullName( name, TRUE, &full_name )) return -1;
585 if (!FILE_Stat( full_name.long_name, &info )) return -1;
586 return info.dwFileAttributes;
587 }
588
589
590 /**************************************************************************
591 * GetFileAttributesW (KERNEL32.218)
592 */
593 DWORD WINAPI GetFileAttributesW( LPCWSTR name )
594 {
595 LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, name );
596 DWORD res = GetFileAttributesA( nameA );
597 HeapFree( GetProcessHeap(), 0, nameA );
598 return res;
599 }
600
601
602 /***********************************************************************
603 * GetFileSize (KERNEL32.220)
604 */
605 DWORD WINAPI GetFileSize( HANDLE hFile, LPDWORD filesizehigh )
606 {
607 BY_HANDLE_FILE_INFORMATION info;
608 if (!GetFileInformationByHandle( hFile, &info )) return 0;
609 if (filesizehigh) *filesizehigh = info.nFileSizeHigh;
610 return info.nFileSizeLow;
611 }
612
613
614 /***********************************************************************
615 * GetFileTime (KERNEL32.221)
616 */
617 BOOL WINAPI GetFileTime( HANDLE hFile, FILETIME *lpCreationTime,
618 FILETIME *lpLastAccessTime,
619 FILETIME *lpLastWriteTime )
620 {
621 BY_HANDLE_FILE_INFORMATION info;
622 if (!GetFileInformationByHandle( hFile, &info )) return FALSE;
623 if (lpCreationTime) *lpCreationTime = info.ftCreationTime;
624 if (lpLastAccessTime) *lpLastAccessTime = info.ftLastAccessTime;
625 if (lpLastWriteTime) *lpLastWriteTime = info.ftLastWriteTime;
626 return TRUE;
627 }
628
629 /***********************************************************************
630 * CompareFileTime (KERNEL32.28)
631 */
632 INT WINAPI CompareFileTime( LPFILETIME x, LPFILETIME y )
633 {
634 if (!x || !y) return -1;
635
636 if (x->dwHighDateTime > y->dwHighDateTime)
637 return 1;
638 if (x->dwHighDateTime < y->dwHighDateTime)
639 return -1;
640 if (x->dwLowDateTime > y->dwLowDateTime)
641 return 1;
642 if (x->dwLowDateTime < y->dwLowDateTime)
643 return -1;
644 return 0;
645 }
646
647 /***********************************************************************
648 * FILE_GetTempFileName : utility for GetTempFileName
649 */
650 static UINT FILE_GetTempFileName( LPCSTR path, LPCSTR prefix, UINT unique,
651 LPSTR buffer, BOOL isWin16 )
652 {
653 static UINT unique_temp;
654 DOS_FULL_NAME full_name;
655 int i;
656 LPSTR p;
657 UINT num;
658
659 if ( !path || !prefix || !buffer ) return 0;
660
661 if (!unique_temp) unique_temp = time(NULL) & 0xffff;
662 num = unique ? (unique & 0xffff) : (unique_temp++ & 0xffff);
663
664 strcpy( buffer, path );
665 p = buffer + strlen(buffer);
666
667 /* add a \, if there isn't one and path is more than just the drive letter ... */
668 if ( !((strlen(buffer) == 2) && (buffer[1] == ':'))
669 && ((p == buffer) || (p[-1] != '\\'))) *p++ = '\\';
670
671 if (isWin16) *p++ = '~';
672 for (i = 3; (i > 0) && (*prefix); i--) *p++ = *prefix++;
673 sprintf( p, "%04x.tmp", num );
674
675 /* Now try to create it */
676
677 if (!unique)
678 {
679 do
680 {
681 HFILE handle = CreateFileA( buffer, GENERIC_WRITE, 0, NULL,
682 CREATE_NEW, FILE_ATTRIBUTE_NORMAL, 0 );
683 if (handle != INVALID_HANDLE_VALUE)
684 { /* We created it */
685 TRACE("created %s\n",
686 buffer);
687 CloseHandle( handle );
688 break;
689 }
690 if (GetLastError() != ERROR_FILE_EXISTS)
691 break; /* No need to go on */
692 num++;
693 sprintf( p, "%04x.tmp", num );
694 } while (num != (unique & 0xffff));
695 }
696
697 /* Get the full path name */
698
699 if (DOSFS_GetFullName( buffer, FALSE, &full_name ))
700 {
701 /* Check if we have write access in the directory */
702 if ((p = strrchr( full_name.long_name, '/' ))) *p = '\0';
703 if (access( full_name.long_name, W_OK ) == -1)
704 WARN("returns '%s', which doesn't seem to be writeable.\n",
705 buffer);
706 }
707 TRACE("returning %s\n", buffer );
708 return unique ? unique : num;
709 }
710
711
712 /***********************************************************************
713 * GetTempFileNameA (KERNEL32.290)
714 */
715 UINT WINAPI GetTempFileNameA( LPCSTR path, LPCSTR prefix, UINT unique,
716 LPSTR buffer)
717 {
718 return FILE_GetTempFileName(path, prefix, unique, buffer, FALSE);
719 }
720
721 /***********************************************************************
722 * GetTempFileNameW (KERNEL32.291)
723 */
724 UINT WINAPI GetTempFileNameW( LPCWSTR path, LPCWSTR prefix, UINT unique,
725 LPWSTR buffer )
726 {
727 LPSTR patha,prefixa;
728 char buffera[144];
729 UINT ret;
730
731 if (!path) return 0;
732 patha = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
733 prefixa = HEAP_strdupWtoA( GetProcessHeap(), 0, prefix );
734 ret = FILE_GetTempFileName( patha, prefixa, unique, buffera, FALSE );
735 MultiByteToWideChar( CP_ACP, 0, buffera, -1, buffer, MAX_PATH );
736 HeapFree( GetProcessHeap(), 0, patha );
737 HeapFree( GetProcessHeap(), 0, prefixa );
738 return ret;
739 }
740
741
742 /***********************************************************************
743 * GetTempFileName16 (KERNEL.97)
744 */
745 UINT16 WINAPI GetTempFileName16( BYTE drive, LPCSTR prefix, UINT16 unique,
746 LPSTR buffer )
747 {
748 char temppath[144];
749
750 if (!(drive & ~TF_FORCEDRIVE)) /* drive 0 means current default drive */
751 drive |= DRIVE_GetCurrentDrive() + 'A';
752
753 if ((drive & TF_FORCEDRIVE) &&
754 !DRIVE_IsValid( toupper(drive & ~TF_FORCEDRIVE) - 'A' ))
755 {
756 drive &= ~TF_FORCEDRIVE;
757 WARN("invalid drive %d specified\n", drive );
758 }
759
760 if (drive & TF_FORCEDRIVE)
761 sprintf(temppath,"%c:", drive & ~TF_FORCEDRIVE );
762 else
763 GetTempPathA( 132, temppath );
764 return (UINT16)FILE_GetTempFileName( temppath, prefix, unique, buffer, TRUE );
765 }
766
767 /***********************************************************************
768 * FILE_DoOpenFile
769 *
770 * Implementation of OpenFile16() and OpenFile32().
771 */
772 static HFILE FILE_DoOpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode,
773 BOOL win32 )
774 {
775 HFILE hFileRet;
776 FILETIME filetime;
777 WORD filedatetime[2];
778 DOS_FULL_NAME full_name;
779 DWORD access, sharing;
780 char *p;
781
782 if (!ofs) return HFILE_ERROR;
783
784 TRACE("%s %s %s %s%s%s%s%s%s%s%s%s\n",name,
785 ((mode & 0x3 )==OF_READ)?"OF_READ":
786 ((mode & 0x3 )==OF_WRITE)?"OF_WRITE":
787 ((mode & 0x3 )==OF_READWRITE)?"OF_READWRITE":"unknown",
788 ((mode & 0x70 )==OF_SHARE_COMPAT)?"OF_SHARE_COMPAT":
789 ((mode & 0x70 )==OF_SHARE_DENY_NONE)?"OF_SHARE_DENY_NONE":
790 ((mode & 0x70 )==OF_SHARE_DENY_READ)?"OF_SHARE_DENY_READ":
791 ((mode & 0x70 )==OF_SHARE_DENY_WRITE)?"OF_SHARE_DENY_WRITE":
792 ((mode & 0x70 )==OF_SHARE_EXCLUSIVE)?"OF_SHARE_EXCLUSIVE":"unknown",
793 ((mode & OF_PARSE )==OF_PARSE)?"OF_PARSE ":"",
794 ((mode & OF_DELETE )==OF_DELETE)?"OF_DELETE ":"",
795 ((mode & OF_VERIFY )==OF_VERIFY)?"OF_VERIFY ":"",
796 ((mode & OF_SEARCH )==OF_SEARCH)?"OF_SEARCH ":"",
797 ((mode & OF_CANCEL )==OF_CANCEL)?"OF_CANCEL ":"",
798 ((mode & OF_CREATE )==OF_CREATE)?"OF_CREATE ":"",
799 ((mode & OF_PROMPT )==OF_PROMPT)?"OF_PROMPT ":"",
800 ((mode & OF_EXIST )==OF_EXIST)?"OF_EXIST ":"",
801 ((mode & OF_REOPEN )==OF_REOPEN)?"OF_REOPEN ":""
802 );
803
804
805 ofs->cBytes = sizeof(OFSTRUCT);
806 ofs->nErrCode = 0;
807 if (mode & OF_REOPEN) name = ofs->szPathName;
808
809 if (!name) {
810 ERR("called with `name' set to NULL ! Please debug.\n");
811 return HFILE_ERROR;
812 }
813
814 TRACE("%s %04x\n", name, mode );
815
816 /* the watcom 10.6 IDE relies on a valid path returned in ofs->szPathName
817 Are there any cases where getting the path here is wrong?
818 Uwe Bonnes 1997 Apr 2 */
819 if (!GetFullPathNameA( name, sizeof(ofs->szPathName),
820 ofs->szPathName, NULL )) goto error;
821 FILE_ConvertOFMode( mode, &access, &sharing );
822
823 /* OF_PARSE simply fills the structure */
824
825 if (mode & OF_PARSE)
826 {
827 ofs->fFixedDisk = (GetDriveType16( ofs->szPathName[0]-'A' )
828 != DRIVE_REMOVABLE);
829 TRACE("(%s): OF_PARSE, res = '%s'\n",
830 name, ofs->szPathName );
831 return 0;
832 }
833
834 /* OF_CREATE is completely different from all other options, so
835 handle it first */
836
837 if (mode & OF_CREATE)
838 {
839 if ((hFileRet = CreateFileA( name, GENERIC_READ | GENERIC_WRITE,
840 sharing, NULL, CREATE_ALWAYS,
841 FILE_ATTRIBUTE_NORMAL, 0 ))== INVALID_HANDLE_VALUE)
842 goto error;
843 goto success;
844 }
845
846 /* If OF_SEARCH is set, ignore the given path */
847
848 if ((mode & OF_SEARCH) && !(mode & OF_REOPEN))
849 {
850 /* First try the file name as is */
851 if (DOSFS_GetFullName( name, TRUE, &full_name )) goto found;
852 /* Now remove the path */
853 if (name[0] && (name[1] == ':')) name += 2;
854 if ((p = strrchr( name, '\\' ))) name = p + 1;
855 if ((p = strrchr( name, '/' ))) name = p + 1;
856 if (!name[0]) goto not_found;
857 }
858
859 /* Now look for the file */
860
861 if (!DIR_SearchPath( NULL, name, NULL, &full_name, win32 )) goto not_found;
862
863 found:
864 TRACE("found %s = %s\n",
865 full_name.long_name, full_name.short_name );
866 lstrcpynA( ofs->szPathName, full_name.short_name,
867 sizeof(ofs->szPathName) );
868
869 if (mode & OF_SHARE_EXCLUSIVE)
870 /* Some InstallShield version uses OF_SHARE_EXCLUSIVE
871 on the file <tempdir>/_ins0432._mp to determine how
872 far installation has proceeded.
873 _ins0432._mp is an executable and while running the
874 application expects the open with OF_SHARE_ to fail*/
875 /* Probable FIXME:
876 As our loader closes the files after loading the executable,
877 we can't find the running executable with FILE_InUse.
878 Perhaps the loader should keep the file open.
879 Recheck against how Win handles that case */
880 {
881 char *last = strrchr(full_name.long_name,'/');
882 if (!last)
883 last = full_name.long_name - 1;
884 if (GetModuleHandle16(last+1))
885 {
886 TRACE("Denying shared open for %s\n",full_name.long_name);
887 return HFILE_ERROR;
888 }
889 }
890
891 if (mode & OF_DELETE)
892 {
893 if (unlink( full_name.long_name ) == -1) goto not_found;
894 TRACE("(%s): OF_DELETE return = OK\n", name);
895 return 1;
896 }
897
898 hFileRet = FILE_CreateFile( full_name.long_name, access, sharing,
899 NULL, OPEN_EXISTING, 0, 0,
900 DRIVE_GetFlags(full_name.drive) & DRIVE_FAIL_READ_ONLY );
901 if (!hFileRet) goto not_found;
902
903 GetFileTime( hFileRet, NULL, NULL, &filetime );
904 FileTimeToDosDateTime( &filetime, &filedatetime[0], &filedatetime[1] );
905 if ((mode & OF_VERIFY) && (mode & OF_REOPEN))
906 {
907 if (memcmp( ofs->reserved, filedatetime, sizeof(ofs->reserved) ))
908 {
909 CloseHandle( hFileRet );
910 WARN("(%s): OF_VERIFY failed\n", name );
911 /* FIXME: what error here? */
912 SetLastError( ERROR_FILE_NOT_FOUND );
913 goto error;
914 }
915 }
916 memcpy( ofs->reserved, filedatetime, sizeof(ofs->reserved) );
917
918 success: /* We get here if the open was successful */
919 TRACE("(%s): OK, return = %d\n", name, hFileRet );
920 if (win32)
921 {
922 if (mode & OF_EXIST) /* Return the handle, but close it first */
923 CloseHandle( hFileRet );
924 }
925 else
926 {
927 hFileRet = Win32HandleToDosFileHandle( hFileRet );
928 if (hFileRet == HFILE_ERROR16) goto error;
929 if (mode & OF_EXIST) /* Return the handle, but close it first */
930 _lclose16( hFileRet );
931 }
932 return hFileRet;
933
934 not_found: /* We get here if the file does not exist */
935 WARN("'%s' not found or sharing violation\n", name );
936 SetLastError( ERROR_FILE_NOT_FOUND );
937 /* fall through */
938
939 error: /* We get here if there was an error opening the file */
940 ofs->nErrCode = GetLastError();
941 WARN("(%s): return = HFILE_ERROR error= %d\n",
942 name,ofs->nErrCode );
943 return HFILE_ERROR;
944 }
945
946
947 /***********************************************************************
948 * OpenFile16 (KERNEL.74)
949 */
950 HFILE16 WINAPI OpenFile16( LPCSTR name, OFSTRUCT *ofs, UINT16 mode )
951 {
952 return FILE_DoOpenFile( name, ofs, mode, FALSE );
953 }
954
955
956 /***********************************************************************
957 * OpenFile (KERNEL32.396)
958 */
959 HFILE WINAPI OpenFile( LPCSTR name, OFSTRUCT *ofs, UINT mode )
960 {
961 return FILE_DoOpenFile( name, ofs, mode, TRUE );
962 }
963
964
965 /***********************************************************************
966 * FILE_InitProcessDosHandles
967 *
968 * Allocates the default DOS handles for a process. Called either by
969 * Win32HandleToDosFileHandle below or by the DOSVM stuff.
970 */
971 static void FILE_InitProcessDosHandles( void )
972 {
973 dos_handles[0] = GetStdHandle(STD_INPUT_HANDLE);
974 dos_handles[1] = GetStdHandle(STD_OUTPUT_HANDLE);
975 dos_handles[2] = GetStdHandle(STD_ERROR_HANDLE);
976 dos_handles[3] = GetStdHandle(STD_ERROR_HANDLE);
977 dos_handles[4] = GetStdHandle(STD_ERROR_HANDLE);
978 }
979
980 /***********************************************************************
981 * Win32HandleToDosFileHandle (KERNEL32.21)
982 *
983 * Allocate a DOS handle for a Win32 handle. The Win32 handle is no
984 * longer valid after this function (even on failure).
985 *
986 * Note: this is not exactly right, since on Win95 the Win32 handles
987 * are on top of DOS handles and we do it the other way
988 * around. Should be good enough though.
989 */
990 HFILE WINAPI Win32HandleToDosFileHandle( HANDLE handle )
991 {
992 int i;
993
994 if (!handle || (handle == INVALID_HANDLE_VALUE))
995 return HFILE_ERROR;
996
997 for (i = 5; i < DOS_TABLE_SIZE; i++)
998 if (!dos_handles[i])
999 {
1000 dos_handles[i] = handle;
1001 TRACE("Got %d for h32 %d\n", i, handle );
1002 return (HFILE)i;
1003 }
1004 CloseHandle( handle );
1005 SetLastError( ERROR_TOO_MANY_OPEN_FILES );
1006 return HFILE_ERROR;
1007 }
1008
1009
1010 /***********************************************************************
1011 * DosFileHandleToWin32Handle (KERNEL32.20)
1012 *
1013 * Return the Win32 handle for a DOS handle.
1014 *
1015 * Note: this is not exactly right, since on Win95 the Win32 handles
1016 * are on top of DOS handles and we do it the other way
1017 * around. Should be good enough though.
1018 */
1019 HANDLE WINAPI DosFileHandleToWin32Handle( HFILE handle )
1020 {
1021 HFILE16 hfile = (HFILE16)handle;
1022 if (hfile < 5 && !dos_handles[hfile]) FILE_InitProcessDosHandles();
1023 if ((hfile >= DOS_TABLE_SIZE) || !dos_handles[hfile])
1024 {
1025 SetLastError( ERROR_INVALID_HANDLE );
1026 return INVALID_HANDLE_VALUE;
1027 }
1028 return dos_handles[hfile];
1029 }
1030
1031
1032 /***********************************************************************
1033 * DisposeLZ32Handle (KERNEL32.22)
1034 *
1035 * Note: this is not entirely correct, we should only close the
1036 * 32-bit handle and not the 16-bit one, but we cannot do
1037 * this because of the way our DOS handles are implemented.
1038 * It shouldn't break anything though.
1039 */
1040 void WINAPI DisposeLZ32Handle( HANDLE handle )
1041 {
1042 int i;
1043
1044 if (!handle || (handle == INVALID_HANDLE_VALUE)) return;
1045
1046 for (i = 5; i < DOS_TABLE_SIZE; i++)
1047 if (dos_handles[i] == handle)
1048 {
1049 dos_handles[i] = 0;
1050 CloseHandle( handle );
1051 break;
1052 }
1053 }
1054
1055
1056 /***********************************************************************
1057 * FILE_Dup2
1058 *
1059 * dup2() function for DOS handles.
1060 */
1061 HFILE16 FILE_Dup2( HFILE16 hFile1, HFILE16 hFile2 )
1062 {
1063 HANDLE new_handle;
1064
1065 if (hFile1 < 5 && !dos_handles[hFile1]) FILE_InitProcessDosHandles();
1066
1067 if ((hFile1 >= DOS_TABLE_SIZE) || (hFile2 >= DOS_TABLE_SIZE) || !dos_handles[hFile1])
1068 {
1069 SetLastError( ERROR_INVALID_HANDLE );
1070 return HFILE_ERROR16;
1071 }
1072 if (hFile2 < 5)
1073 {
1074 FIXME("stdio handle closed, need proper conversion\n" );
1075 SetLastError( ERROR_INVALID_HANDLE );
1076 return HFILE_ERROR16;
1077 }
1078 if (!DuplicateHandle( GetCurrentProcess(), dos_handles[hFile1],
1079 GetCurrentProcess(), &new_handle,
1080 0, FALSE, DUPLICATE_SAME_ACCESS ))
1081 return HFILE_ERROR16;
1082 if (dos_handles[hFile2]) CloseHandle( dos_handles[hFile2] );
1083 dos_handles[hFile2] = new_handle;
1084 return hFile2;
1085 }
1086
1087
1088 /***********************************************************************
1089 * _lclose16 (KERNEL.81)
1090 */
1091 HFILE16 WINAPI _lclose16( HFILE16 hFile )
1092 {
1093 if (hFile < 5)
1094 {
1095 FIXME("stdio handle closed, need proper conversion\n" );
1096 SetLastError( ERROR_INVALID_HANDLE );
1097 return HFILE_ERROR16;
1098 }
1099 if ((hFile >= DOS_TABLE_SIZE) || !dos_handles[hFile])
1100 {
1101 SetLastError( ERROR_INVALID_HANDLE );
1102 return HFILE_ERROR16;
1103 }
1104 TRACE("%d (handle32=%d)\n", hFile, dos_handles[hFile] );
1105 CloseHandle( dos_handles[hFile] );
1106 dos_handles[hFile] = 0;
1107 return 0;
1108 }
1109
1110
1111 /***********************************************************************
1112 * _lclose (KERNEL32.592)
1113 */
1114 HFILE WINAPI _lclose( HFILE hFile )
1115 {
1116 TRACE("handle %d\n", hFile );
1117 return CloseHandle( hFile ) ? 0 : HFILE_ERROR;
1118 }
1119
1120 /***********************************************************************
1121 * GetOverlappedResult (KERNEL32.360)
1122 *
1123 * Check the result of an Asynchronous data transfer from a file.
1124 *
1125 * RETURNS
1126 * TRUE on success
1127 * FALSE on failure
1128 *
1129 * If successful (and relevant) lpTransfered will hold the number of
1130 * bytes transfered during the async operation.
1131 *
1132 * BUGS
1133 *
1134 * Currently only works for WaitCommEvent, ReadFile, WriteFile
1135 * with communications ports.
1136 *
1137 */
1138 BOOL WINAPI GetOverlappedResult(
1139 HANDLE hFile, /* [I] handle of file to check on */
1140 LPOVERLAPPED lpOverlapped, /* [I/O] pointer to overlapped */
1141 LPDWORD lpTransferred, /* [I/O] number of bytes transfered */
1142 BOOL bWait /* [I] wait for the transfer to complete ? */
1143 ) {
1144 DWORD r;
1145
1146 TRACE("(%d %p %p %x)\n", hFile, lpOverlapped, lpTransferred, bWait);
1147
1148 if(lpOverlapped==NULL)
1149 {
1150 ERR("lpOverlapped was null\n");
1151 return FALSE;
1152 }
1153 if(!lpOverlapped->hEvent)
1154 {
1155 ERR("lpOverlapped->hEvent was null\n");
1156 return FALSE;
1157 }
1158
1159 do {
1160 TRACE("waiting on %p\n",lpOverlapped);
1161 r = WaitForSingleObjectEx(lpOverlapped->hEvent, bWait?INFINITE:0, TRUE);
1162 TRACE("wait on %p returned %ld\n",lpOverlapped,r);
1163 } while (r==STATUS_USER_APC);
1164
1165 if(lpTransferred)
1166 *lpTransferred = lpOverlapped->Offset;
1167
1168 SetLastError(lpOverlapped->Internal);
1169
1170 return (r==WAIT_OBJECT_0);
1171 }
1172
1173 /***********************************************************************
1174 * FILE_AsyncResult (INTERNAL)
1175 */
1176 static int FILE_AsyncResult(HANDLE hAsync, int result)
1177 {
1178 int r;
1179
1180 SERVER_START_REQ
1181 {
1182 struct async_result_request *req = server_alloc_req(sizeof *req,0);
1183
1184 req->ov_handle = hAsync;
1185 req->result = result;
1186
1187 r = server_call( REQ_ASYNC_RESULT);
1188 }
1189 SERVER_END_REQ
1190
1191 return !r;
1192 }
1193
1194 /***********************************************************************
1195 * FILE_AsyncReadService (INTERNAL)
1196 */
1197 static void FILE_AsyncReadService(void **args)
1198 {
1199 LPOVERLAPPED lpOverlapped = (LPOVERLAPPED)args[0];
1200 LPDWORD buffer = (LPDWORD)args[1];
1201 DWORD events = (DWORD)args[2];
1202 int fd, result, r;
1203
1204 TRACE("%p %p %08lx\n", lpOverlapped, buffer, events );
1205
1206 /* if there are no events, it must be a timeout */
1207 if(events==0)
1208 {
1209 TRACE("read timed out\n");
1210 /* r = STATUS_TIMEOUT; */
1211 r = STATUS_SUCCESS;
1212 goto async_end;
1213 }
1214
1215 fd = FILE_GetUnixHandle(lpOverlapped->InternalHigh, GENERIC_READ);
1216 if(fd<0)
1217 {
1218 TRACE("FILE_GetUnixHandle(%ld) failed \n",lpOverlapped->InternalHigh);
1219 r = STATUS_UNSUCCESSFUL;
1220 goto async_end;
1221 }
1222
1223 /* check to see if the data is ready (non-blocking) */
1224 result = read(fd, &buffer[lpOverlapped->Offset],
1225 lpOverlapped->OffsetHigh - lpOverlapped->Offset);
1226 close(fd);
1227
1228 if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
1229 {
1230 TRACE("Deferred read %d\n",errno);
1231 r = STATUS_PENDING;
1232 goto async_end;
1233 }
1234
1235 /* check to see if the transfer is complete */
1236 if(result<0)
1237 {
1238 TRACE("read returned errno %d\n",errno);
1239 r = STATUS_UNSUCCESSFUL;
1240 goto async_end;
1241 }
1242
1243 lpOverlapped->Offset += result;
1244 TRACE("read %d more bytes %ld/%ld so far\n",result,lpOverlapped->Offset,lpOverlapped->OffsetHigh);
1245
1246 if(lpOverlapped->Offset < lpOverlapped->OffsetHigh)
1247 r = STATUS_PENDING;
1248 else
1249 r = STATUS_SUCCESS;
1250
1251 async_end:
1252 lpOverlapped->Internal = r;
1253 if ( (r!=STATUS_PENDING)
1254 || (!FILE_AsyncResult( lpOverlapped->InternalHigh, r)))
1255 {
1256 /* close the handle to the async operation */
1257 if(lpOverlapped->InternalHigh)
1258 CloseHandle(lpOverlapped->InternalHigh);
1259 lpOverlapped->InternalHigh = 0;
1260
1261 NtSetEvent( lpOverlapped->hEvent, NULL );
1262 TRACE("set event flag\n");
1263 }
1264 }
1265
1266 /***********************************************************************
1267 * FILE_StartAsyncRead (INTERNAL)
1268 */
1269 static BOOL FILE_StartAsyncRead( HANDLE hFile, LPOVERLAPPED overlapped, LPVOID buffer, DWORD count)
1270 {
1271 int r;
1272
1273 SERVER_START_REQ
1274 {
1275 struct create_async_request *req = server_alloc_req(sizeof *req,0);
1276
1277 req->file_handle = hFile;
1278 req->overlapped = overlapped;
1279 req->buffer = buffer;
1280 req->count = count;
1281 req->func = FILE_AsyncReadService;
1282 req->type = ASYNC_TYPE_READ;
1283
1284 r=server_call( REQ_CREATE_ASYNC );
1285
1286 overlapped->InternalHigh = req->ov_handle;
1287 }
1288 SERVER_END_REQ
1289
1290 if(!r)
1291 {
1292 TRACE("ov=%ld IO is pending!!!\n",overlapped->InternalHigh);
1293 SetLastError(ERROR_IO_PENDING);
1294 }
1295
1296 return !r;
1297 }
1298
1299 /***********************************************************************
1300 * ReadFile (KERNEL32.577)
1301 */
1302 BOOL WINAPI ReadFile( HANDLE hFile, LPVOID buffer, DWORD bytesToRead,
1303 LPDWORD bytesRead, LPOVERLAPPED overlapped )
1304 {
1305 int unix_handle, result;
1306
1307 TRACE("%d %p %ld %p %p\n", hFile, buffer, bytesToRead,
1308 bytesRead, overlapped );
1309
1310 if (bytesRead) *bytesRead = 0; /* Do this before anything else */
1311 if (!bytesToRead) return TRUE;
1312
1313 /* this will only have impact if the overlapped structure is specified */
1314 if ( overlapped )
1315 {
1316 /* if overlapped, check that there is an event flag */
1317 if ( (overlapped->hEvent == 0) ||
1318 (overlapped->hEvent == INVALID_HANDLE_VALUE) )
1319 {
1320 return FALSE;
1321 }
1322
1323 overlapped->Offset = 0;
1324 overlapped->OffsetHigh = bytesToRead;
1325 overlapped->Internal = 0;
1326 overlapped->InternalHigh = 0;
1327
1328 NtResetEvent( overlapped->hEvent, NULL );
1329
1330 if(FILE_StartAsyncRead(hFile, overlapped, buffer, bytesToRead))
1331 {
1332 overlapped->Internal = STATUS_PENDING;
1333 }
1334
1335 /* always fail on return, either ERROR_IO_PENDING or other error */
1336 return FALSE;
1337 }
1338
1339 unix_handle = FILE_GetUnixHandle( hFile, GENERIC_READ );
1340 if (unix_handle == -1) return FALSE;
1341
1342 /* code for synchronous reads */
1343 while ((result = read( unix_handle, buffer, bytesToRead )) == -1)
1344 {
1345 if ((errno == EAGAIN) || (errno == EINTR)) continue;
1346 if ((errno == EFAULT) && !IsBadWritePtr( buffer, bytesToRead )) continue;
1347 FILE_SetDosError();
1348 break;
1349 }
1350 close( unix_handle );
1351 if (result == -1) return FALSE;
1352 if (bytesRead) *bytesRead = result;
1353 return TRUE;
1354 }
1355
1356 /***********************************************************************
1357 * FILE_AsyncWriteService (INTERNAL)
1358 */
1359 static void FILE_AsyncWriteService(void **args)
1360 {
1361 LPOVERLAPPED lpOverlapped = (LPOVERLAPPED)args[0];
1362 LPDWORD buffer = (LPDWORD)args[1];
1363 DWORD events = (DWORD)args[2];
1364 int fd, result, r;
1365
1366 TRACE("(%p %p %lx)\n",lpOverlapped,buffer,events);
1367
1368 /* if there are no events, it must be a timeout */
1369 if(events==0)
1370 {
1371 TRACE("write timed out\n");
1372 r = STATUS_TIMEOUT;
1373 goto async_end;
1374 }
1375
1376 fd = FILE_GetUnixHandle(lpOverlapped->InternalHigh, GENERIC_WRITE);
1377 if(fd<0)
1378 {
1379 ERR("FILE_GetUnixHandle(%ld) failed \n",lpOverlapped->InternalHigh);
1380 r = STATUS_UNSUCCESSFUL;
1381 goto async_end;
1382 }
1383
1384 /* write some data (non-blocking) */
1385 result = write(fd, &buffer[lpOverlapped->Offset],
1386 lpOverlapped->OffsetHigh-lpOverlapped->Offset);
1387 close(fd);
1388
1389 if ( (result<0) && ((errno == EAGAIN) || (errno == EINTR)))
1390 {
1391 r = STATUS_PENDING;
1392 goto async_end;
1393 }
1394
1395 /* check to see if the transfer is complete */
1396 if(result<0)
1397 {
1398 r = STATUS_UNSUCCESSFUL;
1399 goto async_end;
1400 }
1401
1402 lpOverlapped->Offset += result;
1403
1404 if(lpOverlapped->Offset < lpOverlapped->OffsetHigh)
1405 r = STATUS_PENDING;
1406 else
1407 r = STATUS_SUCCESS;
1408
1409 async_end:
1410 lpOverlapped->Internal = r;
1411 if ( (r!=STATUS_PENDING)
1412 || (!FILE_AsyncResult( lpOverlapped->InternalHigh, r)))
1413 {
1414 /* close the handle to the async operation */
1415 CloseHandle(lpOverlapped->InternalHigh);
1416 lpOverlapped->InternalHigh = 0;
1417
1418 NtSetEvent( lpOverlapped->hEvent, NULL );
1419 }
1420 }
1421
1422 /***********************************************************************
1423 * FILE_StartAsyncWrite (INTERNAL)
1424 */
1425 static BOOL FILE_StartAsyncWrite(HANDLE hFile, LPOVERLAPPED overlapped, LPCVOID buffer,DWORD count)
1426 {
1427 int r;
1428
1429 SERVER_START_REQ
1430 {
1431 struct create_async_request *req = get_req_buffer();
1432
1433 req->file_handle = hFile;
1434 req->buffer = (LPVOID)buffer;
1435 req->overlapped = overlapped;
1436 req->count = 0;
1437 req->func = FILE_AsyncWriteService;
1438 req->type = ASYNC_TYPE_WRITE;
1439
1440 r = server_call( REQ_CREATE_ASYNC );
1441
1442 overlapped->InternalHigh = req->ov_handle;
1443 }
1444 SERVER_END_REQ
1445
1446 if(!r)
1447 {
1448 SetLastError(ERROR_IO_PENDING);
1449 }
1450
1451 return !r;
1452 }
1453
1454 /***********************************************************************
1455 * WriteFile (KERNEL32.738)
1456 */
1457 BOOL WINAPI WriteFile( HANDLE hFile, LPCVOID buffer, DWORD bytesToWrite,
1458 LPDWORD bytesWritten, LPOVERLAPPED overlapped )
1459 {
1460 int unix_handle, result;
1461
1462 TRACE("%d %p %ld %p %p\n", hFile, buffer, bytesToWrite,
1463 bytesWritten, overlapped );
1464
1465 if (bytesWritten) *bytesWritten = 0; /* Do this before anything else */
1466 if (!bytesToWrite) return TRUE;
1467
1468 /* this will only have impact if the overlappd structure is specified */
1469 if ( overlapped )
1470 {
1471 if ( (overlapped->hEvent == 0) ||
1472 (overlapped->hEvent == INVALID_HANDLE_VALUE) )
1473 return FALSE;
1474
1475 overlapped->Offset = 0;
1476 overlapped->OffsetHigh = bytesToWrite;
1477 overlapped->Internal = 0;
1478 overlapped->InternalHigh = 0;
1479
1480 NtResetEvent( overlapped->hEvent, NULL );
1481
1482 if (FILE_StartAsyncWrite(hFile, overlapped, buffer, bytesToWrite))
1483 {
1484 overlapped->Internal = STATUS_PENDING;
1485 }
1486
1487 /* always fail on return, either ERROR_IO_PENDING or other error */
1488 return FALSE;
1489 }
1490
1491 unix_handle = FILE_GetUnixHandle( hFile, GENERIC_WRITE );
1492 if (unix_handle == -1) return FALSE;
1493
1494 /* synchronous file write */
1495 while ((result = write( unix_handle, buffer, bytesToWrite )) == -1)
1496 {
1497 if ((errno == EAGAIN) || (errno == EINTR)) continue;
1498 if ((errno == EFAULT) && !IsBadReadPtr( buffer, bytesToWrite )) continue;
1499 if (errno == ENOSPC)
1500 SetLastError( ERROR_DISK_FULL );
1501 else
1502 FILE_SetDosError();
1503 break;
1504 }
1505 close( unix_handle );
1506 if (result == -1) return FALSE;
1507 if (bytesWritten) *bytesWritten = result;
1508 return TRUE;
1509 }
1510
1511
1512 /***********************************************************************
1513 * WIN16_hread
1514 */
1515 LONG WINAPI WIN16_hread( HFILE16 hFile, SEGPTR buffer, LONG count )
1516 {
1517 LONG maxlen;
1518
1519 TRACE("%d %08lx %ld\n",
1520 hFile, (DWORD)buffer, count );
1521
1522 /* Some programs pass a count larger than the allocated buffer */
1523 maxlen = GetSelectorLimit16( SELECTOROF(buffer) ) - OFFSETOF(buffer) + 1;
1524 if (count > maxlen) count = maxlen;
1525 return _lread(DosFileHandleToWin32Handle(hFile), MapSL(buffer), count );
1526 }
1527
1528
1529 /***********************************************************************
1530 * WIN16_lread
1531 */
1532 UINT16 WINAPI WIN16_lread( HFILE16 hFile, SEGPTR buffer, UINT16 count )
1533 {
1534 return (UINT16)WIN16_hread( hFile, buffer, (LONG)count );
1535 }
1536
1537
1538 /***********************************************************************
1539 * _lread (KERNEL32.596)
1540 */
1541 UINT WINAPI _lread( HFILE handle, LPVOID buffer, UINT count )
1542 {
1543 DWORD result;
1544 if (!ReadFile( handle, buffer, count, &result, NULL )) return -1;
1545 return result;
1546 }
1547
1548
1549 /***********************************************************************
1550 * _lread16 (KERNEL.82)
1551 */
1552 UINT16 WINAPI _lread16( HFILE16 hFile, LPVOID buffer, UINT16 count )
1553 {
1554 return (UINT16)_lread(DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
1555 }
1556
1557
1558 /***********************************************************************
1559 * _lcreat16 (KERNEL.83)
1560 */
1561 HFILE16 WINAPI _lcreat16( LPCSTR path, INT16 attr )
1562 {
1563 return Win32HandleToDosFileHandle( _lcreat( path, attr ) );
1564 }
1565
1566
1567 /***********************************************************************
1568 * _lcreat (KERNEL32.593)
1569 */
1570 HFILE WINAPI _lcreat( LPCSTR path, INT attr )
1571 {
1572 /* Mask off all flags not explicitly allowed by the doc */
1573 attr &= FILE_ATTRIBUTE_READONLY | FILE_ATTRIBUTE_HIDDEN | FILE_ATTRIBUTE_SYSTEM;
1574 TRACE("%s %02x\n", path, attr );
1575 return CreateFileA( path, GENERIC_READ | GENERIC_WRITE,
1576 FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
1577 CREATE_ALWAYS, attr, 0 );
1578 }
1579
1580
1581 /***********************************************************************
1582 * SetFilePointer (KERNEL32.492)
1583 */
1584 DWORD WINAPI SetFilePointer( HANDLE hFile, LONG distance, LONG *highword,
1585 DWORD method )
1586 {
1587 DWORD ret = 0xffffffff;
1588
1589 if (highword &&
1590 ((distance >= 0 && *highword != 0) || (distance < 0 && *highword != -1)))
1591 {
1592 FIXME("64-bit offsets not supported yet\n"
1593 "SetFilePointer(%08x,%08lx,%08lx,%08lx)\n",
1594 hFile,distance,*highword,method);
1595 SetLastError( ERROR_INVALID_PARAMETER );
1596 return ret;
1597 }
1598 TRACE("handle %d offset %ld origin %ld\n",
1599 hFile, distance, method );
1600
1601 SERVER_START_REQ
1602 {
1603 struct set_file_pointer_request *req = server_alloc_req( sizeof(*req), 0 );
1604 req->handle = hFile;
1605 req->low = distance;
1606 req->high = highword ? *highword : (distance >= 0) ? 0 : -1;
1607 /* FIXME: assumes 1:1 mapping between Windows and Unix seek constants */
1608 req->whence = method;
1609 SetLastError( 0 );
1610 if (!server_call( REQ_SET_FILE_POINTER ))
1611 {
1612 ret = req->new_low;
1613 if (highword) *highword = req->new_high;
1614 }
1615 }
1616 SERVER_END_REQ;
1617 return ret;
1618 }
1619
1620
1621 /***********************************************************************
1622 * _llseek16 (KERNEL.84)
1623 *
1624 * FIXME:
1625 * Seeking before the start of the file should be allowed for _llseek16,
1626 * but cause subsequent I/O operations to fail (cf. interrupt list)
1627 *
1628 */
1629 LONG WINAPI _llseek16( HFILE16 hFile, LONG lOffset, INT16 nOrigin )
1630 {
1631 return SetFilePointer( DosFileHandleToWin32Handle(hFile), lOffset, NULL, nOrigin );
1632 }
1633
1634
1635 /***********************************************************************
1636 * _llseek (KERNEL32.594)
1637 */
1638 LONG WINAPI _llseek( HFILE hFile, LONG lOffset, INT nOrigin )
1639 {
1640 return SetFilePointer( hFile, lOffset, NULL, nOrigin );
1641 }
1642
1643
1644 /***********************************************************************
1645 * _lopen16 (KERNEL.85)
1646 */
1647 HFILE16 WINAPI _lopen16( LPCSTR path, INT16 mode )
1648 {
1649 return Win32HandleToDosFileHandle( _lopen( path, mode ) );
1650 }
1651
1652
1653 /***********************************************************************
1654 * _lopen (KERNEL32.595)
1655 */
1656 HFILE WINAPI _lopen( LPCSTR path, INT mode )
1657 {
1658 DWORD access, sharing;
1659
1660 TRACE("('%s',%04x)\n", path, mode );
1661 FILE_ConvertOFMode( mode, &access, &sharing );
1662 return CreateFileA( path, access, sharing, NULL, OPEN_EXISTING, 0, 0 );
1663 }
1664
1665
1666 /***********************************************************************
1667 * _lwrite16 (KERNEL.86)
1668 */
1669 UINT16 WINAPI _lwrite16( HFILE16 hFile, LPCSTR buffer, UINT16 count )
1670 {
1671 return (UINT16)_hwrite( DosFileHandleToWin32Handle(hFile), buffer, (LONG)count );
1672 }
1673
1674 /***********************************************************************
1675 * _lwrite (KERNEL32.761)
1676 */
1677 UINT WINAPI _lwrite( HFILE hFile, LPCSTR buffer, UINT count )
1678 {
1679 return (UINT)_hwrite( hFile, buffer, (LONG)count );
1680 }
1681
1682
1683 /***********************************************************************
1684 * _hread16 (KERNEL.349)
1685 */
1686 LONG WINAPI _hread16( HFILE16 hFile, LPVOID buffer, LONG count)
1687 {
1688 return _lread( DosFileHandleToWin32Handle(hFile), buffer, count );
1689 }
1690
1691
1692 /***********************************************************************
1693 * _hread (KERNEL32.590)
1694 */
1695 LONG WINAPI _hread( HFILE hFile, LPVOID buffer, LONG count)
1696 {
1697 return _lread( hFile, buffer, count );
1698 }
1699
1700
1701 /***********************************************************************
1702 * _hwrite16 (KERNEL.350)
1703 */
1704 LONG WINAPI _hwrite16( HFILE16 hFile, LPCSTR buffer, LONG count )
1705 {
1706 return _hwrite( DosFileHandleToWin32Handle(hFile), buffer, count );
1707 }
1708
1709
1710 /***********************************************************************
1711 * _hwrite (KERNEL32.591)
1712 *
1713 * experimentation yields that _lwrite:
1714 * o truncates the file at the current position with
1715 * a 0 len write
1716 * o returns 0 on a 0 length write
1717 * o works with console handles
1718 *
1719 */
1720 LONG WINAPI _hwrite( HFILE handle, LPCSTR buffer, LONG count )
1721 {
1722 DWORD result;
1723
1724 TRACE("%d %p %ld\n", handle, buffer, count );
1725
1726 if (!count)
1727 {
1728 /* Expand or truncate at current position */
1729 if (!SetEndOfFile( handle )) return HFILE_ERROR;
1730 return 0;
1731 }
1732 if (!WriteFile( handle, buffer, count, &result, NULL ))
1733 return HFILE_ERROR;
1734 return result;
1735 }
1736
1737
1738 /***********************************************************************
1739 * SetHandleCount16 (KERNEL.199)
1740 */
1741 UINT16 WINAPI SetHandleCount16( UINT16 count )
1742 {
1743 HGLOBAL16 hPDB = GetCurrentPDB16();
1744 PDB16 *pdb = (PDB16 *)GlobalLock16( hPDB );
1745 BYTE *files = MapSL( pdb->fileHandlesPtr );
1746
1747 TRACE("(%d)\n", count );
1748
1749 if (count < 20) count = 20; /* No point in going below 20 */
1750 else if (count > 254) count = 254;
1751
1752 if (count == 20)
1753 {
1754 if (pdb->nbFiles > 20)
1755 {
1756 memcpy( pdb->fileHandles, files, 20 );
1757 GlobalFree16( pdb->hFileHandles );
1758 pdb->fileHandlesPtr = (SEGPTR)MAKELONG( 0x18,
1759 GlobalHandleToSel16( hPDB ) );
1760 pdb->hFileHandles = 0;
1761 pdb->nbFiles = 20;
1762 }
1763 }
1764 else /* More than 20, need a new file handles table */
1765 {
1766 BYTE *newfiles;
1767 HGLOBAL16 newhandle = GlobalAlloc16( GMEM_MOVEABLE, count );
1768 if (!newhandle)
1769 {
1770 SetLastError( ERROR_NOT_ENOUGH_MEMORY );
1771 return pdb->nbFiles;
1772 }
1773 newfiles = (BYTE *)GlobalLock16( newhandle );
1774
1775 if (count > pdb->nbFiles)
1776 {
1777 memcpy( newfiles, files, pdb->nbFiles );
1778 memset( newfiles + pdb->nbFiles, 0xff, count - pdb->nbFiles );
1779 }
1780 else memcpy( newfiles, files, count );
1781 if (pdb->nbFiles > 20) GlobalFree16( pdb->hFileHandles );
1782 pdb->fileHandlesPtr = K32WOWGlobalLock16( newhandle );
1783 pdb->hFileHandles = newhandle;
1784 pdb->nbFiles = count;
1785 }
1786 return pdb->nbFiles;
1787 }
1788
1789
1790 /*************************************************************************
1791 * SetHandleCount (KERNEL32.494)
1792 */
1793 UINT WINAPI SetHandleCount( UINT count )
1794 {
1795 return min( 256, count );
1796 }
1797
1798
1799 /***********************************************************************
1800 * FlushFileBuffers (KERNEL32.133)
1801 */
1802 BOOL WINAPI FlushFileBuffers( HANDLE hFile )
1803 {
1804 BOOL ret;
1805 SERVER_START_REQ
1806 {
1807 struct flush_file_request *req = server_alloc_req( sizeof(*req), 0 );
1808 req->handle = hFile;
1809 ret = !server_call( REQ_FLUSH_FILE );
1810 }
1811 SERVER_END_REQ;
1812 return ret;
1813 }
1814
1815
1816 /**************************************************************************
1817 * SetEndOfFile (KERNEL32.483)
1818 */
1819 BOOL WINAPI SetEndOfFile( HANDLE hFile )
1820 {
1821 BOOL ret;
1822 SERVER_START_REQ
1823 {
1824 struct truncate_file_request *req = server_alloc_req( sizeof(*req), 0 );
1825 req->handle = hFile;
1826 ret = !server_call( REQ_TRUNCATE_FILE );
1827 }
1828 SERVER_END_REQ;
1829 return ret;
1830 }
1831
1832
1833 /***********************************************************************
1834 * DeleteFile16 (KERNEL.146)
1835 */
1836 BOOL16 WINAPI DeleteFile16( LPCSTR path )
1837 {
1838 return DeleteFileA( path );
1839 }
1840
1841
1842 /***********************************************************************
1843 * DeleteFileA (KERNEL32.71)
1844 */
1845 BOOL WINAPI DeleteFileA( LPCSTR path )
1846 {
1847 DOS_FULL_NAME full_name;
1848
1849 TRACE("'%s'\n", path );
1850
1851 if (!*path)
1852 {
1853 ERR("Empty path passed\n");
1854 return FALSE;
1855 }
1856 if (DOSFS_GetDevice( path ))
1857 {
1858 WARN("cannot remove DOS device '%s'!\n", path);
1859 SetLastError( ERROR_FILE_NOT_FOUND );
1860 return FALSE;
1861 }
1862
1863 if (!DOSFS_GetFullName( path, TRUE, &full_name )) return FALSE;
1864 if (unlink( full_name.long_name ) == -1)
1865 {
1866 FILE_SetDosError();
1867 return FALSE;
1868 }
1869 return TRUE;
1870 }
1871
1872
1873 /***********************************************************************
1874 * DeleteFileW (KERNEL32.72)
1875 */
1876 BOOL WINAPI DeleteFileW( LPCWSTR path )
1877 {
1878 LPSTR xpath = HEAP_strdupWtoA( GetProcessHeap(), 0, path );
1879 BOOL ret = DeleteFileA( xpath );
1880 HeapFree( GetProcessHeap(), 0, xpath );
1881 return ret;
1882 }
1883
1884
1885 /***********************************************************************
1886 * GetFileType (KERNEL32.222)
1887 */
1888 DWORD WINAPI GetFileType( HANDLE hFile )
1889 {
1890 DWORD ret = FILE_TYPE_UNKNOWN;
1891 SERVER_START_REQ
1892 {
1893 struct get_file_info_request *req = server_alloc_req( sizeof(*req), 0 );
1894 req->handle = hFile;
1895 if (!server_call( REQ_GET_FILE_INFO )) ret = req->type;
1896 }
1897 SERVER_END_REQ;
1898 return ret;
1899 }
1900
1901
1902 /**************************************************************************
1903 * MoveFileExA (KERNEL32.???)
1904 */
1905 BOOL WINAPI MoveFileExA( LPCSTR fn1, LPCSTR fn2, DWORD flag )
1906 {
1907 DOS_FULL_NAME full_name1, full_name2;
1908
1909 TRACE("(%s,%s,%04lx)\n", fn1, fn2, flag);
1910
1911 if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE;
1912
1913 if (fn2) /* !fn2 means delete fn1 */
1914 {
1915 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 ))
1916 {
1917 /* target exists, check if we may overwrite */
1918 if (!(flag & MOVEFILE_REPLACE_EXISTING))
1919 {
1920 /* FIXME: Use right error code */
1921 SetLastError( ERROR_ACCESS_DENIED );
1922 return FALSE;
1923 }
1924 }
1925 else if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE;
1926
1927 /* Source name and target path are valid */
1928
1929 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
1930 {
1931 /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
1932 Perhaps we should queue these command and execute it
1933 when exiting... What about using on_exit(2)
1934 */
1935 FIXME("Please move existing file '%s' to file '%s' when Wine has finished\n",
1936 full_name1.long_name, full_name2.long_name);
1937 return TRUE;
1938 }
1939
1940 if (full_name1.drive != full_name2.drive)
1941 {
1942 /* use copy, if allowed */
1943 if (!(flag & MOVEFILE_COPY_ALLOWED))
1944 {
1945 /* FIXME: Use right error code */
1946 SetLastError( ERROR_FILE_EXISTS );
1947 return FALSE;
1948 }
1949 return CopyFileA( fn1, fn2, !(flag & MOVEFILE_REPLACE_EXISTING) );
1950 }
1951 if (rename( full_name1.long_name, full_name2.long_name ) == -1)
1952 {
1953 FILE_SetDosError();
1954 return FALSE;
1955 }
1956 return TRUE;
1957 }
1958 else /* fn2 == NULL means delete source */
1959 {
1960 if (flag & MOVEFILE_DELAY_UNTIL_REBOOT)
1961 {
1962 if (flag & MOVEFILE_COPY_ALLOWED) {
1963 WARN("Illegal flag\n");
1964 SetLastError( ERROR_GEN_FAILURE );
1965 return FALSE;
1966 }
1967 /* FIXME: (bon@elektron.ikp.physik.th-darmstadt.de 970706)
1968 Perhaps we should queue these command and execute it
1969 when exiting... What about using on_exit(2)
1970 */
1971 FIXME("Please delete file '%s' when Wine has finished\n",
1972 full_name1.long_name);
1973 return TRUE;
1974 }
1975
1976 if (unlink( full_name1.long_name ) == -1)
1977 {
1978 FILE_SetDosError();
1979 return FALSE;
1980 }
1981 return TRUE; /* successfully deleted */
1982 }
1983 }
1984
1985 /**************************************************************************
1986 * MoveFileExW (KERNEL32.???)
1987 */
1988 BOOL WINAPI MoveFileExW( LPCWSTR fn1, LPCWSTR fn2, DWORD flag )
1989 {
1990 LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
1991 LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
1992 BOOL res = MoveFileExA( afn1, afn2, flag );
1993 HeapFree( GetProcessHeap(), 0, afn1 );
1994 HeapFree( GetProcessHeap(), 0, afn2 );
1995 return res;
1996 }
1997
1998
1999 /**************************************************************************
2000 * MoveFileA (KERNEL32.387)
2001 *
2002 * Move file or directory
2003 */
2004 BOOL WINAPI MoveFileA( LPCSTR fn1, LPCSTR fn2 )
2005 {
2006 DOS_FULL_NAME full_name1, full_name2;
2007 struct stat fstat;
2008
2009 TRACE("(%s,%s)\n", fn1, fn2 );
2010
2011 if (!DOSFS_GetFullName( fn1, TRUE, &full_name1 )) return FALSE;
2012 if (DOSFS_GetFullName( fn2, TRUE, &full_name2 )) {
2013 /* The new name must not already exist */
2014 SetLastError(ERROR_ALREADY_EXISTS);
2015 return FALSE;
2016 }
2017 if (!DOSFS_GetFullName( fn2, FALSE, &full_name2 )) return FALSE;
2018
2019 if (full_name1.drive == full_name2.drive) /* move */
2020 if (rename( full_name1.long_name, full_name2.long_name ) == -1)
2021 {
2022 FILE_SetDosError();
2023 return FALSE;
2024 }
2025 else return TRUE;
2026 else /*copy */ {
2027 if (stat( full_name1.long_name, &fstat ))
2028 {
2029 WARN("Invalid source file %s\n",
2030 full_name1.long_name);
2031 FILE_SetDosError();
2032 return FALSE;
2033 }
2034 if (S_ISDIR(fstat.st_mode)) {
2035 /* No Move for directories across file systems */
2036 /* FIXME: Use right error code */
2037 SetLastError( ERROR_GEN_FAILURE );
2038 return FALSE;
2039 }
2040 else
2041 return CopyFileA(fn1, fn2, TRUE); /*fail, if exist */
2042 }
2043 }
2044
2045
2046 /**************************************************************************
2047 * MoveFileW (KERNEL32.390)
2048 */
2049 BOOL WINAPI MoveFileW( LPCWSTR fn1, LPCWSTR fn2 )
2050 {
2051 LPSTR afn1 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn1 );
2052 LPSTR afn2 = HEAP_strdupWtoA( GetProcessHeap(), 0, fn2 );
2053 BOOL res = MoveFileA( afn1, afn2 );
2054 HeapFree( GetProcessHeap(), 0, afn1 );
2055 HeapFree( GetProcessHeap(), 0, afn2 );
2056 return res;
2057 }
2058
2059
2060 /**************************************************************************
2061 * CopyFileA (KERNEL32.36)
2062 */
2063 BOOL WINAPI CopyFileA( LPCSTR source, LPCSTR dest, BOOL fail_if_exists )
2064 {
2065 HFILE h1, h2;
2066 BY_HANDLE_FILE_INFORMATION info;
2067 UINT count;
2068 BOOL ret = FALSE;
2069 int mode;
2070 char buffer[2048];
2071
2072 if ((h1 = _lopen( source, OF_READ )) == HFILE_ERROR) return FALSE;
2073 if (!GetFileInformationByHandle( h1, &info ))
2074 {
2075 CloseHandle( h1 );
2076 return FALSE;
2077 }
2078 mode = (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) ? 0444 : 0666;
2079 if ((h2 = CreateFileA( dest, GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_WRITE, NULL,
2080 fail_if_exists ? CREATE_NEW : CREATE_ALWAYS,
2081 info.dwFileAttributes, h1 )) == INVALID_HANDLE_VALUE)
2082 {
2083 CloseHandle( h1 );
2084 return FALSE;
2085 }
2086 while ((count = _lread( h1, buffer, sizeof(buffer) )) > 0)
2087 {
2088 char *p = buffer;
2089 while (count > 0)
2090 {
2091 INT res = _lwrite( h2, p, count );
2092 if (res <= 0) goto done;
2093 p += res;
2094 count -= res;
2095 }
2096 }
2097 ret = TRUE;
2098 done:
2099 CloseHandle( h1 );
2100 CloseHandle( h2 );
2101 return ret;
2102 }
2103
2104
2105 /**************************************************************************
2106 * CopyFileW (KERNEL32.37)
2107 */
2108 BOOL WINAPI CopyFileW( LPCWSTR source, LPCWSTR dest, BOOL fail_if_exists)
2109 {
2110 LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, source );
2111 LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, dest );
2112 BOOL ret = CopyFileA( sourceA, destA, fail_if_exists );
2113 HeapFree( GetProcessHeap(), 0, sourceA );
2114 HeapFree( GetProcessHeap(), 0, destA );
2115 return ret;
2116 }
2117
2118
2119 /**************************************************************************
2120 * CopyFileExA (KERNEL32.858)
2121 *
2122 * This implementation ignores most of the extra parameters passed-in into
2123 * the "ex" version of the method and calls the CopyFile method.
2124 * It will have to be fixed eventually.
2125 */
2126 BOOL WINAPI CopyFileExA(LPCSTR sourceFilename,
2127 LPCSTR destFilename,
2128 LPPROGRESS_ROUTINE progressRoutine,
2129 LPVOID appData,
2130 LPBOOL cancelFlagPointer,
2131 DWORD copyFlags)
2132 {
2133 BOOL failIfExists = FALSE;
2134
2135 /*
2136 * Interpret the only flag that CopyFile can interpret.
2137 */
2138 if ( (copyFlags & COPY_FILE_FAIL_IF_EXISTS) != 0)
2139 {
2140 failIfExists = TRUE;
2141 }
2142
2143 return CopyFileA(sourceFilename, destFilename, failIfExists);
2144 }
2145
2146 /**************************************************************************
2147 * CopyFileExW (KERNEL32.859)
2148 */
2149 BOOL WINAPI CopyFileExW(LPCWSTR sourceFilename,
2150 LPCWSTR destFilename,
2151 LPPROGRESS_ROUTINE progressRoutine,
2152 LPVOID appData,
2153 LPBOOL cancelFlagPointer,
2154 DWORD copyFlags)
2155 {
2156 LPSTR sourceA = HEAP_strdupWtoA( GetProcessHeap(), 0, sourceFilename );
2157 LPSTR destA = HEAP_strdupWtoA( GetProcessHeap(), 0, destFilename );
2158
2159 BOOL ret = CopyFileExA(sourceA,
2160 destA,
2161 progressRoutine,
2162 appData,
2163 cancelFlagPointer,
2164 copyFlags);
2165
2166 HeapFree( GetProcessHeap(), 0, sourceA );
2167 HeapFree( GetProcessHeap(), 0, destA );
2168
2169 return ret;
2170 }
2171
2172
2173 /***********************************************************************
2174 * SetFileTime (KERNEL32.650)
2175 */
2176 BOOL WINAPI SetFileTime( HANDLE hFile,
2177 const FILETIME *lpCreationTime,
2178 const FILETIME *lpLastAccessTime,
2179 const FILETIME *lpLastWriteTime )
2180 {
2181 BOOL ret;
2182 SERVER_START_REQ
2183 {
2184 struct set_file_time_request *req = server_alloc_req( sizeof(*req), 0 );
2185 req->handle = hFile;
2186 if (lpLastAccessTime)
2187 RtlTimeToSecondsSince1970( lpLastAccessTime, (DWORD *)&req->access_time );
2188 else
2189 req->access_time = 0; /* FIXME */
2190 if (lpLastWriteTime)
2191 RtlTimeToSecondsSince1970( lpLastWriteTime, (DWORD *)&req->write_time );
2192 else
2193 req->write_time = 0; /* FIXME */
2194 ret = !server_call( REQ_SET_FILE_TIME );
2195 }
2196 SERVER_END_REQ;
2197 return ret;
2198 }
2199
2200
2201 /**************************************************************************
2202 * LockFile (KERNEL32.511)
2203 */
2204 BOOL WINAPI LockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
2205 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh )
2206 {
2207 BOOL ret;
2208 SERVER_START_REQ
2209 {
2210 struct lock_file_request *req = server_alloc_req( sizeof(*req), 0 );
2211
2212 req->handle = hFile;
2213 req->offset_low = dwFileOffsetLow;
2214 req->offset_high = dwFileOffsetHigh;
2215 req->count_low = nNumberOfBytesToLockLow;
2216 req->count_high = nNumberOfBytesToLockHigh;
2217 ret = !server_call( REQ_LOCK_FILE );
2218 }
2219 SERVER_END_REQ;
2220 return ret;
2221 }
2222
2223 /**************************************************************************
2224 * LockFileEx [KERNEL32.512]
2225 *
2226 * Locks a byte range within an open file for shared or exclusive access.
2227 *
2228 * RETURNS
2229 * success: TRUE
2230 * failure: FALSE
2231 * NOTES
2232 *
2233 * Per Microsoft docs, the third parameter (reserved) must be set to 0.
2234 */
2235 BOOL WINAPI LockFileEx( HANDLE hFile, DWORD flags, DWORD reserved,
2236 DWORD nNumberOfBytesToLockLow, DWORD nNumberOfBytesToLockHigh,
2237 LPOVERLAPPED pOverlapped )
2238 {
2239 FIXME("hFile=%d,flags=%ld,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
2240 hFile, flags, reserved, nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh,
2241 pOverlapped);
2242 if (reserved == 0)
2243 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2244 else
2245 {
2246 ERR("reserved == %ld: Supposed to be 0??\n", reserved);
2247 SetLastError(ERROR_INVALID_PARAMETER);
2248 }
2249
2250 return FALSE;
2251 }
2252
2253
2254 /**************************************************************************
2255 * UnlockFile (KERNEL32.703)
2256 */
2257 BOOL WINAPI UnlockFile( HANDLE hFile, DWORD dwFileOffsetLow, DWORD dwFileOffsetHigh,
2258 DWORD nNumberOfBytesToUnlockLow, DWORD nNumberOfBytesToUnlockHigh )
2259 {
2260 BOOL ret;
2261 SERVER_START_REQ
2262 {
2263 struct unlock_file_request *req = server_alloc_req( sizeof(*req), 0 );
2264
2265 req->handle = hFile;
2266 req->offset_low = dwFileOffsetLow;
2267 req->offset_high = dwFileOffsetHigh;
2268 req->count_low = nNumberOfBytesToUnlockLow;
2269 req->count_high = nNumberOfBytesToUnlockHigh;
2270 ret = !server_call( REQ_UNLOCK_FILE );
2271 }
2272 SERVER_END_REQ;
2273 return ret;
2274 }
2275
2276
2277 /**************************************************************************
2278 * UnlockFileEx (KERNEL32.705)
2279 */
2280 BOOL WINAPI UnlockFileEx(
2281 HFILE hFile,
2282 DWORD dwReserved,
2283 DWORD nNumberOfBytesToUnlockLow,
2284 DWORD nNumberOfBytesToUnlockHigh,
2285 LPOVERLAPPED lpOverlapped
2286 )
2287 {
2288 FIXME("hFile=%d,reserved=%ld,lowbytes=%ld,highbytes=%ld,overlapped=%p: stub.\n",
2289 hFile, dwReserved, nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh,
2290 lpOverlapped);
2291 if (dwReserved == 0)
2292 SetLastError(ERROR_CALL_NOT_IMPLEMENTED);
2293 else
2294 {
2295 ERR("reserved == %ld: Supposed to be 0??\n", dwReserved);
2296 SetLastError(ERROR_INVALID_PARAMETER);
2297 }
2298
2299 return FALSE;
2300 }
2301
2302
2303 #if 0
2304
2305 struct DOS_FILE_LOCK {
2306 struct DOS_FILE_LOCK * next;
2307 DWORD base;
2308 DWORD len;
2309 DWORD processId;
2310 FILE_OBJECT * dos_file;
2311 /* char * unix_name;*/
2312 };
2313
2314 typedef struct DOS_FILE_LOCK DOS_FILE_LOCK;
2315
2316 static DOS_FILE_LOCK *locks = NULL;
2317 static void DOS_RemoveFileLocks(FILE_OBJECT *file);
2318
2319
2320 /* Locks need to be mirrored because unix file locking is based
2321 * on the pid. Inside of wine there can be multiple WINE processes
2322 * that share the same unix pid.
2323 * Read's and writes should check these locks also - not sure
2324 * how critical that is at this point (FIXME).
2325 */
2326
2327 static BOOL DOS_AddLock(FILE_OBJECT *file, struct flock *f)
2328 {
2329 DOS_FILE_LOCK *curr;
2330 DWORD processId;
2331
2332 processId = GetCurrentProcessId();
2333
2334 /* check if lock overlaps a current lock for the same file */
2335 #if 0
2336 for (curr = locks; curr; curr = curr->next) {
2337 if (strcmp(curr->unix_name, file->unix_name) == 0) {
2338 if ((f->l_start == curr->base) && (f->l_len == curr->len))
2339 return TRUE;/* region is identic */
2340 if ((f->l_start < (curr->base + curr->len)) &&
2341 ((f->l_start + f->l_len) > curr->base)) {
2342 /* region overlaps */
2343 return FALSE;
2344 }
2345 }
2346 }
2347 #endif
2348
2349 curr = HeapAlloc( GetProcessHeap(), 0, sizeof(DOS_FILE_LOCK) );
2350 curr->processId = GetCurrentProcessId();
2351 curr->base = f->l_start;
2352 curr->len = f->l_len;
2353 /* curr->unix_name = HEAP_strdupA( GetProcessHeap(), 0, file->unix_name);*/
2354 curr->next = locks;
2355 curr->dos_file = file;
2356 locks = curr;
2357 return TRUE;
2358 }
2359
2360 static void DOS_RemoveFileLocks(FILE_OBJECT *file)
2361 {
2362 DWORD processId;
2363 DOS_FILE_LOCK **curr;
2364 DOS_FILE_LOCK *rem;
2365
2366 processId = GetCurrentProcessId();
2367 curr = &locks;
2368 while (*curr) {
2369 if ((*curr)->dos_file == file) {
2370 rem = *curr;
2371 *curr = (*curr)->next;
2372 /* HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
2373 HeapFree( GetProcessHeap(), 0, rem );
2374 }
2375 else
2376 curr = &(*curr)->next;
2377 }
2378 }
2379
2380 static BOOL DOS_RemoveLock(FILE_OBJECT *file, struct flock *f)
2381 {
2382 DWORD processId;
2383 DOS_FILE_LOCK **curr;
2384 DOS_FILE_LOCK *rem;
2385
2386 processId = GetCurrentProcessId();
2387 for (curr = &locks; *curr; curr = &(*curr)->next) {
2388 if ((*curr)->processId == processId &&
2389 (*curr)->dos_file == file &&
2390 (*curr)->base == f->l_start &&
2391 (*curr)->len == f->l_len) {
2392 /* this is the same lock */
2393 rem = *curr;
2394 *curr = (*curr)->next;
2395 /* HeapFree( GetProcessHeap(), 0, rem->unix_name );*/
2396 HeapFree( GetProcessHeap(), 0, rem );
2397 return TRUE;
2398 }
2399 }
2400 /* no matching lock found */
2401 return FALSE;
2402 }
2403
2404
2405 /**************************************************************************
2406 * LockFile (KERNEL32.511)
2407 */
2408 BOOL WINAPI LockFile(
2409 HFILE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
2410 DWORD nNumberOfBytesToLockLow,DWORD nNumberOfBytesToLockHigh )
2411 {
2412 struct flock f;
2413 FILE_OBJECT *file;
2414
2415 TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
2416 hFile, dwFileOffsetLow, dwFileOffsetHigh,
2417 nNumberOfBytesToLockLow, nNumberOfBytesToLockHigh);
2418
2419 if (dwFileOffsetHigh || nNumberOfBytesToLockHigh) {
2420 FIXME("Unimplemented bytes > 32bits\n");
2421 return FALSE;
2422 }
2423
2424 f.l_start = dwFileOffsetLow;
2425 f.l_len = nNumberOfBytesToLockLow;
2426 f.l_whence = SEEK_SET;
2427 f.l_pid = 0;
2428 f.l_type = F_WRLCK;
2429
2430 if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
2431
2432 /* shadow locks internally */
2433 if (!DOS_AddLock(file, &f)) {
2434 SetLastError( ERROR_LOCK_VIOLATION );
2435 return FALSE;
2436 }
2437
2438 /* FIXME: Unix locking commented out for now, doesn't work with Excel */
2439 #ifdef USE_UNIX_LOCKS
2440 if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
2441 if (errno == EACCES || errno == EAGAIN) {
2442 SetLastError( ERROR_LOCK_VIOLATION );
2443 }
2444 else {
2445 FILE_SetDosError();
2446 }
2447 /* remove our internal copy of the lock */
2448 DOS_RemoveLock(file, &f);
2449 return FALSE;
2450 }
2451 #endif
2452 return TRUE;
2453 }
2454
2455
2456 /**************************************************************************
2457 * UnlockFile (KERNEL32.703)
2458 */
2459 BOOL WINAPI UnlockFile(
2460 HFILE hFile,DWORD dwFileOffsetLow,DWORD dwFileOffsetHigh,
2461 DWORD nNumberOfBytesToUnlockLow,DWORD nNumberOfBytesToUnlockHigh )
2462 {
2463 FILE_OBJECT *file;
2464 struct flock f;
2465
2466 TRACE("handle %d offsetlow=%ld offsethigh=%ld nbyteslow=%ld nbyteshigh=%ld\n",
2467 hFile, dwFileOffsetLow, dwFileOffsetHigh,
2468 nNumberOfBytesToUnlockLow, nNumberOfBytesToUnlockHigh);
2469
2470 if (dwFileOffsetHigh || nNumberOfBytesToUnlockHigh) {
2471 WARN("Unimplemented bytes > 32bits\n");
2472 return FALSE;
2473 }
2474
2475 f.l_start = dwFileOffsetLow;
2476 f.l_len = nNumberOfBytesToUnlockLow;
2477 f.l_whence = SEEK_SET;
2478 f.l_pid = 0;
2479 f.l_type = F_UNLCK;
2480
2481 if (!(file = FILE_GetFile(hFile,0,NULL))) return FALSE;
2482
2483 DOS_RemoveLock(file, &f); /* ok if fails - may be another wine */
2484
2485 /* FIXME: Unix locking commented out for now, doesn't work with Excel */
2486 #ifdef USE_UNIX_LOCKS
2487 if (fcntl(file->unix_handle, F_SETLK, &f) == -1) {
2488 FILE_SetDosError();
2489 return FALSE;
2490 }
2491 #endif
2492 return TRUE;
2493 }
2494 #endif
2495
2496 /**************************************************************************
2497 * GetFileAttributesExA [KERNEL32.874]
2498 */
2499 BOOL WINAPI GetFileAttributesExA(
2500 LPCSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
2501 LPVOID lpFileInformation)
2502 {
2503 DOS_FULL_NAME full_name;
2504 BY_HANDLE_FILE_INFORMATION info;
2505
2506 if (lpFileName == NULL) return FALSE;
2507 if (lpFileInformation == NULL) return FALSE;
2508
2509 if (fInfoLevelId == GetFileExInfoStandard) {
2510 LPWIN32_FILE_ATTRIBUTE_DATA lpFad =
2511 (LPWIN32_FILE_ATTRIBUTE_DATA) lpFileInformation;
2512 if (!DOSFS_GetFullName( lpFileName, TRUE, &full_name )) return FALSE;
2513 if (!FILE_Stat( full_name.long_name, &info )) return FALSE;
2514
2515 lpFad->dwFileAttributes = info.dwFileAttributes;
2516 lpFad->ftCreationTime = info.ftCreationTime;
2517 lpFad->ftLastAccessTime = info.ftLastAccessTime;
2518 lpFad->ftLastWriteTime = info.ftLastWriteTime;
2519 lpFad->nFileSizeHigh = info.nFileSizeHigh;
2520 lpFad->nFileSizeLow = info.nFileSizeLow;
2521 }
2522 else {
2523 FIXME("invalid info level %d!\n", fInfoLevelId);
2524 return FALSE;
2525 }
2526
2527 return TRUE;
2528 }
2529
2530
2531 /**************************************************************************
2532 * GetFileAttributesExW [KERNEL32.875]
2533 */
2534 BOOL WINAPI GetFileAttributesExW(
2535 LPCWSTR lpFileName, GET_FILEEX_INFO_LEVELS fInfoLevelId,
2536 LPVOID lpFileInformation)
2537 {
2538 LPSTR nameA = HEAP_strdupWtoA( GetProcessHeap(), 0, lpFileName );
2539 BOOL res =
2540 GetFileAttributesExA( nameA, fInfoLevelId, lpFileInformation);
2541 HeapFree( GetProcessHeap(), 0, nameA );
2542 return res;
2543 }
Work in progress by Kai Blin